算法问题：
    sort
    递归
    一分为二，分冶

    1. //冒泡排序
    2. bubbleSort = function(arr){
    3.     const length = arr.length;
    4.     let hasChanged = true;
    5.     for(let i=0;i<length &&hasChanged;i++){
    6.         for(let j= 0;j<length -1-i;j++){
    7.             if(arr[j]>arr[j+1]){
    8.                 [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
    9.                 hasChanged = true;
    10.             }
    11.         }
    12.     }
    13.     console.log(arr);
    14. };
    16. //插入排序
    17. insertSort = function(arr){
    18.     let l = arr.length;
    19.     let current;
    20.     let preIndex
    21.     for(let i=1;i<length;i++){
    22.         //外层循环
    23.         current = arr[i];
    24.         preIndex = i-1;
    25.         //内层循环，判断插入到哪里
    26.          // 内循环结束，j+1 所指向的位置就是 current 值插入的位置
    27.        while(preIndex>= 0 && arr[preIndex] > current){
    28.             arr[preIndex+1] =arr[preIndex];
    29.             preIndex --;
    30.        }
    31.        if(preIndex+1!==i){
    32.         arr[preIndex+1] = current;
    33.        }
    34.     }
    35.     console.log(arr);
    36. };
    38.  selectionSort = function(arr){
    39.     let minIndex = 0,temp;
    40.     for(let i=0;i<arr.length;i++){
    41.         minIndex = i;
    42.         for(let j=i+1;j<arr.length;j++){
    43.             if(arr[j] < arr[minIndex]){
    44.                 minIndex = j;
    45.             }
    46.         }
    47.         temp = arr[i];
    48.         arr[i] = arr[minIndex]
    49.         arr[minIndex] = temp;
    50.     }
    51.     return arr;
    52. };
    54. //归并排序,先递归分为两部分，然后执行合并操作，递归时间复杂度是logn,合并操作是n，所以平均复杂度是nlogn
    55. merge = function(left,right){
    56.     const result = [];
    57.     while(left.length && right.length){
    58.         if(left[0]<=right[0]){
    59.             result.push(left.shift());
    60.         } else{
    61.             result.push(right.shift());
    62.         }
    63.     }
    65.     while(left.length){
    66.         result.push(left.shift());
    67.     }
    69.     while(right.length){
    70.         result.push(right.shift());
    71.     }
    72.     return result;
    73. };
    75. mergeSort = function(arr){
    76.     if(arr.length<2){
    77.         return arr;
    78.     }
    79.     let mid = Math.floor(arr.length/2);
    80.     let left = arr.slice(0,mid);
    81.     let right = arr.slice(mid);
    82.    return merge(mergeSort(left),mergeSort(right)) ;
    83. };
    85. //快排
    86. quickSort = function(arr){
    87.     if (arr.length <= 1) {
    88.         return arr;
    89.     }
    90.     let midIndex = Math.floor(arr.length/2);
    91.     const mid = arr[midIndex];
    92.     const left = [];
    93.     const right = [];
    94.     for(let i=0;i<arr.length;i++){
    95.         if(arr[i]<mid){
    96.             left.push(arr[i]);
    97.         }else{
    98.             right.push(arr[i]);
    99.         }
    100.     }
    102.     return quickSort(left).concat(mid).quickSort(right)
    103. };