上一篇：JS数据结构与算法_树

写在前面

这是《进修JavaScript数据结构与算法》的末了一篇博客，也是在口试中常常会被问到的一部分内容：排序和搜刮。在这篇博客之前，我往往看到排序头就是大的，内心想着相似“冒泡排序，两层遍历啪啪啪“就完事了，然后再也无意去深入研究排序相干的问题了。假如你也有相似的阅历，愿望下面的内容对你有肯定协助

一、预备

在进入正题之前，先预备几个基本的函数

（1）交流数组两个元素

function swap(arr, sourceIndex, targetIndex) {
  let temp = arr[sourceIndex];
  arr[sourceIndex] = arr[targetIndex];
  arr[targetIndex] = temp;
}

（2）疾速天生0~N的数组 可点击检察更多天生要领

function createArr(length) {
  return Array.from({length}, (_, i) => i);
}

（3）洗牌函数

洗牌函数可疾速打乱数组，罕见的用法如切换音乐播放递次

function shuffle(arr) {
  for (let i = 0; i < arr.length; i += 1) {
    const rand = Math.floor(Math.random() * (i + 1));
    if (rand !== i) {
      swap(arr, i, rand);
    }
  }
  return arr;
}

二、排序

罕见排序算法能够分为两大类：

• 比较类排序：经由过程比较来决议元素间的相对序次，因为其时候庞杂度不能打破O(nlogn)，因此也称为非线性时候比较类排序
• 非比较类排序：不经由过程比较来决议元素间的相对序次，它能够打破基于比较排序的时候下界，以线性时候运转，因此也称为线性时候非比较类排序

在本篇博客中，仅对比较类排序的几种排序体式格局举行进修引见

2.1 冒泡排序

冒泡排序是一切排序算法中最简朴的，一般也是我们进修排序的入门要领。然则，从运转时候的角度来看，冒泡排序是最差的一种排序体式格局。

中心：比较任何两个相邻的项，假如第一个比第二个大，则交流它们。元素项向上挪动至准确的递次，就好像气泡升至外表一样，冒泡排序因此得名

动图：

注重：第一层遍历找出盈余元素的最大值，至指定位置【顺次冒泡出最大值】

代码：

function bubbleSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len; i += 1) {
    for (let j = 0; j < len - 1 - i; j += 1) {
      if (arr[j] > arr[j + 1]) { // 比较相邻元素
        swap(arr, j, j + 1);
      }
    }
  }
  return arr;
}

2.2 挑选排序

挑选排序是一种旧址比较排序算法。

中心：首先在未排序序列中找到最小元素，存放到排序序列的肇端位置，然后，再从盈余未排序元素中继承寻觅最小元素，然后放到已排序序列的末端。以此类推，直到一切元素均排序终了

动图：

注重：第一层遍历找出盈余元素最小值的索引，然后交流当前位置和最小值索引值【顺次找到最小值】

代码：

function selectionSort(arr) {
  const len = arr.length;
  let minIndex;
  for (let i = 0; i < len - 1; i += 1) {
    minIndex = i;
    for (let j = i + 1; j < len; j += 1) {
      if (arr[minIndex] > arr[j]) {
        minIndex = j; // 寻觅最小值对应的索引
      }
    }
    if (minIndex === i) continue;
    swap(arr, minIndex, i);
  }
  return arr;
}

2.3 插进去排序

插进去排序的比较递次不同于冒泡排序和挑选排序，插进去排序的比较递次是当前项向前比较。

中心：经由过程构建有序序列，关于未排序数据，在已排序序列中从后向前扫描，找到响应位置并插进去

动图：

注重：从第二项最先，顺次向前比较，保证当前项之前的序列是递次排列

代码：

function insertionSort(arr) {
  const len = arr.length;
  let current, pointer;
  for (let i = 1; i < len; i += 1) {
    current = arr[i];
    pointer = i;
    while(pointer >= 0 && current < arr[pointer - 1]) { // 每次向前比较
      arr[pointer] = arr[pointer - 1]; // 前一项大于指针项，则向前挪动一项
      pointer -= 1;
    }
    arr[pointer] = current; // 指针项还原成当前项
  }
  return arr;
}

2.4 兼并排序

兼并排序和疾速排序相较于上面三种排序算法在现实中更具有可行性（在第四小节我们会经由过程实践庞杂度来比较这几种排序算法）

JavaScript的
Array类定义了一个
sort函数(
Array.prototype.sort)用以排序
JavaScript数组。
ECMAScript没有定义用哪一个排序算法，所以浏览器厂商能够自行去完成算法。比方，
Mozilla Firefox运用
兼并排序作为
Array.prototype.sort的完成，而
Chrome运用了一个
疾速排序的变体

