簡單玩轉JS數組十大排序算法

先上一張耳熟能詳的圖

n: 數據規模
k:“桶”的個數
In-place: 佔用常數內存，不佔用額外內存
Out-place: 佔用額外內存
穩定性：排序後2個相等鍵值的順序和排序之前它們的順序相同

1、冒泡排序
前後兩個數據對比，找出較大的值並交換位置，繼續向後比較最後找出最大的值；
內層循環一次，找出一個最大值，當找到倒數第二大的值得時候，循環結束。

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        //相鄰元素兩兩對比
                var temp = arr[j+1];        //元素交換
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

2、選擇排序
用最開始的數據和所有的數據作比較，得到最小的數，依次循環找到每次循環最小的數。即可得到升序的數據。

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

3、快速排序
快速排序採取了分而治之的思想，有點二分法的意思。
簡而言之，取一箇中間值，大於中間值的放在右邊，小於的放在左邊，然後依次循環左右兩邊的數組繼續取中間值作比較，直至排序完成，拼接即可。

var quickSort = function(arr) {
    　　if (arr.length <= 1) { return arr; }
    　　var pivotIndex = Math.floor(arr.length / 2);
    　　var pivot = arr.splice(pivotIndex, 1)[0];
    　　var left = [];
    　　var right = [];
    　　for (var i = 0; i < arr.length; i++){
    　　　　if (arr[i] < pivot) {
    　　　　　　left.push(arr[i]);
    　　　　} else {
    　　　　　　right.push(arr[i]);
    　　　　}
    　　}
    　　return quickSort(left).concat([pivot], quickSort(right));
    };
    quickSort([3, 2, 4, 5, 1]);

4、插入排序

function insertionSort(arr) {
	    var len = arr.length;
	    var preIndex, current;
	    for (var i = 1; i < len; i++) {
	        preIndex = i - 1;
	        current = arr[i];
	        while(preIndex >= 0 && arr[preIndex] > current) {
	        //這一個循環的含義:當前的元素和數組中下標小於它的元素作對比，如果當前元素大於，則位置不變，小於的話繼續比較，然後找到大於的位置插入進去
	            arr[preIndex+1] = arr[preIndex];
	            preIndex--;
	        }
	        arr[preIndex+1] = current;
	    }
	    return arr;
	}

二分法插入排序
function binaryInsertionSort(array) {
	　　for (var i = 1; i < array.length; i++) {
	　　　　var key = array[i], left = 0, right = i - 1;
	　　　　while (left <= right) {//當數據不進入這個循環的時候，就說明left大於right，也就說明key的值介於left和right之間
	　　　　　　var middle = parseInt((left + right) / 2);
	　　　　　　if (key < array[middle]) {
	　　　　　　　　right = middle - 1;
	　　　　　　} else {
	　　　　　　　　left = middle + 1;
	　　　　　　}
	　　　　}
	　　　　for (var j = i - 1; j >= left; j--) {//由於上一步的操作導致left和right的位置交換，所以我們以left之前作爲插入可以的位置，所以left以後的數據需要後移
	　　　　　　array[j + 1] = array[j];
	　　　　}
	　　　　array[left] = key;//left以後的數據後移一位後，就可以將key放在left的位置了。
	　　}
	　　return array;
	}
	var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
	仔細看說明，就能明白其中的意思。

5、希爾排序
看圖，看明白了，就懂了

function shellSort(arr) {
        　　var len = arr.length,
        　　temp,
        　　gap = 1;
        　　while(gap < len/5) { //動態定義間隔序列
        　　　　gap =gap*5+1;
                console.log(gap);
        　　}
        　　for (gap; gap > 0; gap = Math.floor(gap/5)) {
        　　　　for (var i = gap; i < len; i++) {
        　　　　　　temp = arr[i];
        　　　　　　for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
        　　　　　　　　arr[j+gap] = arr[j];
        　　　　　　}
        　　　　　　arr[j+gap] = temp;
        　　　　}
                console.log(arr);
        　　}
        　　return arr;
        }
        var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48,77,64];
        console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]；
        數據分組比較

6、歸併排序
主要的思想是把數組拆分成小的數組，然後小數據進行比較，將比較後的值按順序放在一個空數組裏

function mergeSort(arr) { //採用自上而下的遞歸方法,用來拆分數據成小的數組
    		var len = arr.length;
    	　　if(len < 2) {
    	　　　　return arr;
    	　　}
    	　　var middle = Math.floor(len / 2),
    	　　left = arr.slice(0, middle),
    	　　right = arr.slice(middle);
    	　　return merge(mergeSort(left), mergeSort(right));
    	}
    	function merge(left, right){
    	　　var result = [];
    	　　console.time('歸併排序耗時');
    	　　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());
    	　　}
    	　　console.timeEnd('歸併排序耗時');
    	　　return result;
    	}
    	var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
    	console.log(mergeSort(arr));

7、堆排序

function heapSort(array) {
	　　console.time('堆排序耗時');
	　　//建堆
	　　var heapSize = array.length, temp;
	　　for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {　　
	　　　　heapify(array, i, heapSize);
	　　}
	　　//堆排序
	　　for (var j = heapSize - 1; j >= 1; j--) {
	　　　　temp = array[0];
	　　　　array[0] = array[j];
	　　　　array[j] = temp;
	　　　　console.log(array)
	　　　　heapify(array, 0, --heapSize);
	　　}
	　　console.timeEnd('堆排序耗時');
	　　return array;
	}
	function heapify(arr, x, len) {
	　　var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp;
	　　if (l < len && arr[l] > arr[largest]) {
	　　　　largest = l;
	　　}
	　　if (r < len && arr[r] > arr[largest]) {
	　　　　largest = r;
	　　}
	　　if (largest != x) {
	　　　　temp = arr[x];
	　　　　arr[x] = arr[largest];
	　　　　arr[largest] = temp;
	　　　　console.log(arr)
	　　　　heapify(arr, largest, len);
	　　}
	}
	var arr=[91,60,96,13,35,65,46,65,10,30,20,31,77,81,22];
	console.log(heapSort(arr));//[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]；

8、計數排序
9、桶排序
10、基數排序