选择排序、快速排序、冒泡排序、插入排序

1.选择排序：

在一个长度为N的无序数组中，在第一趟遍历N个数据，找出其中最小的数值与第一个元素交换，第二趟遍历剩下的N-1个数据，找出其中最小的元素与第一个交换，第N-1趟遍历剩下的2个数据，找出其中最小的值与第N-1个元素交换，直到完成排序。

例如： 11  32  22  13  9

第一趟排序后： 9  32  22  13  11

第二趟排序后： 9  11  22  13  32

第三次排序后： 9  11  13  22  32  排序完成。

平均时间复杂度：O（n^2）

空间复杂度：O(1)

稳定性：不稳定

2.快速排序

思想：a在带排序的元素中任取一个元素作为基准（通常选第一个），称为基准元素；

      b将带排序的元素进行分区，比基准元素大的元素放在他的右边，比他小的放在左边；

      c对左右两个分区重复以上步骤直达所有元素有序；

时间复杂的：O（nlogn）

例如：5  2  6  8  4为带排序元素

首先选取5为基准元素 5 和4比较5>4交互 4  2  6  8  5

                     5 和2比较2<5不交换 4  2  6  8  5

                     5和 8比较8>5交换 4  2  6  5  8

                     5和6比较5<6交互 4  2  5  6  8

基准元素分别与最后一个比较，然后与第二个元素比较，然后与倒数第二个比较，然后与第三个比较。。。。大的放右边，小的放左边。

3.冒泡排序

思想：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第一个和第二个数，将小数放前，大数放后，然后比较第二个数和第三个数将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较 （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个 数），将小数放前中，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟 结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

时间复杂度：O（n^2）

例如：6  3  1  8  4

3  1  6  4  8（最后一个位置为最大数字）

1  3  4  6  8（倒数第二位为倒数第二大）

4.插入排序

思想：检查第i个数字，如果在它的左边的数字比它大，进行交换，这个动作一直继续下去，直到这个数字的左边数字比它还要小，就可以停止了。

例如：5  8  4  1  6

从第二个数开始：8大于5不用交换，第三个数比第二个数小，交换得到5  4  8  1  6第二个比第一个小，交换，4  5  8  1  6，同理，第四个数与前面的数比较1  4  5  8  6，第五个数与前面的比较1  4  5  6  8完成。

时间复杂度：O（n^2）

// 冒泡排序
Array.prototype.bubbleSort = function () {
  for (let i = 0; i < this.length - 1; i++) {
    for (let j = 0; j < this.length - 1 - i; j++) {
      if (this[j] > this[j + 1]) {
        const temp = this[j];
        this[j] = this[j + 1];
        this[j + 1] = temp;
      }
    }
  }
  return this;
};

// 选择排序
Array.prototype.selectSort = function () {
  for (let i = 0; i < this.length; i++) {
    let minIndex = i;
    for (let j = i; j < this.length; j++) {
      if (this[minIndex] > this[j]) {
        const temp = this[minIndex];
        this[minIndex] = this[j];
        this[j] = temp;
      }
    }
  }
  return this;
};

// 插入排序
Array.prototype.insertionSort = function () {
  for (let i = 1; i < this.length; i++) {
    let temp = this[i];
    let j = i;
    while (j) {
      if (this[j - 1] > temp) {
        this[j] = this[j - 1];
      } else {
        break;
      }
      j--;
    }
    this[j] = temp;
  }
  return this;
};

//快速排序
Array.prototype.quickSort = function () {
  const rec = (arr) => {
    if (arr.length <= 1) return arr;
    const left = [];
    const right = [];
    const mid = arr[0];
    for (let i = 1; i < arr.length; i++) {
      if (arr[i] < mid) {
        left.push(arr[i]);
      } else {
        right.push(arr[i]);
      }
    }
    return [...rec(left), mid, ...rec(right)];
  };
  const res = rec(this);
  res.forEach((n) => (this[i] = n));
  return this;
};

const arr = [2, 4, 5, 3, 1, 0, 99];
arr.quickSort();