插入排序(Insertion-Sort)的算法描述是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列,對於未排序數據,在已排序序列中從後向前掃描,找到相應位置並插入。插入排序在實現上,一般採用in-place排序(即只需用到O(1)的額外空間的排序),於是在從後向前掃描過程當中,須要反覆把已排序元素逐步向後挪位,爲最新元素提供插入空間。算法
通常來講,插入排序都採用in-place在數組上實現。具體算法描述以下:api
function insertionSort(array) { if (Object.prototype.toString.call(array).slice(8, -1) === ‘Array’) { for (var i = 1; i < array.length; i++) { var key = array[i]; var j = i – 1; while (j >= 0 && array[j] > key) { array[j + 1] = array[j]; j–; } array[j + 1] = key; } return array; } else { return ‘array is not an Array!’; } }
二分插入(Binary-insert-sort)排序是一種在直接插入排序算法上進行小改動的排序算法。其與直接插入排序算法最大的區別在於查找插入位置時使用的是二分查找的方式,在速度上有必定提高。數組
通常來講,插入排序都採用in-place在數組上實現。具體算法描述以下:數據結構
function binaryInsertionSort(array) { if (Object.prototype.toString.call(array).slice(8, -1) === ‘Array’) { for (var i = 1; i < array.length; i++) { var key = array[i], left = 0, right = i – 1; while (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–) { array[j + 1] = array[j]; } array[left] = key; } return array; } else { return ‘array is not an Array!’; } }
選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工做原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,而後,再從剩餘未排序元素中繼續尋找最小(大)元素,而後放到已排序序列的末尾。以此類推,直到全部元素均排序完畢。ide
n個記錄的直接選擇排序可通過n-1趟直接選擇排序獲得有序結果。具體算法描述以下:ui
function selectionSort(array) { if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') { var len = array.length, temp; for (var i = 0; i < len - 1; i++) { var min = array[i]; for (var j = i + 1; j < len; j++) { if (array[j] < min) { temp = min; min = array[j]; array[j] = temp; } } array[i] = min; } return array; } else { return ‘array is not an Array!’; } }
冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列,一次比較兩個元素,若是它們的順序錯誤就把它們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換,也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。spa
function bubbleSort(array) { if (Object.prototype.toString.call(array).slice(8, -1) === ‘Array’) { var len = array.length, temp; for (var i = 0; i < len – 1; i++) { for (var j = len – 1; j >= i; j–) { if (array[j] < array[j - 1]) { temp = array[j]; array[j] = array[j - 1]; array[j - 1] = temp; } } } return array; } else { return ‘array is not an Array!’; } }
快速排序的基本思想:經過一趟排序將待排記錄分隔成獨立的兩部分,其中一部分記錄的關鍵字均比另外一部分的關鍵字小,則可分別對這兩部分記錄繼續進行排序,以達到整個序列有序prototype
快速排序使用分治法來把一個串(list)分爲兩個子串(sub-lists)。具體算法描述以下:設計
//方法一 function quickSort(array, left, right) { if (Object.prototype.toString.call(array).slice(8, -1) === ‘Array’ && typeof left === ‘number’ && typeof right === ‘number’) { if (left < right) { var x = array[right], i = left – 1, temp; for (var j = left; j <= right; j++) { if (array[j] <= x) { i++; temp = array[i]; array[i] = array[j]; array[j] = temp; } } quickSort(array, left, i – 1); quickSort(array, i + 1, right); }; } else { return ‘array is not an Array or left or right is not a number!’; } } var aaa = [3, 5, 2, 9, 1]; quickSort(aaa, 0, aaa.length – 1); console.log(aaa); //方法二 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)); };
堆排序(Heapsort)是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似徹底二叉樹的結構,並同時知足堆積的性質:即子結點的鍵值或索引老是小於(或者大於)它的父節點。code
function heapSort(array) { if (Object.prototype.toString.call(array).slice(8, -1) === ‘Array’) { var heapSize = array.length, temp; // 建堆 for (var i = Math.floor(heapSize / 2); 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; heapify(array, 0, –heapSize); } } else { return ‘array is not an Array!’; } } /** 方法說明:維護堆的性質 * @param arr 數組 * @param x 數組下標 * @param len 堆大小 */ function heapify(arr, x, len) { if (Object.prototype.toString.call(arr).slice(8, -1) === ‘Array’ && typeof x === ‘number’) { var l = 2 * x, r = 2 * x + 1, 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; heapify(arr, largest, len); } } else { return ‘arr is not an Array or x is not a number!’; } }
歸併排序是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法(Divide and Conquer)的一個很是典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併,獲得徹底有序的序列;即先使每一個子序列有序,再使子序列段間有序。若將兩個有序表合併成一個有序表,稱爲2-路歸併。
function mergeSort(array, p, r) { if (p < r) { var q = Math.floor((p + r) / 2); mergeSort(array, p, q); mergeSort(array, q + 1, r); merge(array, p, q, r); } } function merge(array, p, q, r) { var n1 = q – p + 1, n2 = r – q, left = [], right = [], m = n = 0; for (var i = 0; i < n1; i++) { left[i] = array[p + i]; } for (var j = 0; j < n2; j++) { right[j] = array[q + 1 + j]; } left[n1] = right[n2] = Number.MAX_VALUE; for (var k = p; k <= r; k++) { if (left[m] <= right[n]) { array[k] = left[m]; m++; } else { array[k] = right[n]; n++; } } }
桶排序 (Bucket sort)的工做的原理:假設輸入數據服從均勻分佈,將數據分到有限數量的桶裏,每一個桶再分別排序(有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排序)。
/** * 方法說明:桶排序 * @param array 數組 * @param num 桶的數量 */ function bucketSort(array, num) { if (array.length <= 1) { return array; } var len = array.length, buckets = [], result = [], min = max = array[0], regex = ‘/^[1-9]+[0-9]*$/’, space, n = 0; num = num || ((num > 1 && regex.test(num)) ? num : 10); for (var i = 1; i < len; i++) { min = min <= array[i] ? min : array[i]; max = max >= array[i] ? max : array[i]; } space = (max – min + 1) / num; for (var j = 0; j < len; j++) { var index = Math.floor((array[j] – min) / space); if (buckets[index]) { // 非空桶,插入排序 var k = buckets[index].length – 1; while (k >= 0 && buckets[index][k] > array[j]) { buckets[index][k + 1] = buckets[index][k]; k–; } buckets[index][k + 1] = array[j]; } else { //空桶,初始化 buckets[index] = []; buckets[index].push(array[j]); } } while (n < num) { result = result.concat(buckets[n]); n++; } return result; }
計數排序(Counting sort)是一種穩定的排序算法。計數排序使用一個額外的數組C,其中第i個元素是待排序數組A中值等於i的元素的個數。而後根據數組C來將A中的元素排到正確的位置。它只能對整數進行排序。
function countingSort(array) { var len = array.length, B = [], C = [], min = max = array[0]; for (var i = 0; i < len; i++) { min = min <= array[i] ? min : array[i]; max = max >= array[i] ? max : array[i]; C[array[i]] = C[array[i]] ? C[array[i]] + 1 : 1; } for (var j = min; j < max; j++) { C[j + 1] = (C[j + 1] || 0) + (C[j] || 0); } for (var k = len – 1; k >=0; k–) { B[C[array[k]] – 1] = array[k]; C[array[k]]–; } return B; }