兼并排序是一种分治算法。其头脑是将原始数组切分红较小的数组，直到每一个小数组只要一 个位置，接着将小数组兼并成较大的数组，直到末了只要一个排序终了的大数组。因此须要用到递归

中心：兼并排序，拆分红摆布两块数组，离别排序后兼并

动图：

注重：递归中最小的摆布数组比较为单个元素的数组，因此在较上层多个元素对比时，摆布两个数组肯定是递次的

代码：

function mergeSort(arr) {
  const len = arr.length;

  if (len < 2) return arr; // 递归的住手前提
  const middle = Math.floor(len / 2); // 拆分摆布数组
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);
  
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) { // 将摆布两侧比较后举行兼并
  const ret = [];

  while (left.length && right.length) {
    if (left[0] > right[0]) {
      ret.push(right.shift());
    } else {
      ret.push(left.shift());
    }
  }

  while (left.length) {
    ret.push(left.shift());
  }
  while (right.length) {
    ret.push(right.shift());
  }

  return ret;
}

2.5 疾速排序

疾速排序也许是最经常使用的排序算法了。它的庞杂度为O(nlogn)，且它的机能一般比其他的复 杂度为O(nlogn)的排序算法要好。和兼并排序一样，疾速排序也运用分治的要领，将原始数组分为较小的数组

中心：分治算法，以参考值为界线，将比它小的和大的值拆开

动图：

注重：每一次遍历筛选出比基准点小的值

代码：

function quickSort(arr, left = 0, right = arr.length - 1) {
  // left和right默以为数组首尾
  if (left < right) {
    let partitionIndex = partition(arr, left, right);
    quickSort(arr, left, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  let pivot = left;
  let index = left + 1; // 满足比较前提的顺次放在支解点后

  for (let i = index; i <= right; i += 1) {
    if (arr[i] < arr[pivot]) {
      swap(arr, i, index);
      index += 1;
    }
  }
  swap(arr, index - 1, pivot); // 交流递次时，以末了一名替代分开项
  return index - 1;
}

三、搜刮算法

3.1 递次搜刮

递次或线性搜刮是最基本的搜刮算法。它的机制是，将每一个数据结构中的元素和我们要找的元素做比较。递次搜刮是最低效的一种搜刮算法。

function findItem(item, arr) {
  for (let i = 0; i < arr.length; i += 1) {
    if (item === arr[i]) {
      return i;
    }
  }
  return -1;
}

3.2 二分搜刮

二分搜刮请求被搜刮的数据结构已排序。以下是该算法遵照的步骤：

1. 挑选数组的中心值
2. 假如选中值是待搜刮值，那末算法实行终了
3. 假如待搜刮值比选中值要小，则返回步骤1在选中值左侧的子数组中寻觅
4. 假如待搜刮值比选中值要大，则返回步骤1在选中值右侧的子数组中寻觅

function binarySearch(item, arr) {
  arr = quickSort(arr); // 排序

  let low = 0;
  let high = arr.length - 1;
  let mid;

  while (low <= high) {
    min = Math.floor((low + high) / 2);
    if (arr[mid] < item) {
      low = mid + 1;
    } else if (arr[mid] > item) {
      high = mid - 1;
    } else {
      return mid;
    }
  }
  return -1;
}

四、算法庞杂度

4.1 明白大O示意法

大O示意法用于形貌算法的机能和庞杂水平。剖析算法时，经常碰到一下几类函数

（1）O(1)

function increment(num){
    return ++num;
}

实行时候和参数无关。因此说，上述函数的庞杂度是O(1)(常数)

（2）O(n)

以递次搜刮函数为例，查找元素须要遍历全部数组，直到找到该元素住手。函数实行的总开支取决于数组元素的个数(数组大小)，而且也和搜刮的值有关。然则函数庞杂度取决于最坏的状况：假如数组大小是10，开支就是10；假如数组大小是1000，开支就是1000。这类函数的时候庞杂度是O(n)，n是(输入)数组的大小

（3）O(n2)

以冒泡排序为例，在未优化的状况下，每次排序均需举行n*n次实行。时候庞杂度为O(n2)

时候庞杂度
O(n)的代码只要一层轮回，而
O(n2)的代码有双层嵌套轮回。如 果算法有三层遍历数组的嵌套轮回，它的时候庞杂度极可能就是
O(n3)

4.2 时候庞杂度比较

（1）经常使用数据结构时候庞杂度

（2）排序算法时候庞杂度

上一篇：JS数据结构与算法_树
参考：十大典范排序算法（动图演示）