0、算法概述
0.1 算法分类
十种常见排序算法可以分为两大类：
- 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
- 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
0.2 算法复杂度
0.3 相关概念
- 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
- 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
- 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
- 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数
1、冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
1.2 图片演示
我们先分析第1趟排序
当i=5,j=0时，a[0]<a[1]。此时，不做任何处理！
当i=5,j=1时，a[1]>a[2]。此时，交换a[1]和a[2]的值；交换之后，a[1]=30，a[2]=40。
当i=5,j=2时，a[2]>a[3]。此时，交换a[2]和a[3]的值；交换之后，a[2]=10，a[3]=40。
当i=5,j=3时，a[3]<a[4]。此时，不做任何处理！
当i=5,j=4时，a[4]>a[5]。此时，交换a[4]和a[5]的值；交换之后，a[4]=50，a[3]=60。
于是，第1趟排序完之后，数列{20,40,30,10,60,50}变成了{20,30,10,40,50,60}。此时，数列末尾的值最大。
根据这种方法：
第2趟排序完之后，数列中a[5...6]是有序的。
第3趟排序完之后，数列中a[4...6]是有序的。
第4趟排序完之后，数列中a[3...6]是有序的。
第5趟排序完之后，数列中a[1...6]是有序的。
第5趟排序之后，整个数列也就是有序的了。
观察上面冒泡排序的流程图，第3趟排序之后，数据已经是有序的了；第4趟和第5趟并没有进行数据交换。
下面我们对冒泡排序进行优化，使它效率更高一些：添加一个标记，如果一趟遍历中发生了交换，则标记为true，否则为false。如果某一趟没有发生交换，说明排序已经完成。
冒泡排序时间复杂度
冒泡排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1次！因此，冒泡排序的时间复杂度是O(N2)。
冒泡排序稳定性
冒泡排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
1.3 代码实现
/**
* 冒泡排序：C++
*
* @author skywang
* @date 2014/03/11
*/
#include <iostream>
using namespace std;
/*
* 冒泡排序
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void bubbleSort1(int* a, int n)
{
int i,j,tmp;
for (i=n-1; i>0; i--)
{
// 将a[0...i]中最大的数据放在末尾
for (j=0; j<i; j++)
{
if (a[j] > a[j+1])
{
// 交换a[j]和a[j+1]
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
}
/*
* 冒泡排序(改进版)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void bubbleSort2(int* a, int n)
{
int i,j,tmp;
int flag; // 标记
for (i=n-1; i>0; i--)
{
flag = 0; // 初始化标记为0
// 将a[0...i]中最大的数据放在末尾
for (j=0; j<i; j++)
{
if (a[j] > a[j+1])
{
// 交换a[j]和a[j+1]
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
flag = 1; // 若发生交换，则设标记为1
}
}
if (flag==0)
break; // 若没发生交换，则说明数列已有序。
}
}
int main()
{
int i;
int a[] = {20,40,30,10,60,50};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
bubbleSort1(a, ilen);
//bubbleSort2(a, ilen);
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
2、快速排序（Quick Sort）
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
2.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
2.2 图片演示
上图只是给出了第1趟快速排序的流程。在第1趟中，设置x=a[i]，即x=30。
(01) 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=20，此时j=4；然后将a[j]赋值a[i]，此时i=0；接着从左往右遍历。
(02) 从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=40，此时i=1；然后将a[i]赋值a[j]，此时j=4；接着从右往左遍历。
(03) 从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=10，此时j=3；然后将a[j]赋值a[i]，此时i=1；接着从左往右遍历。
(04) 从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=60，此时i=2；然后将a[i]赋值a[j]，此时j=3；接着从右往左遍历。
(05) 从"右 --> 左"查找小于x的数：没有找到满足条件的数。当i>=j时，停止查找；然后将x赋值给a[i]。此趟遍历结束！
按照同样的方法，对子数列进行递归遍历。最后得到有序数组！
快速排序稳定性
快速排序是不稳定的算法，它不满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
快速排序时间复杂度
快速排序的时间复杂度在最坏情况下是O(N2)，平均的时间复杂度是O(N*lgN)。
这句话很好理解：假设被排序的数列中有N个数。遍历一次的时间复杂度是O(N)，需要遍历多少次呢？至少lg(N+1)次，最多N次。
(01) 为什么最少是lg(N+1)次？快速排序是采用的分治法进行遍历的，我们将它看作一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是lg(N+1)。因此，快速排序的遍历次数最少是lg(N+1)次。
(02) 为什么最多是N次？这个应该非常简单，还是将快速排序看作一棵二叉树，它的深度最大是N。因此，快读排序的遍历次数最多是N次。
2.3 代码实现
/**
* 快速排序：C++
*
* @author skywang
* @date 2014/03/11
*/
#include <iostream>
using namespace std;
/*
* 快速排序
*
* 参数说明：
* a -- 待排序的数组
* left -- 数组的左边界(例如，从起始位置开始排序，则left=0)
* right -- 数组的右边界(例如，排序截至到数组末尾，则right=a.length-1)
*/
void quickSort(int* a, int left, int right)
{
if (left < right)
{
int i,j,x;
i = left;
j = right;
x = a[i];
while (i < j)
{
while(i < j && a[j] > x)
j--; // 从右向左找第一个小于x的数
if(i < j)
a[i++] = a[j];
while(i < j && a[i] < x)
i++; // 从左向右找第一个大于x的数
if(i < j)
a[j--] = a[i];
}
a[i] = x;
quickSort(a, left, i-1); /* 递归调用 */
quickSort(a, i+1, right); /* 递归调用 */
}
}
int main()
{
int i;
int a[] = {80,70,40,12,33,90};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
quickSort(a, 0, ilen-1);
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
3、插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
3.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
3.2 图片演示
直接插入排序时间复杂度
直接插入排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，直接插入排序的时间复杂度是O(N2)。
直接插入排序稳定性
直接插入排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
3.3 代码实现
#include <stdio.h>
void insert_sort(int a[],int n)
//待排序元素用一个数组a表示，数组有n个元素
{
int i,j;
int temp;
for ( i=1; i<n; i++) //i表示插入次数，共进行n-1次插入
{
temp=a[i]; //把待排序元素赋给temp，temp在while循环中并不改变，这样方便比较，并且它是要插入的元素
j=i-1;
//while循环的作用是将比当前元素大的元素都往后移动一个位置
while ((j>=0)&& (temp<a[j])){
a[j+1]=a[j];
j--; // 顺序比较和移动,依次将元素后移动一个位置
}
a[j+1]=temp;//元素后移后要插入的位置就空出了，找到该位置插入
}
}
int main(){
int array[]={2, 10, 4, 5, 1, 9};
int i=0;
insert_sort(array,6);
for(;i<=5;i++)
printf("[%d]",array[i]);
return 0;
}
4、希尔排序（Shell Sort）
希尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行插入排序。
希尔排序最后一趟已经基本有序，比较次数和移动次数更少。
4.1 算法描述
排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。
4.2 图片演示
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。
图中有10个数，所以第一趟增量就设为10/2=5；看图中第一趟排序，颜色相同为一组，每组进行比较，可以看到，这十个数被分成了五组 [9,4] [1,8] [2,6] [5,3] [7,5], 然后对这五组分别进行直接插入排序
第二趟继续进行，缩小增量为5/2=2；这时候可以看到这些数被分成了两组[4,2,5,8,5] [1,3,9,6,7]，继续分别对这两组进行直接插入排序。
第三趟 缩小增量为 2/2=1；这时候，只需要对这些数字进行微调就可以满足要求。
4.3 代码实现
/**
* 希尔排序：C++
*
* @author skywang
* @date 2014/03/11
*/
#include <iostream>
using namespace std;
/*
* 希尔排序
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void shellSort1(int* a, int n)
{
int i,j,gap;
// gap为步长，每次减为原来的一半。
for (gap = n / 2; gap > 0; gap /= 2)
{
// 共gap个组，对每一组都执行直接插入排序
for (i = 0 ;i < gap; i++)
{
for (j = i + gap; j < n; j += gap)
{
// 如果a[j] < a[j-gap]，则寻找a[j]位置，并将后面数据的位置都后移。
if (a[j] < a[j - gap])
{
int tmp = a[j];
int k = j - gap;
while (k >= 0 && a[k] > tmp)
{
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = tmp;
}
}
}
}
}
/*
* 对希尔排序中的单个组进行排序
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组总的长度
* i -- 组的起始位置
* gap -- 组的步长
*
* 组是"从i开始，将相隔gap长度的数都取出"所组成的！
*/
void groupSort(int* a, int n, int i,int gap)
{
int j;
for (j = i + gap; j < n; j += gap)
{
// 如果a[j] < a[j-gap]，则寻找a[j]位置，并将后面数据的位置都后移。
if (a[j] < a[j - gap])
{
int tmp = a[j];
int k = j - gap;
while (k >= 0 && a[k] > tmp)
{
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = tmp;
}
}
}
/*
* 希尔排序
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void shellSort2(int* a, int n)
{
int i,gap;
// gap为步长，每次减为原来的一半。
for (gap = n / 2; gap > 0; gap /= 2)
{
// 共gap个组，对每一组都执行直接插入排序
for (i = 0 ;i < gap; i++)
groupSort(a, n, i, gap);
}
}
int main()
{
int i;
int a[] = {80,30,60,40,20,10,50,70};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
shellSort1(a, ilen); //直接把插入排序写进去
//shellSort2(a, ilen); //把插入排序拎出来方便理解
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
5、选择排序（Selection Sort）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 （交换）
5.1 算法描述
选择排序是蛮力法在排序算法中的一个重要运用，选择排序开始的时候，我们扫描整个列表，找到它的最小元素然后和第一个元素交换，将最小元素放到它在有序表的最终位置上。然后我们从第二个元素开始扫描列表，找到最后n-1个元素的最小元素，再和第二个元素交换位置，把第二小的元素放在它最终的位置上。如此循环下去，在n-1遍以后，列表就排好序了。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1..n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
5.2 图片演示
排序流程
第1趟：i=0。找出a[1...5]中的最小值a[3]=10，然后将a[0]和a[3]互换。 数列变化：20,40,30,10,60,50 -- > 10,40,30,20,60,50
第2趟：i=1。找出a[2...5]中的最小值a[3]=20，然后将a[1]和a[3]互换。 数列变化：10,40,30,20,60,50 -- > 10,20,30,40,60,50
第3趟：i=2。找出a[3...5]中的最小值，由于该最小值大于a[2]，该趟不做任何处理。
第4趟：i=3。找出a[4...5]中的最小值，由于该最小值大于a[3]，该趟不做任何处理。
第5趟：i=4。交换a[4]和a[5]的数据。 数列变化：10,20,30,40,60,50 -- > 10,20,30,40,50,60
5.3 代码实现
#include <iostream>
using namespace std;
/*
* 选择排序
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void selectSort(int* a, int n)
{
int i; // 有序区的末尾位置
int j; // 无序区的起始位置
int min; // 无序区中最小元素位置
for(i=0; i<n; i++)
{
min=i;
// 找出"a[i+1] ... a[n]"之间的最小元素，并赋值给min。
for(j=i+1; j<n; j++)
{
if(a[j] < a[min])
min=j;
}
// 若min!=i，则交换 a[i] 和 a[min]。
// 交换之后，保证了a[0] ... a[i] 之间的元素是有序的。
// ice：其实还是无序的，可以把if(min != i)去掉，直接写函数体里的交换代码就可以。
if(min != i)
{
int tmp = a[i];
a[i] = a[min];
a[min] = tmp;
}
}
}
int main()
{
int i;
int a[] = {20,40,30,10,60,50};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
selectSort(a, ilen);
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
6、堆排序（Heap Sort）
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
升序->大顶堆
降序->小顶堆
参考：https://www.cnblogs.com/lanhaicode/p/10546257.html
6.1 算法描述
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
6.2 图片演示
6.3 举例说明
给定一个列表array=[16,7,3,20,17,8]，对其进行堆排序。
首先根据该数组元素构建一个完全二叉树，得到
然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：
第一步: 初始化大顶堆(从最后一个子节点开始往上调整最大堆) 由下往上
20和16交换后导致16不满足堆的性质，因此需重新调整
第二步: 堆顶元素R[1]与最后一个元素R[n]交换，交换后堆长度减一
即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了。
第三步: 重新调整堆。此时3位于堆顶不满堆的性质，则需调整继续调整(从顶点开始往下调整) 由上往下
重复上面的步骤:
请特别特别注意:
初始化大顶堆时 是从最后一个非叶子节点开始从下往上调整最大堆。
而堆顶元素(最大数)与堆最后一个数交换后，需再次调整成大顶堆，此时是从上往下调整的。
不管是初始大顶堆的从下往上调整，还是堆顶堆尾元素交换，每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换，交换之后都可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整。
堆排序时间复杂度
堆排序的时间复杂度是O(N*lgN)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？
堆排序是采用的二叉堆进行排序的，二叉堆就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是lg(N+1)。最多是多少呢？由于二叉堆是完全二叉树，因此，它的深度最多也不会超过lg(2N)。因此，遍历一趟的时间复杂度是O(N)，而遍历次数介于lg(N+1)和lg(2N)之间；因此得出它的时间复杂度是O(N*lgN)。
堆排序稳定性
堆排序是不稳定的算法，它不满足稳定算法的定义。它在交换数据的时候，是比较父结点和子节点之间的数据，所以，即便是存在两个数值相等的兄弟节点，它们的相对顺序在排序也可能发生变化。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
6.4 代码实现
/**
* 堆排序：C++
*
* @author skywang
* @date 2014/03/11
*/
#include <iostream>
using namespace std;
/*
* (最大)堆的向下调整算法
*
* 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
* 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
*
* 参数说明：
* a -- 待排序的数组
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end -- 截至范围(一般为数组中最后一个元素的索引)
*/
void maxHeapDown(int* a, int start, int end)
{
int c = start; // 当前(current)节点的位置
int l = 2*c + 1; // 左(left)孩子的位置
int tmp = a[c]; // 当前(current)节点的大小
for (; l <= end; c=l,l=2*l+1)
{
// "l"是左孩子，"l+1"是右孩子
if ( l < end && a[l] < a[l+1])
l++; // 左右两孩子中选择较大者，即m_heap[l+1]
if (tmp >= a[l])
break; // 调整结束
else // 交换值
{
a[c] = a[l];
a[l]= tmp;
}
}
}
/*
* 堆排序(从小到大)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void heapSortAsc(int* a, int n)
{
int i,tmp;
// 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。
for (i = n / 2 - 1; i >= 0; i--)
maxHeapDown(a, i, n-1);
// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = n - 1; i > 0; i--)
{
// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的。
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆。
// 即，保证a[i-1]是a[0...i-1]中的最大值。
maxHeapDown(a, 0, i-1);
}
}
/*
* (最小)堆的向下调整算法
*
* 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
* 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
*
* 参数说明：
* a -- 待排序的数组
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end -- 截至范围(一般为数组中最后一个元素的索引)
*/
void minHeapDown(int* a, int start, int end)
{
int c = start; // 当前(current)节点的位置
int l = 2*c + 1; // 左(left)孩子的位置
int tmp = a[c]; // 当前(current)节点的大小
for (; l <= end; c=l,l=2*l+1)
{
// "l"是左孩子，"l+1"是右孩子
if ( l < end && a[l] > a[l+1])
l++; // 左右两孩子中选择较小者
if (tmp <= a[l])
break; // 调整结束
else // 交换值
{
a[c] = a[l];
a[l]= tmp;
}
}
}
/*
* 堆排序(从大到小)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void heapSortDesc(int* a, int n)
{
int i,tmp;
// 从(n/2-1) --> 0逐次遍历每。遍历之后，得到的数组实际上是一个最小堆。
for (i = n / 2 - 1; i >= 0; i--)
minHeapDown(a, i, n-1);
// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = n - 1; i > 0; i--)
{
// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最小的。
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最小堆。
// 即，保证a[i-1]是a[0...i-1]中的最小值。
minHeapDown(a, 0, i-1);
}
}
int main()
{
int i;
int a[] = {20,30,90,40,70,110,60,10,100,50,80};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
heapSortAsc(a, ilen); // 升序排列
//heapSortDesc(a, ilen); // 降序排列
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
7、归并排序（Merge Sort）
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
7.1 算法描述
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
7.2 图片演示
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
分而治之
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。
合并相邻有序子序列
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
7.3 代码实现
/**
* 归并排序：C++
*
* @author skywang
* @date 2014/03/12
*/
#include <iostream>
using namespace std;
/*
* 将一个数组中的两个相邻有序区间合并成一个
*
* 参数说明：
* a -- 包含两个有序区间的数组
* start -- 第1个有序区间的起始地址。
* mid -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
* end -- 第2个有序区间的结束地址。
*/
void merge(int* a, int start, int mid, int end)
{
int *tmp = new int[end-start+1]; // tmp是汇总2个有序区的临时区域
int i = start; // 第1个有序区的索引
int j = mid + 1; // 第2个有序区的索引
int k = 0; // 临时区域的索引
while(i <= mid && j <= end)
{
if (a[i] <= a[j])
tmp[k++] = a[i++];
else
tmp[k++] = a[j++];
}
while(i <= mid)
tmp[k++] = a[i++];
while(j <= end)
tmp[k++] = a[j++];
// 将排序后的元素，全部都整合到数组a中。
for (i = 0; i < k; i++)
a[start + i] = tmp[i];
delete[] tmp;
}
/*
* 归并排序(从上往下)
*
* 参数说明：
* a -- 待排序的数组
* start -- 数组的起始地址
* endi -- 数组的结束地址
*/
void mergeSortUp2Down(int* a, int start, int end)
{
if(a==NULL || start >= end)
return ;
int mid = (end + start)/2;
mergeSortUp2Down(a, start, mid); // 递归排序a[start...mid]
mergeSortUp2Down(a, mid+1, end); // 递归排序a[mid+1...end]
// a[start...mid] 和 a[mid...end]是两个有序空间，
// 将它们排序成一个有序空间a[start...end]
merge(a, start, mid, end);
}
/*
* 对数组a做若干次合并：数组a的总长度为len，将它分为若干个长度为gap的子数组；
* 将"每2个相邻的子数组" 进行合并排序。
*
* 参数说明：
* a -- 待排序的数组
* len -- 数组的长度
* gap -- 子数组的长度
*/
void mergeGroups(int* a, int len, int gap)
{
int i;
int twolen = 2 * gap; // 两个相邻的子数组的长度
// 将"每2个相邻的子数组" 进行合并排序。
for(i = 0; i+2*gap-1 < len; i+=(2*gap))
{
merge(a, i, i+gap-1, i+2*gap-1);
}
// 若 i+gap-1 < len-1，则剩余一个子数组没有配对。
// 将该子数组合并到已排序的数组中。
if ( i+gap-1 < len-1)
{
merge(a, i, i + gap - 1, len - 1);
}
}
/*
* 归并排序(从下往上)
*
* 参数说明：
* a -- 待排序的数组
* len -- 数组的长度
*/
void mergeSortDown2Up(int* a, int len)
{
int n;
if (a==NULL || len<=0)
return ;
for(n = 1; n < len; n*=2)
mergeGroups(a, len, n);
}
int main()
{
int i;
int a[] = {80,30,60,40,20,10,50,70};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
# 我们以上图片展示的就是从上往下的思路， 从下往上的先不要看了...
mergeSortUp2Down(a, 0, ilen-1); // 归并排序(从上往下)
//mergeSortDown2Up(a, ilen); // 归并排序(从下往上)
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
8、计数排序（Counting Sort）
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
8.1 算法描述
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
8.2 图片演示
8.3 举例说明
- 假设有 8 个考生，他们的分数范围为 [0, 5]。这 8 个考生的成绩我们放在一个数组中，A[8] = {2, 5, 3, 0, 2, 3, 0, 3}。
- 我们用大小为 6 的数组代表 6 个桶来统计考生的成绩分布情况，其中下标表示考生的分数，数组内的值表示这个分数的考生个数。我们遍历一遍数组后，就可以得到 C[6] = {2, 0, 2, 3, 0, 1,}，得 0 分的共有 2 人，得 3 分的共有 3 人。
- 如下所示，成绩为 3 的考生共有 3 个，小于 3 分的考生共有 4 个，所以在排好序的数据 R[8] 中，3 的位置应该为 4，5 和 6 。
- 而我们怎么得到这个位置呢？只需要对 C[6] 数组按顺序累计求和即可，这时候，C[6] 数组中的每个值就都表示小于等于它的值的个数了。
- 接下来，我们从后到前依次扫描数组 A[8]。当扫描到 3 时，我们取出 C[3] 的值 7，说明小于等于 3 的个数为 7 个，那么 3 就应该放在数组 R[8] 的第 7 个位置，也就是下标为 6 的地方，然后把 C[3] 相应地减去 1。当我们再次遇到 3 的时候，这时候小于等于 3 的元素个数就少了一个。
- 之所以要从后到前依次扫描数组，是因为这样之前相同的元素就仍然会保持相同的顺序，可以保证排序算法的稳定性。
- 当我们扫描完整个数组 A[8] 时，数组 R[8] 中的数据也就从小到大排好序了，其详细过程可参考下图。
8.4 代码实现
注意：以下代码只是找了最大值出来作为作为临时计数数组的长度。实际中为了避免空间浪费，可以用max-min+1的长度来作为数组长度，当然下标也要相应改变。
另外，
- 计数排序只适用于数据范围不大的场景中，如果数据范围比排序的数据大很多，就不适合用计数排序了。
- 计数排序能给非负整数排序，如果数据是其他类型的，需要将其在不改变相对大小的情况下，转化为非负整数。比如数据有一位小数，我们需要将数据都乘以 10；数据范围为 [-1000, 1000]，我们需要对每个数据加 1000。
#include <iostream>
using namespace std;
// 假设数组中存储的都是非负整数
void Counting_Sort(int data[], int n)
{
if (n <= 1)
{
return;
}
// 寻找数组的最大值
int max = data[0];
for (int i = 1; i < n; i++)
{
if (data[i] > max)
{
max = data[i];
}
}
// 定义一个计数数组, 统计每个元素的个数
int c[max+1] = {0};
for (int i = 0; i < n; i++)
{
c[data[i]]++;
}
// 对计数数组累计求和
for (int i = 1; i <= max; i++)
{
c[i] = c[i] + c[i-1];
}
// 临时存放排好序的数据
int r[n] = {0};
// 倒序遍历数组，将元素放入正确的位置
for (int i = n-1; i >= 0; i--)
{
r[c[data[i]] - 1] = data[i];
c[data[i]]--;
}
for (int i = 0; i < n; i++)
{
data[i] = r[i];
}
}
int main()
{
int i;
int a[] = {3,4,1,2,2,3,5,5,6,7};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
Counting_Sort(a, ilen);
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
9、桶排序（Bucket Sort）
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。
9.1 算法描述
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序；
- 从不是空的桶里把排好序的数据拼接起来。
第三步，对不是空的桶进行排序：可以给每个桶做个标记，有数据的置1，没数据的置0，遍历每个桶，只对有数据的（标记为1）的做排序。这个排序就直接用桶排序吧（相当于每个桶1个数据）...
9.2 举例说明
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。
1. 什么时候最快
当输入的数据可以均匀的分配到每一个桶中。
2. 什么时候最慢
当输入的数据被分配到了同一个桶中。
3. 示意图
元素分布在桶中：
然后，元素在每个桶中排序：
如图：我们要对29，25，3，49，9，37，21，43进行从小到打的排序，根据桶排序的定义，我们要把数组分成大小相等的几个桶，图中分为5个桶，每个桶的长度均为0~9。然后我们把数组里面的数分配到这5个桶里面，然后这样我们就把数据分成了5份，然后每个桶在进行排序(可以冒泡、桶等排序)，最后把桶的数据拼一起就出来了最后的结果。
4.代码demo
def bucketSort(arr):
maximum, minimum = max(arr), min(arr)
bucketArr = [[] for i in range(maximum // 10 - minimum // 10 + 1)] # set the map rule and apply for space
for i in arr: # map every element in array to the corresponding bucket
index = i // 10 - minimum // 10
bucketArr[index].append(i)
arr.clear()
for i in bucketArr:
heapSort(i) # sort the elements in every bucket
arr.extend(i) # move the sorted elements in bucket to array
第一个循环作用为将待排序集合中元素移动到对应的桶中，复杂度为 $O(N)$；第二个循环的作用为对每个桶中元素进行排序，并移动回初始集合中，若桶个数为 $M$，平均每个桶中元素个数为 $\frac NM$，则复杂度为 $O(M*\frac NMlog_2{\frac NM}+N)=O(N+N(log_2N-log_2M))$。当 $M==N$ 时，即桶排序向计数排序方式演化，则堆排序不发挥作用，复杂度为 $O(N)$，只需要将元素移动回初始集合即可。当 $M==1$ 时，即桶排序向比较性质排序算法演化，对集合进行堆排序，并将元素移动回初始集合，复杂度为 $O(N+Nlog_2N)$。
5.算法分析
由算法过程可知，桶排序的时间复杂度为 $O(N+N(log_2N-log_2M))$，其中 $M$ 表示桶的个数。由于需要申请额外的空间来保存元素，并申请额外的数组来存储每个桶，所以空间复杂度为 $O(N+M)$。算法的稳定性取决于对桶中元素排序时选择的排序算法。由桶排序的过程可知，当待排序集合中存在元素值相差较大时，对映射规则的选择是一个挑战，可能导致元素集中分布在某一个桶中或者绝大多数桶是空桶的现象，对算法的时间复杂度或空间复杂度有较大影响，所以同计数排序一样，桶排序适用于元素值分布较为集中的序列。
9.3 代码实现
上面实现的Python版是比较复杂的桶排序。
简单的直接就是一个数据值一个桶，类似于计数排序。
举个例子：
期末考试完了老师要将同学们的分数按照从高到低排序。小哼的班上只有5个同学，这5个同学分别考了5分、3分、5分、2分和8分，哎考的真是惨不忍睹（满分是10分）。接下来将分数进行从大到小排序，排序后是8 5 5 3 2。
这个题里最小分数是0，最大分数是10。所以需要申请一个大小为11的数组。
首先我们需要申请一个大小为11的数组int a[11]。OK现在你已经有了11个变量，编号从a[0]~a[10]。刚开始的时候，我们将a[0]~a[10]都初始化为0，表示这些分数还都没有人得过。例如a[0]等于0就表示目前还没有人得过0分，同理a[1]等于0就表示目前还没有人得过1分……a[10]等于0就表示目前还没有人得过10分。
a[0]~a[10]中的数值其实就是0分到10分每个分数出现的次数。接下来，我们只需要将出现过的分数打印出来就可以了，出现几次就打印几次，具体如下。
a[0]为0，表示“0”没有出现过，不打印。
a[1]为0，表示“1”没有出现过，不打印。
a[2]为1，表示“2”出现过1次，打印2。
a[3]为1，表示“3”出现过1次，打印3。
a[4]为0，表示“4”没有出现过，不打印。
a[5]为2，表示“5”出现过2次，打印5 5。
a[6]为0，表示“6”没有出现过，不打印。
a[7]为0，表示“7”没有出现过，不打印。
a[8]为1，表示“8”出现过1次，打印8。
a[9]为0，表示“9”没有出现过，不打印。
a[10]为0，表示“10”没有出现过，不打印。
最终屏幕输出“2 3 5 5 8”，完整的代码如下：
#include <stdio.h>
int main()
{
int a[11],i,j,t;
for(i=0;i<=10;i++)
a[i]=0; //初始化为0
for(i=1;i<=5;i++) //循环读入5个数
{
scanf("%d",&t); //把每一个数读到变量t中
a[t]++; //进行计数
}
for(i=0;i<=10;i++) //依次判断a[0]~a[10]
for(j=1;j<=a[i];j++) //出现了几次就打印几次
printf("%d ",i);
getchar();getchar();
//这里的getchar();用来暂停程序，以便查看程序输出的内容
//也可以用system("pause");等来代替
return 0;
}
这里实现的是从小到大排序。但是我们要求是从大到小排序，这该怎么办呢？
其实很简单。只需要将for(i=0;i<=10;i++)改为for(i=10;i>=0;i--)就OK啦。
10、基数排序（Radix Sort）
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
10.1 算法描述
基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位数切割成不同的数字，然后按每个位数分别比较。
具体做法是：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
10.2 图片演示
10.3 举例说明
通过基数排序对数组{53, 3, 542, 748, 14, 214, 154, 63, 616}，它的示意图如下：
在上图中，首先将所有待比较树脂统一为统一位数长度，接着从最低位开始，依次进行排序。
1. 按照个位数进行排序。
2. 按照十位数进行排序。
3. 按照百位数进行排序。
排序后，数列就变成了一个有序序列。
10.4 代码实现
/**
* 基数排序：C++
*
* @author skywang
* @date 2014/03/15
*/
#include<iostream>
using namespace std;
/*
* 获取数组a中最大值
*
* 参数说明：
* a -- 数组
* n -- 数组长度
*/
int getMax(int a[], int n)
{
int i, max;
max = a[0];
for (i = 1; i < n; i++)
if (a[i] > max)
max = a[i];
return max;
}
/*
* 对数组按照"某个位数"进行排序(桶排序)
*
* 参数说明：
* a -- 数组
* n -- 数组长度
* exp -- 指数。对数组a按照该指数进行排序。
*
* 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
* (01) 当exp=1表示按照"个位"对数组a进行排序
* (02) 当exp=10表示按照"十位"对数组a进行排序
* (03) 当exp=100表示按照"百位"对数组a进行排序
* ...
*/
void countSort(int a[], int n, int exp)
{
int output[n]; // 存储"被排序数据"的临时数组
int i, buckets[10] = {0};
// 将数据出现的次数存储在buckets[]中
for (i = 0; i < n; i++)
buckets[ (a[i]/exp)%10 ]++;
// 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
for (i = 1; i < 10; i++)
buckets[i] += buckets[i - 1];
// 将数据存储到临时数组output[]中
for (i = n - 1; i >= 0; i--)
{
output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
buckets[ (a[i]/exp)%10 ]--;
}
// 将排序好的数据赋值给a[]
for (i = 0; i < n; i++)
a[i] = output[i];
}
/*
* 基数排序
*
* 参数说明：
* a -- 数组
* n -- 数组长度
*/
void radixSort(int a[], int n)
{
int exp; // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
int max = getMax(a, n); // 数组a中的最大值
// 从个位开始，对数组a按"指数"进行排序
for (exp = 1; max/exp > 0; exp *= 10)
countSort(a, n, exp);
}
int main()
{
int i;
int a[] = {53, 3, 542, 748, 14, 214, 154, 63, 616};
int ilen = (sizeof(a)) / (sizeof(a[0]));
cout << "before sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
radixSort(a, ilen); // 基数排序
cout << "after sort:";
for (i=0; i<ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
参考：
由于时间问题，先在网上找的一些素材整理而成，有时间会自己重新画图整理一遍。感谢互联网，感谢这些出处的大神！
https://www.cnblogs.com/onepixel/articles/7674659.html
https://www.cnblogs.com/skywang12345/p/3602162.html （这位博友的文章很有料...）