1. // 通用函数
    2. function swap(array, left, right) {
    3.     let rightValue = array[right]
    4.     array[right] = array[left]
    5.     array[left] = rightValue
    6. }
    8. /* 1冒泡排序
    9. *  原理：
    10. *  从第一个元素开始，把当前元素current与下一个索引对应的元素next进行比较，如果current > next（升序），
    11. *  则交换位置，重复此操作直到最后一个元素，此时最后一个元素就是这个数组中最大的元素，下一轮比较中已经确定顺序的
    12. *  元素就不需要参与了
    13. *  时间复杂度：平方阶O(n^2)
    14. */
    15. function bubbleSort(array) {
    16.     for (let i = array.length - 1; i > 0; i--) {
    17.         for (let j = 0; j < i; j++) {
    18.             if (array[j] > array[j + 1]) {
    19.                 swap(array, j, j + 1)
    20.             }
    21.         }
    23.     }
    24. }
    27. /* 2插入排序
    28. *  原理：
    29. *  默认第一个元素已经排好序了，取下一个元素和当前元素作比较，如果当前元素大（升序）就交换位置，
    30. *  此时前两个元素已经排好序了，再取下一个元素和前面已经排好序的元素在进行比较(从后往前比较， 
    31. *  因为下一个元素是和前面已经排好序的的最后一个元素是连着的)
    32. *  时间复杂度：平方阶O(n^2)
    33. */
    35. function insertSort(array) {
    36.     for (let i = 1; i < array.length; i++) {
    37.         for (let j = i - 1; j >= 0; j--) {
    38.            if (array[j] > array[j + 1]) {
    39.               swap(array, j, j + 1)
    40.            }
    41.         }
    42.     }
    43. }
    46. /* 3选择排序
    47.     （选择最小的）
    48. *  原理：
    49. *  从索引值0开始，与后面元素依次进行比较，如果索引值0的元素比某个元素大，则交换位置（升序），
    50. *  第一轮比较完之后，索引值0位置的元素就是最小的，下一轮取索引值是1的元素重复操作，寻找下一
    51. *  个相对比较小的值
    52. *  
    53. *  时间复杂度：平方阶O(n^2)
    54. */
    56. function selectionSort(array) {
    57.     for (let i = 0; i < array.length - 1; i++) {
    58.         for (let j = i + 1; j < array.length; j++) {
    59.            if (array[i] > array[j]) {
    60.               swap(array, i, j)
    61.            }
    62.         }
    63.     }
    64. }
    66. /**
    67.  * 4快速排序
    68.  * 原理：
    69.  * （1）在数据集之中，选择一个元素作为"基准"（pivot）。
    70.  * （2）所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。
    71.  * （3）对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。
    72.  *  
    73.  * 时间复杂度：平均时间复杂度O(nlogn)  最差复杂度O( n^2 )
    74.  */
    75. function quickSort(array) {
    76.     // 递归只剩一个元素的时候直接返回
    77.     if (array.length <= 1) { 
    78.         return array; 
    79.     }
    81.     const pivotIndex = Math.floor(array.length / 2)
    82.     const pivot = array.splice(pivotIndex, 1)[0];
    83.     const left = [];
    84.     const right = [];
    86.     for (let i = 0; i < array.length; i++) {
    87. 　　　　if (array[i] < pivot) {
    88. 　　　　　　left.push(array[i]);
    89. 　　　　} else {
    90. 　　　　　　right.push(array[i]);
    91. 　　　　}
    92. 　　}
    94.     return [...quickSort(left), pivot, ...quickSort(right)]
    95. }