前言

随着面试越来越卷，前端也要开始面算法，如果我们想要跳槽不光要准备八股文，还要刷一些算法题，在前端算法有排序算法，即便日常开发中大概率用不到，我们还是要知道各个排序算法的实现方式。

排序算法

首先推荐一个算法可视化网站——VisuAlgo，网站会以动画的形式复现排序的每一步，能够帮助我们快速理解。

有了好工具，现在我们还是先用文字来了解或者说复习排序算法。

冒泡排序

冒泡排序最基础的排序算法，步骤如下：

1. 从第一个元素开始，比较相邻两个元素，如果前面大于后面的元素就交换位置。
2. 重复上面步骤直到所有的元素都循环过。 冒泡排序还是非常容易理解的，要想实现上述步骤我们就要用到两层循环：

    bubbleSort(arr) {
    for (let i = 0; i < arr.length-1; i++) {
      for (let j = 0; j < arr.length - i- 1; j++) {
        if (arr[j] > arr[j + 1]) {
          //解构赋值进行位置交换
          [arr[j + 1], arr[j]] = [arr[j], arr[j + 1]];
        }
      }
    }
  }

选择排序

选择排序就是在一次循环中找到最小的一个元素，进行位置互换，具体步骤如下：

1. 把第一个当成最小值，然后与后面元素进行比对，如果找到比最小值小的就当位置互换。
2. 继续循环剩余元素，将位置互换，直至所有元素都对比过。

     selectSort(arr) {
     let minIndex
    for (let i = 0; i < arr.length - 1; i++) {
      minIndex = i
      for (let j = i + 1; j < arr.length; j++) {
        if (arr[j] < arr[minIndex]) {
          minIndex = j
        }
      }
      [arr[minIndex], arr[i]] = [arr[i], arr[minIndex]];
    }
  }

插入排序

插入排序是假设数组已经排好序，然后循环某个元素，把该元素插入到比它大的元素前面：

1. 从第一位元素开始循环，从剩余元素中找到比当前元素大的，然后插入此位置。
2. 如果两者当前元素与某个元素相等就将当前元素放到该元素后面。

   insertionSort(arr) {
    let currentItem;
    let preIndex;
    for (let i = 1; i < arr.length; i++) {
      preIndex = i - 1;
      currentItem = arr[i];
      while (preIndex >= 0 && arr[preIndex] > currentItem) {
        arr[preIndex + 1] = arr[preIndex];
        preIndex--;
      }
      arr[preIndex + 1] = currentItem;
    }
  }

快速排序

快速排序算法的特点就是快，要比其他排序算法处理的时间复杂度小，该算法利用了分治策略（简单来说就是将大问题化为小问题，从小问题开始向上解决，最终得到效果），分治法是经典的策略，感兴趣的可以查阅资料详细了解以下。

1. 选出一个元素当成基准，将比基准小的分到一起，再把基准大的分到一起，这时候基准就在中间了。
2. 利用递归把分区的两部分数列继续进行该排序操作。

   //快速排序
  quickSort(arr, left = 0, right = 0) {
    let pivotIndex = left + 1;
    if (left < right) {
      for (let i = pivotIndex; i < right; i++) {
        if (arr[i] < arr[left]) {
          [arr[i], arr[left]] = [arr[left], arr[i]];
          pivotIndex++;
        }
      }
      [arr[left], arr[pivotIndex]] = [arr[pivotIndex], arr[lef]];
    }
    this.quickSort(arr, left, pivotIndex - 1);
    this.quickSort(arr, pivotIndex + 1, right);
  }

归并排序

归并排序也是利用分治策略，将数组元素分成多个子序列，将子序列进行排序，然后将排序好的各个子序列进行合并排序。简单来说就是先分后并。 1.获取数组长度的中间下标，将数组分为子序列，并设定两个指针。 2.在子序列中将指针所指元素进行比较，比较完之后再进行合并继续比较。 3.最后排序好的序列合并到一起，排序成功。

    //归并排序
  mergeSort(arr) {
    const middleIndex = Math.floor(arr.length / 2),
      left = arr.slice(0, middleIndex),
      right = arr.slice(middleIndex);
    return this.merge(mergeSort(left), mergeSort(right));
  }
  merge(left, right) {
    const arr = [];
    while (left.length && right.length) {
      if (left[0] <= right[0]) {
        arr.push(left.shift());
      } else {
        arr.push(right.shift());
      }
    }
    while (left.length) arr.push(left.shift());
    while (right.length) arr.push(right.shift());
    return arr;
  }

总结

以上就是几种常见的排序算法，前面三个是很容易理解的，后两个快速与归并是还是需要费点功夫的，尤其是分治的思想，这个是很重要的一种策略。