【前端算法系列】排序

时间复杂度

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	是否稳定
冒泡排序	O(n²)	O(n²)	O(1)	是
选择排序	O(n²)	O(n²)	O(1)	不是
直接插入排序	O(n²)	O(n²)	O(1)	是
快速排序	O(nlogn)	O(n²)	O(logn)	不是
希尔排序	O(nlogn)	O(n^s)	O(1)	不是

冒泡、选择、直接 排序需要两个for循环，每次只关注一个元素，平均时间复杂度为O(n²)(一遍找元素O(n)，一遍找位置O(n)）
快速、归并、希尔、堆基于二分思想，log以2为底，平均时间复杂度为O(nlogn)(一遍找元素O(n)，一遍找位置O(logn))

是否稳定？
稳定性：通俗的讲有两个相同的数A和B，在排序之前A在B的前面，而经过排序之后，B跑到了A的前面，对于这种情况的发生，我们管他叫做排序的不稳定性，而快速排序在对存在相同数进行排序时就有可能发生这种情况（不稳定性会导致重绘重排问题）
如果不考虑稳定性，快排似乎是接近完美的一种方法，但可惜它是不稳定的

冒泡排序 Bubble

1）比较所有相邻元素，如果第一个比第二个大，则交换它们
2）一轮下来，可以保证最后一个数是最大的
3）执行n-1轮，就可以完成排序

// 时间复杂度：O(n^2) 两个嵌套循环
Array.prototype.bubbleSort = function(){
    for(let i=0;i<this.length-1;i+=1){
        for(let j=0;j<this.length-1-i;j+=1){ // 区间不断减少，所以减i
            if(this[j]>this[j+1]){
                const temp = this[j]
                this[j] = this[j+1]
                this[j+1] = temp
            }
        }
    }
}
const arr = [5, 4, 3, 2, 1]
arr.bubbleSort()

选择排序 Select

原理：找出最小值得索引，再跟第一个索引进行交换
1）假设第一个元素就是最小的，定义个变量min放置索引0，拿着最小元素依次进行比较，得到最小索引处
2）拿此时最小索引跟剩余的元素做比较，得到最小索引处
3）交换第一索引处和最小索引处的值

// 时间复杂度：O(n^2) 两个嵌套循环
Array.prototype.selectionSort = function(){
    for(let i=0;i<this.length-1;i+=1){
        let indexMin = i // 最小值下标
        for(let j=i;j<this.length;j+=1){
            // 如果当前元素小于最小值，最小值下标就换成当前元素下标
            if(this[j]<this[indexMin]){ 
                indexMin = j
            }
        }
        if(indexMin!==i){ // 相等就不用交换
            // 和第一个交换
            const temp=this[i]
            this[i] = this[indexMin]
            this[indexMin] = temp
        }
    }
    
}
const arr = [5, 4, 3, 2, 1]
arr.selectionSort()

插入排序 Insert

1）把所有元素分为两组，已排序和未排序的
2）找到未排序中的第一个元素，向已排序的进行插入（倒叙遍历已排序的，找到小于待插入元素，就把待插入元素放到这个位置，其他元素向后移动一位）

从第二个数开始往前比，比它大就往后排

// 时间复杂度：O(n^2) 两个嵌套循环
Array.prototype.insertSort=function(){
    for(i=1; i<this.length; i++){
	  // 从第二个数开始往前比
      let tmp = this[i]
      // 索引0处开始比较
      let j = i - 1
      // 往前比是一个循环过程
      while(j>=0 && tmp < this[j]){
         this[j+1] = this[j]
         j--
       }
       this[j+1] = tmp // 循环到最后，改变开始往前比较的值
    }
}
const arr = [5, 4, 3, 2, 1]
arr.insertSort()

希尔排序 Shell（高级排序，是插入排序的改良版）

原理：把原数组进行分组，分完组之后，对每一组数组进行插入排序
1）选定一个增长量，按照增长量h作为数据分组的依据来分组
2）对分好组的每一组数据完成插入排序（如果左边比右边大就交换元素）
3）减小增长量，最小减为1，重复第二步操作

// 增长量h的确定规则
var h = 1
while(h<数组长度/2){  // 10/2  ==>  h<5
    h=2h+1  // 3,7  7比5大，所以增量为7
}
// 循环结束后我们就可以确定h的最大值

h的减小规则为: 每次循环为h/2 
h = h/2

Array.prototype.shellSort=function(){
  let arr = this
  // 1.根据数组a的长度，确定增长量h的初始值
  let h=1
  while(h<arr.length/2){
      h=2*h+1
  }
  // 数组元素i和j交换位置
  function exch(a,i,j){
    let temp=a[i]
    a[i]=a[j]
    a[j]=temp
    return a
  }

  // 2.希尔排序
  while(h>=1){ // 当增量h大于等于1时要继续排序
      // 2.1 排序
      // 2.1.1 找到待插入的元素
      for(var i=h;i<arr.length;i++){ // i表示已排序
              // 2.1.2 把待插入的元素插入到有序数列中
              for(var j=i;j>=h;j--){ // j表示未排序，相当于定量前都是已插入
                // console.log(j)
                // console.log('j-=h', j-=h)
                // console.log('h', h)
                  if(arr[j-h]>arr[j]){
                  // 交换元素
                  arr = exch(arr,j-h,j)
                  }else{ // 待插入元素已经找到适合位置，结束循环
                      break
                  }
              }
      }
      // 2.2 减小增量值
      h= Math.floor(h/2) 
  }
  return arr
}
const arr = [5,8,3,0,1,4,6]
arr.shellSort()
console.log(arr)   

归并排序 Merge（火狐浏览器sort）

原理：把一组数据分为多组数据，如果还可以继续分，就继续分组，分到不能分为止再进行归并（在归并里面进行排序的）

/** 分的时间复杂度：O(logN)
 *  合的时间复杂度：O(n)
 *  时间复杂度：O(n*logN)
 */
Array.prototype.mergeSort = function(){
   const rec = (arr)=> {
       if(arr.length === 1) return arr
       const mid = Math.floor(arr.length/2)
       const left = arr.slice(0, mid)
       const right = arr.slice(mid, arr.length)
       const orderLeft = rec(left)
       const orderRight = rec(right)
       const res = []
       while(orderLeft.length || orderRight.length){
           if(orderLeft.length && orderRight.length){
                res.push(orderLeft[0] < orderRight[0]? orderLeft.shift():orderRight.shift())   
           }else if(orderLeft.length){ // 左边有值，右边已经空了
                res.push(orderLeft.shift())
           }else if(orderRight.length){
                res.push(orderRight.shift())
           }
       }
       return res
   }
   const res = rec(this)
   res.forEach((n,i) => { this[i] = n});
}
const arr = [5, 4, 3, 2, 1]
arr.mergeSort()

快速排序 Quick (谷歌sort)

• 分区：从数组中任意选择一个“基准”，所有比基准小的元素放在基准前面，比基准大的元素放在基准后面
• 递归：递归地对基准前后的子数组进行分区

/** 递归的时间复杂度是O(log(N))
 *  分区操作的时间复杂度是O(n)
 *  时间复杂度：O(n*logN)
 */
Array.prototype.quickSort = function () {
    const rec = (arr) => {
      if (arr.length <= 1) { return arr; } // 递归出口
      const left = []; // 左侧数组
      const right = []; // 右侧数组
      const mid = arr[0]; // 基准
      for (let i = 1; i < arr.length; i++) {
        if (arr[i] < mid) {
          left.push(arr[i]); // 小于基准的放在左边
        } else {
          right.push(arr[i]); // 大于基准的放在右边
        }
      }
      return [...rec(left), mid, ...rec(right)]; // 返回递归后的左 + 基准 + 右 的拼接数组
    };
    const res = rec(this);
    res.forEach((n, i) => { this[i] = n }); // 将res的值 赋值给arr
  };
const arr = [5, 4, 3, 2, 1]
arr.quickSort()