几大排序

排序稳定性定义 可以理解为当a = b 的时候，排序前排序后的ab的顺序不发生变化 也就是a,b而不是a,xxx,b

冒泡排序

冒泡排序是稳定的排序算法，最好的时间复杂度是n,最差的是n^2,平均数n^2

var BubbleSort = function(arr) {
     let n = arr.length; 
     for(let i = 0; i < n-1;i++) {
       for(let j = 0;j< n-1-i;j++) {
         if(arr[j] > arr[j+1]) {
           swap(arr,j,j+1)
         }
       }
     }
    //  console.log(arr);
     return arr;
   }
   var swap = (arr,index1,index2)=>{
    [arr[index1],arr[index2]] = [arr[index2],arr[index1]];
   }

关于冒泡排序的最好时间复杂度代码如下

 var BubbleSortOptimize =(arr)=>{
     let n = arr.length;
     for(let i = 0;i<arr.length;i++) {
       let flag = true;
       for(let j = 0;j<n-i-1;j++) {
         if(arr[j] > arr[j+1]) {
           swap(arr,j,j+1);
           flag = false;
         }
       }
       if(flag) {
         return arr;
       }
     }
     return arr;
   }

选择排序

选择排序是不稳定的，选择排序最好的时间复杂度是n,最坏的时间复杂度也是n^2,平均时间复杂度是n^2

var selectSort = (arr)=> {
    let n = arr.length;
    for(let i = 0;i<n-1;i++) {
      let max = i;
      for(let j = i+1;j<=n-1-i;j++) {
        if(arr[j] > arr[max]) {
          max = j
        }
      }
      swap(arr,max,i);
    }
    return arr;
  }

插入排序

插入排序是稳定的，插入排序最好的时间复杂度是n,最坏的时间复杂度是n^2，平均时间复杂度是n^2

 var InsertSort = (arr) => {
    let n = arr.length;
    let a = [arr[0]];
    for(let i = 1; i < n;i++) {
      let j = i-1;
      while(j >=0 && a[j] >arr[i]) {
        a[j+1] = a[j];
        j--;
      }
      a[j+1] = arr[i];
    }
    return a;
  }

归并排序

归并排序是稳定的，归并排序最好的时间复杂度是n(logn)，最坏的时间是n(logn)，平均的时间复杂度是n(logn)

  var mergeSort = (arr)=> {
    let n = arr.length;
    if(n < 2) {
      return arr;
    }
    let left = 0,right = n-1;
    let mid = Math.floor((right - left) /2) + left;
    let leftArr = arr.slice(0,mid+1);
    // console.log(leftArr,"++++++++")
    let rightArr = arr.slice(mid+1);
    return merge(mergeSort(leftArr),mergeSort(rightArr))
  }
  var merge = (leftArr,rightArr) =>{
    let tempArr = [];
    while(leftArr.length && rightArr.length) {
      if(leftArr[0] < rightArr[0]) {
        tempArr.push(leftArr.shift())
      } else {
        tempArr.push(rightArr.shift())
      }
    }

    while(leftArr.length) {
      tempArr.push(leftArr.shift());
    }
    while(rightArr.length) {
      tempArr.push(rightArr.shift());
    }
    return tempArr;
  }

快速排序

快速排序是不稳定的，快速排序最好的时间复杂度是nlog(n)，最坏的的时间复杂度是n(logn),平均的时间复杂度是(nlogn)

    var quickSort = (arr,from,to) => {
    console.log(from,to)
    let left = from;
    // let n = arr.length;
    let right = to ;
    let key = arr[from];
    if(from >= to) {
      return ;
    }
    while(left < right) {
      console.log(arr)
      while(arr[right] > key && left < right) {
        right --;
      }
      while(arr[left] <= key && left <right) {
        left++;
      }
      if(left < right) {
        [arr[left],arr[right]] = [arr[right],arr[left]]
      }
      
    }
    arr[from] = arr[left];
    arr[left] = key;
    quickSort(arr,from,left - 1);
    quickSort(arr,left+1,to)
  }