JavaScript 几种数组排序

/**
 *
 * @authors Your Name (you@example.org)
 * @date    2019-01-09 10:41:53
 * @version $Id$
 */

var array = [6,4,1,7,2,5,8,3];

//借助sort排序
array.sort(function(a,b){
	//return a-b;  //升序[默认]
	return b-a;  //降序
});

/**
 * 冒泡排序：
 * 1.比较相邻的两个元素，如果前一个比后一个大，则交换位置。
 * 2.第一轮的时候最后一个元素应该是最大的一个。
 * 3.按照步骤一的方法进行相邻两个元素的比较，这个时候由于最后一个元素已经是最大的了，所以最后一个元素不用比较
 * @param  {[type]} array [description]
 * @return {[type]}       [description]
 */
function bubbleSort(array) {
    var k = array.length;
    for(var i=0;i<k-1;i++) {
        for(var j=0;j<k-1-i;j++) {
            if(array[j]>array[j+1]) {
                var tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
        }
    }
    return array;
}

/**
 * 快速排序
 * 1.通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小
 * 2.然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
 * @param  {[Array]} array [传入的数组]
 * @return {[Array]}       [description]
 */
function quickSort(array) {
	if(array.length<=1) return array;
	var index = Math.floor(array.length/2);  //中间值的索引
	var indexVal = array.splice(index, 1)[0];  //中间值
	var left = [];
	var right = [];
	for(var i=0; i<array.length; i++) {
		if(array[i]<indexVal) {
			left.push(array[i]);
		}
		else {
			right.push(array[i]);
		}
	}
	return quickSort(left).concat([indexVal], quickSort(right));
}

/**
 * 选择排序
 * 1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
 * 2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
 * 3.以此类推，直到所有元素均排序完毕。
 * @param  {[type]} array [description]
 * @return {[type]}       [description]
 */
function selectSort(array) {
    var k = array.length;
    for(var i=0; i<k-1; i++) {
        var minIndex = i;
        for(var j=i+1; j<k; j++) {
            if(array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        var temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
    return array;
}

/**
 * 插入排序：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表
 * 1.从第一个元素开始，该元素可以认为已经被排序；
 * 2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
 * 3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
 * 4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
 * 5.将新元素插入到该位置后；
 * 6.重复步骤2~5
 * @param  {[type]} array [description]
 * @return {[type]}       [description]
 */
function insertSort(array) {
    for(var i=1; i<array.length; i++) {
        if(array[i]<array[i-1]) {
            var temp = array[i];
            var j = i-1;
            while(j>=0&&array[j]>temp) {
                array[j+1] = array[j];
                j--;
            }
            array[j+1] = temp;
        }
    }
    return array;
}

/**
 * 希尔排序
 * 1.按一定的间隔对数列进行分组，然后在每一个分组中做插入排序；
 * 2.随后逐次缩小间隔，在每一个分组中做插入排序...直到间隔等于1，做一次插入排序后结束。
 * @param  {[type]} array [description]
 * @return {[type]}       [description]
 */
function shellSort(array) {
    var gap = Math.floor(array.length/2);
    while(gap!==0) {
        for(var i=gap; i<array.length; i++) {
            var temp = array[i];
            var j = i- gap;
            for(; j>=0&&array[j]>temp; j-=gap) {
                array[j+gap] = array[j];
            }
            /*while(j>=0&&array[j]>temp) {
                array[j+gap] = array[j];
                j-=gap;
            }*/
            array[j+gap] = temp;
        }
        gap = Math.floor(gap/2);
    }
    return array;
}

/**
 * 归并排序
 * 1、把长度为n的输入序列分成两个长度为n/2的子序列
 * 2、对这两个子序列继续分为m/2的子序列，一直分下去，直为1个元素
 * 3、将两个排序好的子序列合并成一个最终的排序序列
 * @param  {[type]} array [description]
 * @return {[type]}       [description]
 */
function mergeSort(array) {
    if(array.length<=1) return array;
    var mid = Math.floor(array.length/2);
    var left = array.slice(0, mid);
    var right = array.slice(mid);
    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;
}

对于归并排序，接触的少，花了点时间才琢磨透代码的含义，画了个草图帮助理解：

若有不对的地方，欢迎指正~~