排序算法之js实现（回顾）

• 基于比较类的排序算法：交换排序（冒泡排序，快速排序），插入排序（简单插入排序，希尔排序），选择排序（简单选择排序，堆排序），归并排序（二路归并排序，多路归并排序）。
• 非比较类的排序算法：计数排序、桶排序、基数排序

———————————————————————————————————————————

（1）冒泡排序

const a = [3,2,1,4,1,7,8,];
// 记住： 
// key1:n个元素进行n-1趟比较，第一个for就是n-1趟
// key2:
// 第一趟进行n个元素的比较，将最大/小值放到最后
// 第二趟进行n-1个元素的比较，将最大/小值放到倒数第二个位置（也就是第二趟的最后位置）
// …………
// 时间复杂度：n + n-1 + n-2 + 1 = O(n^2)
for(let i = 0;i<a.length-1;i++){
    for(let j=0;j<a.length-1-i;j++){
        if(a[j+1]<a[j]){
            let tmp = a[j];
            a[j] = a[j+1];
            a[j+1] = tmp;
        }

    }
}
console.log(a);

———————————————————————————————————————————

（2）快速排序
选择一个基准，基准左边的数都小于该基准，基准右边的数都大于该基准，再对基准左边的区，右边的区依次进行该操作，直到所有数都有序。

// 时间复杂度， 平均情况下： O(nlogn) 最坏的情况：O(n^2)
// 平均情况下：基准可以平衡划分两个区间
// 最坏的情况：基准是最大最小值，此时相当于冒泡 n * （n-1）
const arr = [3,2,1,4,9,8,1];
const quick = (arr, left, right)=>{
    if(left >= right){
        return;
    }

    //设立基准下标、左右边界
    let pivot = left;
    let i = left;
    let j = right;

    //进入判断（硬性条件i<j），左边都要小于等于基准值，右边都要大于等于基准值
    while(i < j){
     
        // 一定要注意：要从右边开始逼近，也就是从j开始：为了保证左边的数小于基准。
        //           因为如果你从i开始，最后while结束交换i和pivot的值，i的值可能比pivot大。而从右边开始，一定保证右边的比基准大，遇到小的才停下……
        //           比如： 3 2 6 5 7 基准是3，从i开始，i指到6结束，最后交换3和6，就是错误的因为6比3大呀～，嗯意会一下？
        // 这里也要加上硬性条件i<j，因为存在这样的情况：外面的条件时符合的，第一层第一次while也是符合的，但是经过第一层第一次之后i>j了
        while(i<j && arr[j] >= arr[pivot]){
            j--;
        }
        while(i<j && arr[i] <= arr[pivot]){
            i++;
        }
      
        // 如果上面两个while都过来了，那说明现在的情况就需要交换两边的值
        if(i<j){
            let tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
       
    }
    // 因为while结束的条件时i===j,所以需要交换基准值和第i或j个值
    let tp = arr[i];
    arr[i] = arr[pivot]; // 等价arr[j] = arr[pivot];
    arr[pivot] = tp;

    //接下来对左、右边的数组进行同样的判断
    quick(arr, left, i-1);
    quick(arr, i+1, right);
    return arr;
}

let l = arr.length;
console.log(quick(arr, 0, l-1));

———————————————————————————————————————————

（3）简单插入排序

假定第一个元素为有序的，之后遍历剩下的每个元素，每次选择一个元素，将其插入到有序区中。

// 时间复杂度：1+2+n-1 = O(n^2)
const a = [3,2,1];
let n = a.length;
let j = 0;
for(let i = 1;i<n;i++){
    for(j = i;j>0;j--){
        if(a[j]<a[j-1]){
            let tmp = a[j];
            a[j] = a[j-1];
            a[j-1] = tmp;
        }
    }
}
console.log(a);

// 另外一种写法
const arr = [3,2,1,5,4];
let l = arr.length;
for (let i = 1;i<l;i++){
    let cur = arr[i];
    let pre = i-1;
    while(pre>=0 && cur<arr[pre]){
        arr[pre+1] = arr[pre];
        pre--;
    }
    arr[pre+1] = cur;
      

}
console.log(arr);

———————————————————————————————————————————

（4）希尔排序

分组+插入；我们对所有数进行一次次的分组后，就会得到一个基本排好序的数组，再该基础上再进行一次简单插入排序，效率会明显得到提升。

// 时间复杂度：
// 当增量为1时希尔排序算法的时间复杂度为O(N^2);
// 当增量为其他时，希尔排序算法的时间复杂度为O(N^3/2);
const arr = [3,2,1,4,5,7,8];
let l = arr.length; 
for(let step = Math.floor(l/2); step > 0;step = Math.floor(step/2))
    {

        for(let i = step; i < l; i++)
        {
            tmp = arr[i];
            let j ;
            for(j = i - step; j >= 0 && tmp < arr[j];)
            {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = tmp;

        }
    }
console.log(arr);

———————————————————————————————————————————

（5）简单选择排序

每一次都选择出一个最小值和当前遍历的元素进行交换。

//时间复杂度：n-1 + n-2 + 1 = O(n^2)
const arr = [3,2,1,4,6,1];
let l = arr.length;
let minIndex = 0;
for(let i = 0; i<l-1;i++){
    minIndex = i;
    for(let j = i+1; j<l;j++){
        if(arr[j]<arr[minIndex]){
        minIndex = j;
        }
    }
    let tmp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = tmp;
 
}
console.log(arr);

// 另外一种写法
const arr = [3,2,1,4,5,1];
let min = 0;
// 进行n-1趟即可
for(let i = 0;i<arr.length-1;i++){
    for(let j = i;j<arr.length;j++){
        if(arr[j] < arr[min]){
            min = j;
        }
    }
    let tmp = arr[i];
    arr[i] = arr[min];
    arr[min] = tmp;
}
console.log(arr);

———————————————————————————————————————————

（6）堆排序

升序用大根堆（每个节点都大于等于其孩子节点，arr[i]>=arr[2*i+1]&&arr[i]>=arr[2*i+2]）因为想要升序的话，最后一个元素则是最大的；而大根堆首先第一个元素是最大的，将第一个元素和最后一个元素交换，相当于最大的元素沉到最底，也就是放到最后一个位置上，符合升序。

———————————————————————————————————————————

（7）归并排序

每部分都分成两个列表，每个列表都只有1个或者0个元素就是有序的了，那么接下去就是对每两个有序列表进行合并。

//时间复杂度：每次都分成两个子问题，相当于一颗递归数，第一层n，第二层分为两个n/2，第三层2个n/2分为
//产生一个n/4……，直到最后为n个1.每一层都是n，共有logn层，所以时间复杂度为O(nlgn) + 合并子问题的
//时间复杂度O(n) =  O(nlgn) 
    const arr = [3,2,1,4,7,2,8,9];

        function mergeSort(arr){
            var l = arr.length;
            if(l<2){
                return arr;
            }
            let middle = Math.floor(l/2),
            left = arr.slice(0,middle),
            right = arr.slice(middle);
            return merge(mergeSort(left), mergeSort(right));
        }
        

        function merge(left, right){

            var result= [];
            while(left.length>0 && right.length>0){
                if(left[0] <= right[0]){
                    result.push(left.shift());
                }else{
                    result.push(right.shift());
                }
            }

            while(left.length){
                result.push(left.shift());
            }
            while (right.length){
                result.push(right.shift());
            }
                
 
              return result;

        }
       console.log(mergeSort(arr));