JS中的算法与数据结构——排序（Sort）

时间 2019-11-05

原文原文链接

排序算法（Sort）

引言

咱们平时对计算机中存储的数据执行的两种最多见的操做就是排序和查找，对于计算机的排序和查找的研究，自计算机诞生以来就没有中止过。现在又是大数据，云计算的时代，对数据的排序和查找的速度、效率要求更高，所以要对排序和查找的算法进行专门的数据结构设计，（例如咱们上一篇聊到的二叉查找树就是其中一种），以便让咱们对数据的操做更加简洁高效。算法

这一篇咱们将会介绍一些数据排序的基本算法和高级算法并利用JavaScript来逐一实现，让大伙对计算机中常见的排序算法的思想和实现有基本的了解，起到一个抛砖引玉的做用。数组

关于排序算法的说明

在介绍各个算法以前，咱们有必要了解一下评估算法优劣的一些术语：数据结构

稳定：若是a本来在b前面，当a=b时，排序以后a仍然在b的前面
不稳定：若是a本来在b的前面，当a=b时，排序以后a可能会出如今b的后面学习

内排序：全部排序操做都在内存中完成
外排序：因为数据太大，所以把数据放在磁盘中，而排序经过磁盘和内存的数据传输才能进行测试

时间复杂度：一个算法执行所耗费的时间
空间复杂度：运行完一个程序所需内存的大小大数据

有想要了解更多，关于时间空间复杂度的，我推荐一篇文章，请戳这里这里ui

基本排序算法

基本排序算法的核心思想就是对一组数据按照必定的顺序从新排序，其中重排时通常都会用到一组嵌套的 for 循环，外循环会遍历数组的每一项元素，内循环则用于进行元素直接的比较。云计算

1.冒泡排序（BubbleSort）.net

冒泡排序是比较经典的算法之一，也是排序最慢的算法之一，由于它的实现是很是的容易的。设计

冒泡排序的算法思想以下（升序排序）：

比较相邻的元素。若是第一个比第二个大，就交换它们两个；
对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对，这样最终最大数被交换到最后的位置
除了最后一个元素之外，针对全部的元素重复以上的步骤
重复步骤1~3，直到排序完成

下面我借用网上一张动图，来展现冒泡排序的过程：

冒泡排序

具体的JS实现以下：

//冒泡排序
function bubbleSort ( data ) {
    var temp = 0;
    for ( var i = data.length ; i > 0 ; i -- ){
        for( var j = 0 ; j < i - 1 ; j++){
           if( data[j] > data[j + 1] ){
               temp = data[j];
               data[j] = data [j+1];
               data[j+1] = temp;
           }
        }
    }
    return data;
}

咱们先设定一组数据，后面咱们将都用这组数据来测试 :

var dataStore = [ 72 , 1 , 68 , 95 , 75 , 54 , 58 , 10 , 35 , 6 , 28 , 45 , 69 , 13 , 88 , 99 , 24 , 28 , 30 , 31 , 78 , 2 , 77 , 82 , 72 ];

