一些前端该掌握的排序

粘别人的博客的部分博客放笔记里里，但是忘了是哪篇博客里😫

插入排序

// 首先将第一个元素看作一个有序的序列，从第二个元素起，逐个将元素i与已经排好的序列i~0的元素进行比较
// 如果该元素小于比较元素，则将比较元素向后移动，将改元素插入，否则就将它插在当前位置
    function insertSort (arr) {
        for (var i in arr) {
            for (var j = i - 1; j >= 0; j --) {
                if (arr[j + 1] < arr[j]) {
                    [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                } else if (arr[j + 1] >= arr[j]) {
                    break;
                }
            }
        }
        return arr;
    }

希尔排序

a、先将要数组按某个增量d（n/2,n为要排序数的个数）分成若干组，所有距离为d的倍数的记录放在同一个组中；在各组内进行直接插入排序；
b、然后再用一个较小的增量（d/2）对它进行分组，每组再进行直接插入排序；直至增量减为1，进行直接插入排序后，整体排序完成。

function shellSort(arr){
    let n = arr.length,
        d = n;
    //第一层循环:分割增量d
    while(d > 1){
        d = Math.floor(d/2);
        //下面；两层循环是直接插入排
        for(var i = d; i < n; i++){
            //记录待比较的元素
            var temp = arr[i];
            for(var j = i - d; j >= 0 && arr[j] > temp; j = j -d){
                arr[j + d] = arr[j];
            }
            arr[j + d] = temp;
        }
    }
    return arr;
}
console.log(shellSort([1,5,3,7,2,8]));

冒泡排序

基本思想——两两比较相邻的元素，如果反序，则交换位置，直到没有反序为止。有序区在后面。
a、将序列中的相邻元素依次比较，较大的数向上冒（即交换到后面）；第一轮比较结束后，序列最后一个元素是当前序列的最大值。
b、对序列当中剩下的n-1个元素再次执行步骤b，直至完成。共需要n-1轮比较。

function bubbleSort(arr) {  
    let len = arr.length;
    //共需要n-1趟排序
    for(let i = 1; i < len; i++){
        for(let j = 0; j < len - i; j++){
            if(arr[j] > arr[j + 1]){
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; //解构赋值进行交换
            }
        }
    }
    return arr;
}
console.log(bubbleSort([7, 3, 4, 5, 10, 7, 8, 2,21]));

快排

（1）基本思想：快排是冒泡排序的改进版。
a、从序列当中选择一个基准数（一般选第一个数）；
b、遍历数组，小于基准的放在left，大于基准的放在right；
c、递归。

function QSort(arr) {  
     //如果数组<=1,则直接返回
     if(arr.length <= 1){
         return arr;
    }
     //找基准，并把基准从原数组删除
     var pivot = arr.splice(0, 1)[0];
     //定义左右数组
     var left = [];
     var right = [];

     //比基准小的放在left，比基准大的放在right
     for(var i = 0; i < arr.length; i++){
         if(arr[i] <= pivot){
             left.push(arr[i]);
         }
         else{
             right.push(arr[i]);
         }
     }
     //递归
     return QSort(left).concat([pivot],QSort(right));
}
console.log(QSort([7,2, 3, 4, 5, 10, 7, 8, 2,21]));

最后附上经常会问到的时间复杂度情况：