前言
在上一篇文章《Javascript-数组乱序》中我们提到不同浏览器采用不同的排序算法来实现Array.prototype.sort方法，今天我们一起来学习常见的几种排序算法。
我们常说的十大经典排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序。
算法概述
算法分类
上面的十种排序算法可以分为两类：
比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破 O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
每个排序算法属于哪一类如下图所示：
算法复杂度
相关概念
在上图中我们标注了每个算法是否稳定，那么如何区分稳定和不稳定？
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b前面，而a=b，排序之后a可能会出现在b的后面。
冒泡排序
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。
算法步骤：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤1-3，直到没有任何一对数字需要比较。
代码实现：
JavaScript 代码实现
function bubbleSort(arr) { var len = arr.length; for (var i = 0; i < len - 1; i++) { for (var j = 0; j < len - i -1; j++) { if (arr[j] > arr[j+1]) { var temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } return arr;}选择排序
选择排序（Selection sort）是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
其算法思想：从数组中选择最小元素，并将其与第一个元素交换位置。再从数组中剩下的元素中选择出最小元素，将其与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复步骤2，直到所有元素均排序完毕。
代码实现
JavaScript代码实现：
function selectionSort(arr) { var len = arr.length; var index, temp; for (var i = 0; i < len - 1; i++) { index = i; for (var j = i + 1; j < len -1; j++) { if (arr[j] < arr[index]) { index = j; } temp = arr[i]; arr[i] = arr[index]; arr[index] = temp; } } return arr;}插入排序
插入排序（Insertion sort）是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序的时间复杂度取决于数组的初始顺序，如果数组已经部分有序了，那么逆序较少，需要的交换次数也就较少，时间复杂度较低。
- 平均情况下插入排序需要 N^2/4 比较以及 N^2/4 次交换；
- 最坏的情况下需要 N^2/2 比较以及 N^2/2 次交换，最坏的情况是数组是倒序的；
- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
算法步骤
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
代码实现
JavaScript代码实现
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;}希尔排序
对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减1。希尔排序的出现就是为了解决插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于1。
希尔排序(Shell's Sort)，也称为递减增量排序算法，是插入排序的一种更高效的改进版本，但希尔排序是非稳定排序算法。
希尔排序使用插入排序对间隔h的序列进行排序。通过不断减小h，最后令h=1，就可以使得整个数组是有序的。
希尔排序的运行时间达不到平方级别，使用递增序列1,4,10,20...的希尔排序所需要的比较次数不会超过N的若干倍乘以递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
算法步骤
选择一个增量序列 t1, t2, ..., tk，其中ti > tj, tk = 1;
按增量序列个数k，对序列进行k趟排序；
每趟排序，根据对应的增量ti， 将待排序列分割为若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。
代码实现
javascript实现
function shellSort(arr) { var len = arr.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 = arr[i]; for (var j = i - gap; j >=0 && arr[j] > temp; j -= gap) { arr[j + gap] = arr[j]; } arr[j + gap] = temp; } } return arr;}归并排序
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
归并排序是一种稳定的排序方法，和选择排序一样，性能不受输入数据的影响，但表现比选择排序好很多，因为时间复杂度始终都是O(nlogn)，代价就是需要额外的内存空间。
算法步骤
- 把长度为n的输入序列分为两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排好序的子序列合并成一个最终的排序序列。
代码实现
JavaScript
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 = [];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;}
我们先学习上面五种排序算法，另外五种下次再继续。