console.log( '原始数据:' + dataStore );
console.log( '冒泡排序:' + bubbleSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 冒泡排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

2.选择排序（SelctionSort）

选择排序是一种比较简单直观的排序算法。它的算法思想是，从数组的开头开始遍历，将第一个元素和其余元素分别进行比较，记录最小的元素，等循环结束以后，将最小的元素放到数组的第一个位置上，而后从数组的第二个位置开始继续执行上述步骤。当进行到数组倒数第二个位置的时候，全部的数据就完成了排序。

选择排序一样会用到嵌套循环，外循环从数组第一个位置移到倒数第二个位置；内循环从第二个位置移动到数组最后一个位置，查找比当前外循环所指向的元素还要小的元素，每次内循环结束后，都会将最小的值放到合适的位置上。

一样，我借用网上一张动图，来展现选择排序的过程：

选择排序

了解了算法思想，具体实现应该也不成问题：

//选择排序
function selectionSort( data ) {
    for( var i = 0; i< data.length ; i++){
        var min = data[i];
        var temp;
        var index = i;
        for( var j = i + 1; j< data.length; j++){
            if( data[j] < min ){
                min = data[j];
                index = j;
            }
        }

        temp = data[i];
        data[i] = min;
        data[index]= temp;
    }
    return data;
}

它的测试结果以下：

console.log( '原始数据:' + dataStore );
console.log( '选择排序:' + selectionSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 选择排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

3.插入排序（insertionSort）

插入排序有点相似人类按字母顺序对数据进行排序，就如同你打扑克牌同样，将摸来的扑克按大小放到合适的位置同样。它的原理就是经过嵌套循环，外循环将数组元素挨个移动，而内循环则对外循环中选中的元素及它后面的元素进行比较；若是外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为内循环中的这个元素腾出位置。

实现步骤以下：

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

它的实现效果图以下：

插入排序

具体实现代码以下：

//插入排序

function insertionSort( data ) {
    var len = data.length;
    for (var i = 1; i < len; i++) {
        var key = data[i];
        var j = i - 1;
        while ( j >= 0 && data[j] > key) {
            data[j + 1] = data[j];
            j--;
        }
        data[j + 1] = key;
    }
    return data;
}

排序结果以下：

console.log( '原始数据:' + dataStore );
console.log( '插入排序:' + insertionSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 插入排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

咱们已经学习了三种基本的排序算法，其中冒泡排序是最慢的，插入排序是最快的，咱们能够在运行的过程当中经过 console.time('sortName') 和 console.timeEnd('sortName') 两个输出来看他们的效率如何，我这里给出一组值做为参考，实际中须要大量的数据测试和反复实验，进行数理统计后才能被视为有效的统计；

排序时间比较

高级排序算法

4.希尔排序（Shell Sort）

咱们首先要学习的就是希尔排序，又称缩小增量排序，这个算法是在插入排序的基础上作了很大的改善，与插入排序不一样的是，它首先会比较位置较远的元素，而非相邻的元素。这种方案可使离正确位置很远的元素可以快速回到合适的位置，当算法进行遍历时，全部元素的间距会不断的减少，直到数据的末尾，此时比较的就是相邻元素了。

该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，而后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。由于直接插入排序在元素基本有序的状况下（接近最好状况），效率是很高的，所以希尔排序在时间效率上有较大提升。

好吧，我仍是用个案例来解释，这样会更清晰，咱们如下面一组数据为例：

数据集

第一次 gap(增量) = 10 / 2 = 5 , 会按照下面进行分组获得五组数据（49，13）、（38，27）、（65，49）、（97，55）、（26，4），这样进行组内排序以后（13，49）、（27，38）、（49，65）、（55，97）、（4，26）

第一次分组

此时，数据会排成以下结构

第一次排序

第二次 gap = 5 / 2 = 2 , 此时能够获得两个分组，以下

第二次分组

再经过组内排序以后，能够获得

第二次排序

第三次 gap = 2 / 2 = 1 ，即不用分组，进行排序后

第三次排序

第四次 gap = 1 / 2 = 0 ，便可获得排序完成的数组

排序完成

如今，可能对希尔排序有了必定得了解了，用JS实现以下：

//希尔排序

function shallSort(array) {
    var increment = array.length;
    var i
    var temp; //暂存
    do {
        //设置增量
        increment = Math.floor(increment / 3) + 1;
        for (i = increment ; i < array.length; i++) {
            if ( array[i] < array[i - increment]) {
                temp = array[i];
                for (var j = i - increment; j >= 0 && temp < array[j]; j -= increment) {
                    array[j + increment] = array[j];
                }
                array[j + increment] = temp;
            }
        }
    }
    while (increment > 1)

    return array;
}

效果以下：

console.log( '原始数据:' + dataStore );
console.log( '希尔排序:' + shallSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 希尔排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

5.归并排序（Merge Sort）

将两个的有序数列合并成一个有序数列，咱们称之为"归并"，归并排序的思想就是将一系列排序好的子序列合并成一个大的完整有序的序列。

实现步骤以下：

把长度为n的输入序列分红两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列

一张动图来讲明归并排序的过程：

归并排序

具体的JS代码实现以下：

//归并排序

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

function merge(left, right)
{
    var result = [];
    while (left.length && right.length) {
        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( '原始数据:' + dataStore );
console.log( '希尔排序:' + mergeSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 希尔排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

6.快速排序（Quicksort）

快速排序是处理大数据最快的排序算法之一，它也是一种分而治之的算法，经过递归方式将数据依次分解为包含较小元素和较大元素的不一样子序列，会不断重复这个步骤，直到全部的序列所有为有序的，最后将这些子序列一次拼接起来，就可获得排序好的数据。

该算法首先要从数列中选出一个元素做为基数（pivot）。接着全部的数据都将围绕这个基数进行，将小于改基数的元素放在它的左边，大于或等于它的数所有放在它的右边，对左右两个小数列重复上述步骤，直至各区间只有1个数。

整个排序过程以下：

快速排序

具体实现以下：

//快速排序

function quickSort( arr ){
    if ( arr.length == 0) {
        return [];
    }
    var left = [];
    var right = [];
    var pivot = arr[0];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push( arr[i] );
        } else {
            right.push( arr[i] );
        }
    }
    return quickSort( left ).concat( pivot, quickSort( right ));
}

测试结果以下：

console.log( '原始数据:' + dataStore );
console.log( '快速排序:' + quickSort( dataStore) );

// 原始数据:72,1,68,95,75,54,58,10,35,6,28,45,69,13,88,99,24,28,30,31,78,2,77,82,72
// 快速排序:1,2,6,10,13,24,28,28,30,31,35,45,54,58,68,69,72,72,75,77,78,82,88,95,99

至此，咱们已基本介绍过一些常见的排序算法的思想和具体实现（基数排序在以前的文章已经介绍过，想要了解戳这里），排序算法博大精深，咱们不只要学习理论，也要不断去实践，你们加油！

做者：Cryptic连接：http://www.jianshu.com/p/8d30da8b832e來源：简书著做权归做者全部。商业转载请联系做者得到受权，非商业转载请注明出处。