js排序：

1. 冒泡排序：

   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
    //冒泡排序
   //双for嵌套
   function arrSort(arr) {
       for (let i = 0; i < arr.length - 1; i++) {//遍历，这里，arr.length-1，是因为最后一次不用循环了。
           for (let j = 0; j < arr.length - i ; j++) {//双重遍历，遍历i之后的数，例如有8个元素，i在第一项，那么遍历后面7项。
               if(arr[j] < arr[j-1]){//如果右边，小于左边，那么交换位置。
                   let temp = arr[j];
                   arr[j] = arr[j-1];
                   arr[j-1] = temp;
               }
           }
       }
       return arr;
   }
   console.log(arrSort(arr));
   
   
   //sort排序
   let arrNew = arr.sort(function (a, b) {
      return a - b  //升序 默认
      // return b - a //倒序
   });
   console.log(arrNew);
   
   

2. 插入排序：

   //插入排序
   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
   function arrSort(array) {
       for(let i = 1; i < array.length; i++) {//遍历一波数组,从数组第二项开始遍历
           let key = array[i];//这里必须要定义，因为循环结束，会用到。
           let j = i - 1;//定义j为i-1,在第一次遍历，是从数组第一项开始
           while(j >= 0 && array[j] > key) {//如果j的值大于i的值，也就是左边的大于右边的，j>=0，防止j--变负数。
               array[j + 1] = array[j];//例如第二项和第三项248和31，那么变成，248，248
               j--;//如果248>31执行成功了，变成了248,248,那么依次判断左边，是否有小于 的。
           }
           array[j + 1] = key;//把第一项赋值成最小的那个。
       }
       return array;
   }
   console.log(arrSort(arr));
   

3. 选择排序：

   //选择排序
   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
   function arrSort(arr){
       for(let i = 0; i < arr.length - 1; i++){//遍历数组
           let min = arr[i];//防止arr[i]发生变化
           for(let j = i + 1; j < arr.length - 1; j++){//双重遍历，查找最小的数进行交换，跟冒泡不一样的地方在于，选择排序，假如第4位更小，则是1，4位交换，不是3，4位交换
               if(min > arr[j]){
                   let temp = min;
                   min = arr[j];
                   arr[j] = temp;
               }
           }
           arr[i] = min;
       }
       return arr;
   }
   console.log(arrSort(arr));
   

4. 归并排序：

   //分治排序
   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
   function merge(left, right) {
       let result = [];
       while(left.length > 0 && right.length > 0) {//如果两边数组都有值
           if(left[0] < right[0]) {//左边小于右边
               result.push(left.shift());//给result数组添加值，并在left删掉值
           }
           else {
               result.push(right.shift());//给result数组添加值，并在right删掉值
           }
       }
       /* 当左右数组长度不等.将比较完后剩下的数组项链接起来即可 */
       return [...result,...left,...right];//这里用es6的语法，只是一个简写，百度一眼就会。...left...right是因为万一长度不相等，会少数，所以会加这两个。
   }
   function mergeSort(arr){
       if(arr.length==1){//如果数组长度为1则返回数组
           return arr
       };
       let mid=Math.floor(arr.length/2);//分成两部分
       let left_arr=arr.slice(0,mid);//数组分成两份后，塞进去。假如说数组有8个元素，分成两部分，左边(0,4)
       let right_arr=arr.slice(mid);//右边(4到后面所有)
       return merge(mergeSort(left_arr),mergeSort(right_arr));//递归
   }
   console.log(mergeSort(arr));
   

5. 快速排序：

   //快速排序
   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
   function arrSort(arr){
       if (arr.length <= 1){
           return arr
       };
       var pivotIndex = Math.floor(arr.length / 2);
       var pivot = arr.splice(pivotIndex,1)[0];//取出中间的数字，比如第一次就取出9
       var left = [];
       var right = [];
       for (var i = 0; i < arr.length; i++){
           if(arr[i] < pivot) {//第一次运算，如果小于9就进入左数组，大于就进入右数组
               left.push(arr[i]);
           }else{
               right.push(arr[i]);
           }
       }
       return arrSort(left).concat([pivot],arrSort(right));//递归，再把左数组分成两半进行排序，右数组同理。
   }
   console.log(arrSort(arr));
   

6. 希尔排序：

   //希尔排序
   let arr = [145, 248, 31, 45, 9, 11, 145, 300];
   function arrSort(arr){
       let gap =Math.floor(arr.length/2);
       while(gap>=1){
           for(let i = gap;i<arr.length;i++){
               let j,temp=arr[i];
               for(j=i-gap;j>=0&&temp<arr[j];j=j-gap){
                   arr[j+gap]=arr[j];
               }
               arr[j+gap]=temp;
           }
           gap=Math.floor(gap/2);
       }
       return arr;
   }
   console.log(arrSort(arr));