经常使用的js排序算法

插入排序

算法描述：

1. 从第一个元素开始，该元素能够认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 若是该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤 2~5

var arr = [5, 6, 3, 1, 8, 7, 2, 4];
for(let i = 1;i<arr.length;i++){
    let myIndex = i;
    console.log('次数：'+i);
    for(let j = i-1 ; j >= 0 ; j -- ){
        console.log('单次比较数据：'+arr[myIndex]+'---'+arr[j])
        if(arr[myIndex] < arr[j]){
            [arr[myIndex],arr[j]] = [arr[j],arr[myIndex]];
            myIndex = j;
        }else{
          break;
        }
        console.log('数组'+arr);
    }
}

时间复杂度 O(n^2)
运行过程

选择排序

算法描述

• 直接从待排序数组中选择一个最小（或最大）数字，放入新数组中。
• 假定第一个数字是最小的，而后依次和后面的比较，哪一个小哪一个就记录当前那个的下标。
• 记录完下标了以后替换第一个和那个最小数字的位置
• 依次执行上述步骤，只不过最小的位置依次累加

var arr = [5, 6, 3, 1, 8, 7, 2, 4];
for(let i = 0; i < arr.length - 1;i++){
    console.log('次数'+Number(i+1))
    let minIndex = i;
    for(let j = i ;j < arr.length - 1; j++){
         console.log('单次比较数据:'+arr[minIndex]+'---'+arr[j+1])
         if(arr[minIndex] > arr[j+1]){
            minIndex = j+1;
         }
    }
    [arr[minIndex],arr[i]] = [arr[i],arr[minIndex]];
    console.log('数组'+arr);

}

时间复杂度 O(n^2)

运行过程

冒泡排序

就几种算法来看，感受冒泡是比较慢的

算法描述：

1. 比较相邻的元素。若是第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对全部的元素重复以上的步骤，除了最后一个。
4. 持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较。

var arr = [5, 6, 3, 1, 8, 7, 2, 4];
let count = 0;
for(let i = arr.length ; i > 0; i --){
    console.log('次数'+i);
    for(let j = 1; j < i; j ++){
        console.log('单次比较数据:'+arr[j]+'----'+arr[j-1])
        if(arr[j] < arr[j-1]){
            [arr[j],arr[j-1]] = [arr[j-1],arr[j]]
        }
    }
    console.log(arr);
}

时间复杂度 O(n^2)

运行过程

归并排序

归并排序的图可能一下看不懂，是由于图表明的是运行的过程,主要看算法描述

归并排序：其基本思想是分治策略，先进行划分，而后再进行合并。
假设要对数组C进行归并排序，步骤是：
1.先将C划分为两个数组A和B（即把数组C从中间分开）
2.再分别对数组A、B重复步骤1的操做，逐步划分，直到不能再划分为止(每一个子数组只剩下一个元素)，这样，划分的过程就结束了。
如： [12 20 30 21 15 33 26 19 40 25]
划分为: [12 20 30 21 15] [33 26 19 40 25]

[12 20]      [30 21 15]       [33 26]       [19 40 25]
     [12]  [20]   [30]  [21 15]     [33]  [26]    [19]    [40 25]
     [12]  [20]   [30] [21] [15]    [33]  [26]    [19]   [40] [25]

3.而后从下层往上层不断合并数组，每一层合并相邻的两个子数组，合并的过程是每次从待合并的两个子数组中选取一个最小的元素，而后把这个元素放到合并后的数组中，不断重复直到把两个子数组的元素都放到合并后的数组为止。
4.依次类推，直到合并到最上层结束，这时数据的排序已经完成了。

var arr = [5, 6, 3, 1, 8, 7, 2, 4,9];
function mergeSort(arr){
    if(arr.length === 1){
        return arr;
    }
    let midIndex = Math.floor(arr.length / 2);
    let leftArr = arr.slice(0,midIndex);
    let rightArr = arr.slice(midIndex);
    console.log('拆分数组'+leftArr+'------'+rightArr)
    return mergeFn(mergeSort(leftArr),mergeSort(rightArr));
}.
function mergeFn(left,right){
    let tmp = [];
    console.log(left + '----' + right);
    while (left.length && right.length) {
        console.log('单次比较数据：'+left[0]+'和'+right[0]+'谁小谁所在的数组就被shift掉一个')
        if (left[0] < right[0]){
          tmp.push(left.shift());
        }
        else{
          tmp.push(right.shift());
        }
        console.log(tmp);
    }
    let arra = tmp.concat(left, right);
    console.log('本次比较完毕:'+arra);

    return arra;

}
mergeSort(arr);

时间复杂度 O(nlogn)

运行过程，看了运行过程就能看懂图了，也知道js函数里的参数有函数的状况下的执行顺序是自左向右

快速排序

图上的运行方式是按照基准是第0号位算的，看起来稍微有点乱，不过只要知道快排是怎么算的就行了

算法描述：

• 在数据集之中，选择一个元素做为”基准”（pivot）。
• 全部小于”基准”的元素，都移到”基准”的左边；全部大于”基准”的元素，都移到”基准”的右边。这个操做称为分区 (partition)操做，分区操做结束后，基准元素所处的位置就是最终排序后它的位置。
• 对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到全部子集只剩下一个元素为止。

var arr = [5, 6, 3, 1, 8, 7, 2, 4];
function quickSort(arr){
    if(arr.length <= 1){
        return arr;
    }
    //找基准
    let midIndex = Math.floor(arr.length/2);
    //剔除基准值
    let midNum = arr.splice(midIndex,1)[0];
    console.log('基准值:'+midNum);
    let leftArr = [],rightArr=[];
    for(let i = 0 ; i < arr.length; i++){
        //小于基准的进左边，大于的进右边
        arr[i] < midNum ? leftArr.push(arr[i]) : rightArr.push(arr[i])
    }
    console.log('小于基准值的数组：'+leftArr);
    console.log('大于基准值的数组:'+rightArr);
    return quickSort(leftArr).concat(midNum,quickSort(rightArr));
}
quickSort(arr);

时间复杂度 O(nlogn)

运行过程

这个运行过程是按照基准为0号位算的；

总结

能够看到，快速排序和归并排序是比较快。并且快排更容易理解更好写一些。