排序算法归纳

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
冒泡排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
插入排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
归并排序	$O(nlogn)$	O($nlogn$)	O($nlogn$)	O($n+logn$)	稳定
桶排序	$O(n+k)$	$O(n+k)$	$O(n^2)$	$O(n+k)$	稳定
计数排序	$O(n+k)$	$O(n+k)$	$O(n+k)$	$O(k)$	稳定
基数排序	$O(n\ast m)$	$O(n\ast m)$	$O(n\ast m)$	$O(n+m)$	稳定
选择排序	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O(1)$	不稳定
希尔排序	$O(nlogn)$	$O(nlo{g}^{2}n)$	$O(n^2)$	$O(1)$	不稳定
快速排序	$O(nlogn)$	$O(nlogn)$	$O(n^2)$	$O(logn)$	不稳定
堆排序	$O(nlogn)$	$O(nlogn)$	$O(nlogn)$	$O(1)$	不稳定

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
时间复杂度： 一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

1、比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3、针对所有的元素重复以上的步骤，除了最后一个；
4、重复步骤1~3，直到排序完成。

例子

对于数组[64, 55, 82, 64, 90, 19, 28, 98, 46]，一趟冒泡排序过程为：
64和55交换，[55 ，64, 82, 64, 90, 19, 28, 98, 46]；
64小于82，不交换，[55, 64, 82, 64, 90, 19, 28, 98, 46]；
82大于64，交换后得[55, 64, 64, 82, 90, 19, 28, 98, 46]；
82小于90，不交换，[55, 64, 64, 82, 90, 19, 28, 98, 46]；
19小于90，交换后得[55, 64, 82, 64, 19, 90, 28, 98, 46]；
28小于90，交换[55, 64, 82, 64, 19, 28, 90, 98, 46]；
90小于98，不交换，[55, 64, 82, 64, 19, 28, 90, 98, 46]；
98大于，交换后得[55, 64, 82, 64, 19, 28, 90, 46, 98]；

1.2 适用场景

冒泡排序思路简单，代码也简单，特别适合小数据的排序。但是，由于算法复杂度较高，在数据量大的时候不适合使用。

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、插入排序

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

2.1 算法描述

1、把待排序的数组分成已排序和未排序两部分，初始的时候把第一个元素认为是已排好序的。
2、取出下一个元素，在已经排序的元素序列中从后向前扫描；
3、如果该元素（已排序）大于新元素，将该元素移到下一位置；
4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5、将新元素插入到该位置后；
6、重复上述过程直到最后一个元素被插入有序子数组中。

2.2 适用场景

插入排序由于$O(n^2)$的复杂度，在数组较大的时候不适用。但是，在数据比较少的时候，是一个不错的选择，一般做为快速排序的扩充。例如，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序。

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、归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述
两种方法

3.1 递归法（Top-down）

1、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2、设定两个指针，最初位置分别为两个已经排序序列的起始位置
3、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4、重复步骤3直到某一指针到达序列尾
5、将另一序列剩下的所有元素直接复制到合并序列尾

3.2 迭代法（Bottom-up）

原理如下（假设序列共有n个元素）：
1、将序列每相邻两个数字进行归并操作，形成ceil(n/2)个序列，排序后每个序列包含两/一个元素
2、若此时序列数不是1个则将上述序列再次归并，形成ceil(n/4)个序列，每个序列包含四/三个元素
3、重复步骤2，直到所有元素排序完毕，即序列数为1

3.3 适用场景

归并排序在数据量比较大的时候也有较为出色的表现（效率上），但是，其空间复杂度O(n)使得在数据量特别大的时候（例如，1千万数据）几乎不可接受。而且，考虑到有的机器内存本身就比较小，因此，采用归并排序一定要注意。

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>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;
}