C++排序算法总结（可执行代码）
常见的分类算法还可以根据排序方式分为两大类：比较排序和非比较排序。本文中前七种算法都是比较排序，非比较排序有三种，分别为：
1）计数排序(Count Sort)（复杂度O(n+k)（其中k是待排序的n个数字中最大值）
2）基数排序(Bucket Sort)（复杂度O(nk)（其中k是最大数字的位数）
3）桶排序(Radix Sort)（复杂度O(n+k)（其中k是待排序的n个数字中最大值）
非比较排序的特点是时间复杂度很低，都是线性复杂度O(n)，但是非比较排序受到的限制比较多，不是通用的排序算法。
1. 直接插入排序（Straight Insertion Sort）
直接插入排序（Insertion Sort），是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序算法的一般步骤：
1.从第一个元素开始，该元素可以认为已被排序；
2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
3.如果该元素（已排序）大于新元素，将该元素移到下一个位置；
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5.将新元素插入到该位置后，重复2~5
#include
// 分类 ------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)
// 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)
// 平均时间复杂度 ---- O(n^2)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 稳定
void InsertionSort(int A[], int n)
{
for (int i = 1; i < n; i++) // 类似抓扑克牌排序
{
int get = A[i]; // 右手抓到一张扑克牌
int j = i - 1; // 拿在左手上的牌总是排序好的
while (j >= 0 && A[j] > get) // 将抓到的牌与手牌从右向左进行比较
{
A[j + 1] = A[j]; // 如果该手牌比抓到的牌大，就将其右移
j--;
}
A[j + 1] = get; // 直到该手牌比抓到的牌小(或二者相等)，将抓到的牌插入到该手牌右边(相等元素的相对次序未变，所以插入排序是稳定的)
}
}
int main()
{
int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 };// 从小到大插入排序
int n = sizeof(A) / sizeof(int);
InsertionSort(A, n);
printf("插入排序结果：");
for (int i = 0; i < n; i++)
{
printf("%d ", A[i]);
}
printf("\n");
return 0;
} 2. 希尔排序（Shells Sort）
public class ShellSort {
/**
* 希尔排序的一趟插入
* @param arr 待排数组
* @param d 增量
*/
public static void shellInsert(int[] arr, int d) {
for(int i=d; i=0 && arr[j]>temp) { //从后向前，找到比其小的数的位置
arr[j+d] = arr[j]; //向后挪动
j -= d;
}
if (j != i - d) //存在比其小的数
arr[j+d] = temp;
}
}
public static void shellSort(int[] arr) {
if(arr == null || arr.length == 0)
return ;
int d = arr.length / 2;
while(d >= 1) {
shellInsert(arr, d);
d /= 2;
}
}
} 3. 直接选择排序（Straight Selection Sort）
工作原理：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
稳定性：
选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。
时间复杂度：
比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。
交换次数O(n），最好情况是，已经有序，交换0次；最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1），逆序交换n/2次。
空间复杂度：
O(1)。简单选择排序需要占用一个临时空间，在交换数值时使用。
比较：
与插入排序比较：直接选择排序和直接插入排序类似，都将数据分为有序区和无序区，所不同的是直接播放排序是将无序区的第一个元素直接插入到有序区以形成一个更大的有序区，而直接选择排序是从无序区选一个最小的元素直接放到有序区的最后。选择排序是固定位置，找元素。相比于插入排序的固定元素找位置，是两种思维方式。
与冒泡排序比较：冒泡算法最费时的一是两两比较，二是两两交换，选择排序中交换次数比冒泡排序少多了，n值较小时，选择排序比冒泡排序快。
示例
4. 堆排序（Heap Sort）
堆的插入
每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中——这就类似于直接插入排序中将一个数据并入到有序区间中，不难写出插入一个新数据时堆的调整代码：
// 新加入i结点 其父结点为(i - 1) / 2
void MinHeapFixup(int a[], int i)
{
int j, temp;
temp = a[i];
j = (i - 1) / 2; //父结点
while (j >= 0 && i != 0) //父节点以及插入节点限制
{
if (a[j] <= temp)
break;
a[i] = a[j]; //把较大的子结点往下移动,替换它的子结点
i = j; //依次向上调整
j = (i - 1) / 2;
}
a[i] = temp;
} 更简短的表达为：
void MinHeapFixup(int a[], int i)
{
for (int j = (i - 1) / 2; (j >= 0 && i != 0)&& a[i] > a[j]; i = j, j = (i - 1) / 2)
Swap(a[i], a[j]);
}
插入时：
//在最小堆中加入新的数据nNum n为最后的插入位置
void MinHeapAddNumber(int a[], int n, int nNum)
{
a[n] = nNum;
MinHeapFixup(a, n);
} 堆的删除
按定义，堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。下面给出代码：
// 从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2
void MinHeapFixdown(int a[], int i, int n)
{
int j, temp;
temp = a[i];
j = 2 * i + 1;
while (j < n)
{
if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的
j++;
if (a[j] >= temp)
break;
a[i] = a[j]; //把较小的子结点往上移动,替换它的父结点
i = j;
j = 2 * i + 1;
}
a[i] = temp;
}
//在最小堆中删除数
void MinHeapDeleteNumber(int a[], int n)
{
Swap(a[0], a[n - 1]);
MinHeapFixdown(a, 0, n - 1);
} 堆化数组
有了堆的插入和删除后，再考虑下如何对一个数据进行堆化操作。要一个一个的从数组中取出数据来建立堆吧，不用！先看一个数组，如下图：
很明显，对叶子结点来说，可以认为它已经是一个合法的堆了即20，60， 65， 4， 49都分别是一个合法的堆。只要从A[4]=50开始向下调整就可以了。然后再取A[3]=30，A[2] = 17，A[1] = 12，A[0] = 9分别作一次向下调整操作就可以了。下图展示了这些步骤：
写出堆化数组的代码：
//建立最小堆
void MakeMinHeap(int a[], int n)
{
for (int i = n / 2 - 1; i >= 0; i--)
MinHeapFixdown(a, i, n);
}
至此，堆的操作就全部完成了(注1)，再来看下如何用堆这种数据结构来进行排序。
堆排序
首先可以看到堆建好之后堆中第0个数据是堆中最小的数据。取出这个数据再执行下堆的删除操作。这样堆中第0个数据又是堆中最小的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据。
由于堆也是用数组模拟的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。有点类似于直接选择排序。
void MinheapsortTodescendarray(int a[], int n)
{
for (int i = n - 1; i >= 1; i--)
{
Swap(a[i], a[0]);
MinHeapFixdown(a, 0, i);
}
} 注意使用最小堆排序后是递减数组，要得到递增数组，可以使用最大堆。
由于每次重新恢复堆的时间复杂度为O(logN)，共N - 1次重新恢复堆操作，再加上前面建立堆时N / 2次向下调整，每次调整时间复杂度也为O(logN)。二次操作时间相加还是O(N * logN)。故堆排序的时间复杂度为O(N * logN)。几句堆排序的强大之处，堆排序可以看成是一种算法，也可以看成是一种数据结构。它可以分为小顶堆和大顶堆。与堆这种数据结构联系紧密的一种典型问题就是我们经常遇到的top-K问题。
我们先看一个大数据top-K示例：
例子：搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计最热门的10个查询串，要求使用的内存不能超过1G。
首先，我们知道这是一个典型的top-K问题。
针对大数据问题进行统计首先应该想到的就是Hash_map。所以第一步就是先遍历全部的1千万Query，构建出一个大小为3百万的Hash_map，其中的key值为某条Query，对应的value值为该条Query的查询次数。
建好Hash_map以后，我们接下来的问题就是如何在3百万的Query中找出10个最热门的Query，也就是要用到排序算法。排序算法中效率最高的时间复杂度为O(n*log(n))，这是最简单粗暴的方法，也是最直接的方法。或者我们进一步优化，该题目是要求寻找top-K问题，那么我们可以直接去前K个Query构建一个数组，然后对其进行排序。遍历剩余的全部Query，如果某条Query的查询次数大于数组中最小的一个，将数组中最小的Query剔除，加入这条新的Query。接着调整数组顺序，依次进行遍历，这样的最坏情况下的复杂度为O(n*K)。
但是还可以继续优化寻找top-K的操作，那就是借助小根堆来实现。基于以上的分析，我们想想，有没有一种既能快速查找，又能快速移动元素的数据结构呢？回答是肯定的，那就是堆。
具体过程是，堆顶存放的是整个堆中最小的数，现在遍历N个数，把最先遍历到的k个数存放到最小堆中，并假设它们就是我们要找的最大的k个数，X1>X2...Xmin(堆顶)，而后遍历后续的(n-K)个数，一一与堆顶元素进行比较，如果遍历到的Xi大于堆顶元素Xmin，则把Xi放入堆中，而后更新整个堆，更新的时间复杂度为logK，如果Xi
一个有关小根堆解决top-K问题的小动画，请点击这个链接。
思想与上述算法二一致，只是算法在算法三，我们采用了最小堆这种数据结构代替数组，把查找目标元素的时间复杂度有O(K)降到了O(logK)。那么这样，采用堆数据结构，算法三，最终的时间复杂度就降到了O(n*logK)，和算法二相比，又有了比较大的改进。
5. 冒泡排序（Bubble Sort）
基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。每一趟排序后的效果都是讲没有沉下去的元素给沉下去。
算法流程：
1）比较相邻的两个元素，如果前面的数据大于后面的数据，就将两个数据进行交换；这样对数组第0个元素到第n-1个元素进行一次遍历后，最大的一个元素就沉到数组的第n-1个位置；
2）重复第2）操作，直到i=n-1。
时间复杂度分析：O(n^2)，冒泡排序是一种不稳定排序算法。
冒泡排序的示例：
//冒泡排序
void BubbleSort(int a[], int n)
{
int i, j;
for(i=0; i6. 快速排序（Quick Sort）
基本思想：快速排序算法的基本思想为分治思想。
1）先从数列中取出一个数作为基准数；
2）根据基准数将数列进行分区，小于基准数的放左边，大于基准数的放右边；
3）重复分区操作，知道各区间只有一个数为止。
算法流程：（递归+挖坑填数）
1）i=L，j=R，将基准数挖出形成第一个坑a[i]；
2）j--由后向前找出比它小的数，找到后挖出此数a[j]填到前一个坑a[i]中；
3）i++从前向后找出比它大的数，找到后也挖出此数填到前一个坑a[j]中；
4）再重复2,3），直到i=j，将基准数填到a[i]。
时间复杂度：O(nlog(n))，但若初始数列基本有序时，快排序反而退化为冒泡排序。
快速排序的示例：
（a）一趟排序的过程：
（b）排序的全过程
void quickaont(int a[], int l, int n)
{
//l代表基准数的位置 n代表数组的长度
if (l= x) // 从右向左找第一个小于x的数
j--;
if (i < j)
a[i++] = a[j];
while (i < j && a[i]< x) // 从左向右找第一个大于等于x的数
i++;
if (i < j)
a[j] = a[i];
}
a[i] = x;
quickaont(a, l, i - 1); // 递归调用
quickaont(a, i + 1, n);
}
} 7. 归并排序（Merge Sort）
基本思想：
归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
归并排序示例：
合并方法：
设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。
- j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
- 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
- //选取r[i]和r[j]较小的存入辅助数组rf
如果r[i] - //将尚未处理完的子表中元素存入rf
如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空 - 合并结束。
-
/将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) { int j,k; for(j=m+1,k=i; i<=m && j <=n ; ++k){ if(r[j] < r[i]) rf[k] = r[j++]; else rf[k] = r[i++]; } while(i <= m) rf[k++] = r[i++]; while(j <= n) rf[k++] = r[j++]; }
归并的迭代算法
1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。
void print(int a[], int n){
for(int j= 0; j两路归并的递归算法
void MSort(ElemType *r, ElemType *rf,int s, int t)
{
ElemType *rf2;
if(s==t) r[s] = rf[s];
else
{
int m=(s+t)/2; /*平分*p 表*/
MSort(r, rf2, s, m); /*递归地将p[s…m]归并为有序的p2[s…m]*/
MSort(r, rf2, m+1, t); /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/
Merge(rf2, rf, s, m+1,t); /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/
}
}
void MergeSort_recursive(ElemType *r, ElemType *rf, int n)
{ /*对顺序表*p 作归并排序*/
MSort(r, rf,0, n-1);
}