js 排序算法

1 冒泡排序

  最简单的排序算法之一

 function sorting(arr){
      //冒泡排序
      let len = arr.length,temp= 0;
      for(let i = 0; i < len -1; i++){
        for (let j = i+1; j < len-1; j++){
          if(arr[i] > arr[j]){
             temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
          }
        }
      }
      return arr;

    },

2 选择排序

 首页从未排序序列中找到最大值或最小值，放到已排序序列的末尾或开头，重复上述步骤，直到所有元素排序完毕

function sorting(arr){
      let len = arr.length,temp = 0;
      let minIndex = 0;
      for (let i = 0; i < len -1; i++){
          minIndex = i;
          for (let j = i+1 ; j < len; j++){
            if(arr[i] > arr[j]){
              minIndex = j;
            }
          }
          temp = arr[i];
          arr[i] = arr[minIndex];
          arr[minIndex] = temp;
      }
      return arr;

    },

3 插入排序

   通过构建有序序列，对于末排序数据，在已排序序列中从后往前扫描，找到相应位置并插入（类似玩扑克牌）

function sorting(arr){
      let len = arr.length;
      let preIndex = 0,current=0;
      for(let i = 1; i < len; i++){
          preIndex = i - 1;
          current = arr[i];
          while (preIndex >= 0 && current < arr[preIndex]){
            arr[preIndex + 1] = arr[preIndex];
            preIndex --;
          }
          arr[preIndex +1] = current;
      }
      return arr;

    },

4 希尔排序

按一定的间隔对数列进行分组，然后在每一个分组中做插入排序；随后逐次缩小间隔，在每一个分组中做插入排序。。。直到间隔等于1，做一次插入排序后结束

function sorting(arr){
      let len = arr.length;
      let preIndex = 0,current=0;
      let gap = Math.floor(len / 2);
      while (gap > 0){
        for( let i = gap; i < len; i++){
          current = arr[i];
          preIndex = i - gap;
          while( preIndex >= 0 && current < arr[preIndex]){
            arr[preIndex + gap] = arr[preIndex];
            preIndex -= gap;
          }
          arr[preIndex + gap] = current;
        }
        gap = Math.floor(gap/2)
      }
      return arr;

    },

5 归并排序

  采用分治法，将将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

function sorting(arr){
      let that = this;
      let len = arr.length;
      if(len < 2){
        return arr;
      }
      let gap = Math.floor(len / 2);
      let left = arr.slice(0,gap);
      let right = arr.slice(gap);
      return merge(sorting(left),sorting(right));

    }
function merge(left, right){
      let result = [];
      while (left.length || right.length){
         if(!left.length){
           result.push(right.shift());
         }else if(!right.length){
           result.push(left.shift());
         }else if(left[0] > right[0]){
           result.push(right.shift());
         }else{
           result.push(left.shift());
         }
      }
      return result;
    }

6 快速排序

 找到一个基点，然后将数组的每一项和该基点进行比对，比它大的放一个数组，比他小的放另外一个数组，然后将其连接在一起，一直重复以上步骤，直到数组的长度为1时

function sorting(arr){
      let len = arr.length,left = [],right = [];
      if(len <= 1){
        return arr;
      }
      let base = arr[0];
      for (let i = 1; i < len; i++){
        if(arr[i] < base){
          left.push(arr[i]);
        }else {
          right.push(arr[i]);
        }
      }
      return sorting(left).concat(base,sorting(right))
    }

参考链接：https://www.cnblogs.com/AlbertP/p/10847627.html