数组排序多种方法汇总

一、冒泡排序

排序规则：比较相邻元素，符合比较条件，交换位置较大的往后排，反复比较交换，直到所有数据都符合排序条件，得出排序效果，结束排序。

稳定性：稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function BubbleSort(ary){
    for(var i = 0;  i < ary.length - 1;  i++){
        for(var j = i + 1;  j < ary.length;  j++){
            var current = ary[i];
            if(current > ary[j]){
                var tmp = ary[j];
                ary[j] = current;
                ary[i] = tmp;
             }
         }
    }
   return ary;
}

BubbleSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]

 二、选择排序

排序规则：通过比较，选出最小的数放在第一位，然后在其余所有的数中选出最小的数排在第二位，以此类推，直到排序结束。

稳定性：不稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function SelectSort(ary){
    for(var i = 0; i < ary.length - 1; i++){
        for(var j = i + 1; j < ary.length; j++){
            if(ary[i] > ary[j]){
                var tmp = ary[i];
                ary[i] = ary[j];
                ary[j] = tmp;
            }
        }
    }
    return ary;
}

SelectSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]

三、插入排序

排序规则：插入排序得比喻成斗地主，手里摸牌之后都是按照从小到大的顺序。每摸到一张牌就把他们插入到合适的位置，使得他们比后面小，比前面大或者相等。

稳定性：稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function InsertSort(ary){
    var temp;
    for (var i = 1; i < ary.length; i++) {
        for (var j = i-1; j >=0; j--) {
            if (ary[j+1] < ary[j]) {
                temp = ary[j+1];
                ary[j+1] = ary[j];
                ary[j] = temp;
            } else if (ary[j+1] >= ary[j]) {
                break;
            }
        }
    }
    return ary;
}

InsertSort(arr);  // [1, 2, 3, 4, 5, 6, 15, 21, 63]

四、快速排序

排序规则：从数组中找一个基准值，通过这个值挨个和数组中的值进行比较，大的放一边，小的放一边，然后进行合并后，在进行比较，反复直至结束。

稳定性：不稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
var quickSort = function(ary) {
    if (ary.length <= 1) {
        return ary;
    }
    var pivotIndex = Math.floor(ary.length / 2);
    var pivot = ary.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];

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

quickSort(arr);  // [1, 2, 3, 4, 5, 6, 15, 21, 63]

五、堆排序

排序规则：堆是一棵顺序存储的二叉树，堆分为最大堆和最小堆，最大堆父节点都大于子节点, 最小堆父节点都小于子节点，左子节点: 2*i +1 (i: 父节点index)，右子节点: 2*i+2，从最后一个非叶子节点开始将堆进行小顶堆排序，每次拿出根节点,并和最后一个节点进行交换，重新进行堆的建立。

稳定性：不稳定

排序动态示意：

代码实现： 

var arr = [3,4,1,2,21,5,15,6,63];
function HeapSort(ary) {
     // 实现最大堆
     // start: 父节点, end: 循环深度
    function maxHeap(ary, start, end) {
        let parent = start, // 父节点
        son = parent*2 + 1, // 左子节点
        temp = null;
        // 规定循序最大深度
        while(son<=end) {
            // 如果存在右子节点, 并且判断右节点是否大于左节点
            if(son+1<=end && ary[son] < ary[son+1]) son++;
            if(ary[son] > ary[parent]) {
                temp = ary[son];
                ary[son] = ary[parent];
                ary[parent] = temp;
                parent = son;
                son = parent*2 +1;
            }else {
                return;
            }
        }
    }
    // 构建最大堆  ary.length/2-1: 表示最后一个父节点
    for(let i = ary.length/2-1; i>=0; i--) {
        maxHeap(ary, i, ary.length-1);
    }
    // 排序
    for(let i = ary.length-1; i>0; i--) {
        let temp = ary[0];
        ary[0] = ary[i];
        ary[i]= temp;
        // 剔除最后一个元素,并复原最大堆
        maxHeap(ary, 0, i-1);
    }
    return ary;
}

HeapSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]

六、递并排序

排序规则：将长的数组分解为短的数组，一直分到最后，单个单个数组比较，我们就认为，只有一个元素的数组是有序的。然后再逐个的合并。

稳定性：稳定

排序动态示意：

 

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function MergeSort(ary) {  //采用自上而下的递归方法
    var len = ary.length;
    if(len < 2) {
        return ary;
    }
    var middle = Math.floor(len / 2),
        left = ary.slice(0, middle),
        right = ary.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;
}

MergeSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]

七、希尔排序

排序规则：希尔排序是插入排序的一种更高效率的实现。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

稳定性：不稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function ShellSort(ary) {
    var len = ary.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = ary[i];
            for (var j = i-gap; j >= 0 && ary[j] > temp; j-=gap) {
                ary[j+gap] = ary[j];
            }
            ary[j+gap] = temp;
        }
    }
    return ary;
}

ShellSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]

　　

八、计数排序

排序规则：

    1、找出待排序的数组中最大和最小的元素，然后建立一个数组C用于统计待排数组中最小元素到最大元素区间中每个元素出现次数；

　 2、统计数组中每个值为i的元素出现的次数，存入数组C的第i项；

    3、对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

    4、反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

稳定性：稳定

排序动态示意：

代码实现：

var arr = [3,4,1,2,21,5,15,6,63];
function CountSort(ary){
    let obj={};
    for(let i=0; i<ary.length; i++){
        if(!obj[ary[i]]){
            obj[ary[i]]=1;
        }else{
            obj[ary[i]]++;
        } 
    }
    let index=0;
    //遍历对象属性名，按顺序放回覆盖原数组
    for(let key in obj){
        while(obj[key]>0){
            ary[index]=Number(key);
            obj[key]--;
            index++
        }
    }
    return ary;
}

CountSort(arr); // [1, 2, 3, 4, 5, 6, 15, 21, 63]