经典排序算法的JS实现

1.冒泡排序法, 算法可视化实现参考visualgo，空间复杂度

Tips:因比较少一个数组，所以循环次数要小于length-1

复杂度：O(n²)

function bubble(a) {
  for (let i = 0; i < a.length - 1; i++) {
    for (let j = 0; j < a.length - i - 1; j++) {
      if (a[j] > a[j + 1]) {
        [a[j], a[j + 1]] = [a[j + 1], a[j]]
      }
    }
  }
 return [...a]
}

2.快速排序算法，算法可视化实现参考visualgo

Tips:考察递归，中分查找法

复杂度：O(nlogn)

function quick(a) {
  if (a.length <= 1) return a;
  let lArr = [], rArr = [];
  let q = a[0]
  //切记从1开始
  for (let i = 1; i < a.length; i++) {
    if (a[i] < q) lArr.push(a[i])
    else rArr.push(a[i])
  }
  //开始递归调用
  return [...quick(lArr), q, ...quick(rArr)]
}

3.归并排序算法，时间复杂度：O(n log n)

是一种分治法的思想

function mergeSort(list) {
  let length = list.length;
  if (length == 1) { // 递归结束条件
    return list;
  }
  let mid = Math.floor(length / 2);
  let left = list.slice(0, mid);
  let right = list.slice(mid, length);
  return merge(mergeSort(left), mergeSort(right));// 递归，跟快速排序差不多一样
};

function merge(left, right) {
  let result = [];
  let nl = 0;
  let nr = 0;
  while (nl < left.length && nr < right.length) {
    if (left[nl] < right[nr]) {
      result.push(left[nl++]);
    } else {
      result.push(right[nr++]);
    }

  }
  while (nl < left.length) {
    result.push(left[nl++]);

  }
  while (nr < right.length) {
    result.push(right[nr++]);

  }

  return result;
}