通过相邻元素的比较和交换，使得每一趟都能找到未有序数组的最大值或者最小值

时间复杂度：?最好:O(n)???最坏:O(n^2)???最平均:O(n^2)

function bubbleSort(arr) {
  console.time('冒泡排序耗时');
  let arr = [...arr]; // 做浅拷贝避免影响原数组
  for (var i = 0, len = arr.length; i < len; i++ ) {
   // 为什么arr.length-1-i？因为每次遍历完后最大值肯定在最右边，数组的后面的那段其实已经是排序好，无需在排序
    for (var j = 0; j < len - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; // 拆开看arr[0] = arr[1]; arr[1] = arr[0]

      }
    }
  }
  console.timeEnd('冒泡排序耗时');
  return arr;
}

2.选择排序:

和冒泡排序类似，区别在于是将每个元素和他后面的元素比较交换

时间复杂度： ?最好:O(n^2) ? ?最坏:O(n^2)?? ?最平均:O(n^2)

function selectSort(arr) {
  console.time('选择排序耗时');
   for (var i = 0, len = arr.length; i < len; i ++) {
     for (var j = i + 1; j < len; j++) {
       if (arr[i] > arr[j]) {
        [arr[i], arr[j]] = [arr[j], arr[i]]
       }
     }
   }
   console.timeEnd('选择排序耗时');
   return arr;
 }

3.插入排序:

以第一个元素作为有序数组，其后的元素通过在这个已有的数组中找到合适的位置并插入

时间复杂度：

?最好:O(n), 原数组已经是升序的。

?最坏:O(n^2)

?最平均:O(n^2)

function insertionSort(d) {
  console.time('插入排序耗时：');
  var arr = [...d];
  var len = arr.length;
  var preIndex; // 索引
  var current; // 当前值
  debugger;
  for (var i = 1; i < len; i++) {
    preIndex = i - 1;// 0开始
    current = arr[i];// 一开始拿到第二个值
    while (preIndex >= 0 && arr[preIndex] > current) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  console.timeEnd('插入排序耗时：');
  return arr;
}

4.快速排序：

1.在数组中选择一个元素作为'基数'； ?

2.所有小于'基数'的元素都移到'基数'左边，所有大于基数的都移到右边。 ?

3.对'基数'左边和右边两个子集不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

?时间复杂度：最好:O(nlogn) ?最坏:O(n^2) ?最平均:O(nlogn)

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  var tempIndex = Math.floor(arr.length/2);
  var temp = arr.splice(tempIndex, 1)[0];  //基数
  var leftArr = [];  //小于基数的集合
  var rightArr = [];  //大于基数的集合
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] > temp) {
      rightArr.push(arr[i]);
    } else {
      leftArr.push(arr[i]);
    }
  }
  return quickSort(leftArr).concat(temp, quickSort(rightArr));
}

附上菜鸟教程提供的一张相关排序算法的时间复杂度及相关算法讲解链接

点我https://www.runoob.com/w3cnote/ten-sorting-algorithm.html

[数据结构与算法]前端基本的排序算法

1.冒泡排序:

2.选择排序:

3.插入排序:

4.快速排序：