一、冒泡排序

冒泡排序就是简单的两两对比，每次循环都将当前最大的数放在最右边。
比较和交换的复杂度都为O(N²)

  1. // 冒泡排序
  2.   bubbleSort() {
  3.     const length = this.arr.length;
  4.     for (let i = length - 1; i >= 0; i--) {
  5.       for (let j = 0; j < i; j++) {
  6.         if (this.arr[j] > this.arr[j + 1]) {
  7.           this.swap(j, j + 1);
  8.         }
  9.       }
  10.     }
  11.   }

二、选择排序

选择排序：用一个变量存储当前较小的那个元素，每次循环结束后都将其依次放到左边
比较的复杂度为O(N²)
交换的复杂度为O(N)

  1.   // 选择排序
  2.   selectionSort() {
  3.     const length = this.arr.length;
  4.     for (let j = 0; j < length - 1; j++) {
  5.       let min = j;
  6.       for (let i = min + 1; i < length; i++) {
  7.         if (this.arr[min] > this.arr[i]) {
  8.           min = i;
  9.         }
  10.       }
  11.       this.swap(min, j);
  12.     }
  13.   }

三、插入排序

插入排序的核心思想就是局部有序，比如左侧的一部分是有序的，右侧是无序的，那么就取无序的数据与有序数据比较，在合适的位置插入即可。

最坏：
比较的复杂度为O(N²)
移动的复杂度为O(N²)

  1.   // 插入排序
  2.   insertionSort() {
  3.     const length = this.arr.length;
  4.     // 外层循环：从第1个位置开始获取数据，向前面的有序部分进行插入
  5.     for (let i = 1; i < length; i++) {
  6.       // 内层循环：获取i位置的元素，与前面的有序部分进行比较
  7.       const temp = this.arr[i];
  8.       let j = i;
  9.       while (this.arr[j - 1] > temp && j > 0) {
  10.         this.arr[j] = this.arr[j - 1];
  11.         j--;
  12.       }
  13.       // 将j位置的数据，插入temp
  14.       this.arr[j] = temp;
  15.     }
  16.   }

四、希尔排序