算法整理：排序

一、冒泡排序

1. 基本思想：
   对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端， 最终达到完全有序。
2. 代码实现

function bubbleSort(arr) {
   
    if (!Array.isArray(arr) || arr.length <= 1) return;
    let lastIndex = arr.length - 1;
    while (lastIndex > 0) {
    // 当最后一个交换的元素为第一个时，说明后面全部排序完毕
        let flag = true, k = lastIndex;
        for (let j = 0; j < k; j++) {
   
            if (arr[j] > arr[j + 1]) {
   
                flag = false;
              	lastIndex = j; // 设置最后一次交换元素的位置
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
      	if (flag) break;
    }
}

3. 优化
   一种是外层循环的优化，我们可以记录当前循环中是否发生了交换，如果没有发生交换，则说明该序列已经为有序序列了。 因此我们不需要再执行之后的外层循环，此时可以直接结束。
   一种是内层循环的优化，我们可以记录当前循环中最后一次元素交换的位置，该位置以后的序列都是已排好的序列，因此下 一轮循环中无需再去比较。
   优化后的冒泡排序，当排序序列为已排序序列时，为最好的时间复杂度为 O(n)。
4. 复杂度
   平均时间复杂度为 O(n²)
   最坏时间复杂度为 O(n²)
   空间复杂度为 O(1)
5. 稳定性
   是稳定排序。

二、 选择排序

1. 基本思想
   每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止
2. 代码实现

function selectSort(array) {
   

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  for (let i = 0; i < length - 1; i++) {
   

    let minIndex = i; // 设置当前循环最小元素索引

    for (let j = i + 1; j < length; j++) {
   

      // 如果当前元素比最小元素索引，则更新最小元素索引
      if (array[minIndex] > array[j]) {
   
        minIndex = j;
      }
    }

    // 交换最小元素到当前位置
    // [array[i], array[minIndex]] = [array[minIndex], array[i]];
    swap(array, i, minIndex);
  }

  return array;
}

// 交换数组中两个元素的位置
function swap(array, left, right) {
   
  var temp = array[left];
  array[left] = array[right];
  array[right] = temp;
}

3. 优化
4. 复杂度
   不管初始序列是否有序，时间复杂度都为 O(n²)

平均时间复杂度为 O(n²)
最坏时间复杂度为 O(n²)
空间复杂度为 O(1)

5. 稳定性
   不是稳定排序

三、插入排序

1. 基本思想（扑克牌思想）
   每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
2. 代码实现

function insertSort(array) {
   

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <=