排序算法(直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数类排序)
目录
一、概述
二、算法复杂度
三、插入类排序
1.直接插入排序
2.折半插入排序
3.希尔排序
四、交换类排序
1.冒泡排序
2.快速排序
五、选择类排序
1.简单选择排序
2.堆排序
六、归并排序
1.二路归并排序
七、基数排序
1.基数排序
一、概述
所谓排序，即将原本无序的序列重新排列成有序序列的过程。
二、算法复杂度
| 分类 | 排序方法 | 时间复杂度（最坏） | 时间复杂度（最好） | 时间复杂度（平均） | 空间复杂度 | 稳定性 |
| 插入类排序 | 直接插入排序 | O( ) |
O(n) | O() |
O(1) | 稳定 |
| 折半插入排序 | O() |
O( ) |
O() |
O(1) | 稳定 | |
| 希尔排序 | O() |
O( ) |
O() |
O(1) | 不稳定 | |
| 交换类排序 | 冒泡排序 | O() |
O(n) | O() |
O(1) | 稳定 |
| 快速排序 | O() |
O() |
O() |
O( ) |
不稳定 | |
| 选择类排序 | 简单选择排序 | O() |
O() |
O() |
O(1) | 不稳定 |
| 堆排序 | O() |
O() |
O() |
O(1) | 不稳定 | |
| 归并类排序 | 二路归并排序 | O() |
O() |
O() |
O(n) | 稳定 |
| 基数类排序 | 基数排序 | O(d(n+ )) |
O(d(n+)) |
O() |
稳定 |
复杂度总结：
(1)时间复杂度：平均情况下，“快些以
速度归队”，其中“快”指快速排序，“些”指希尔排序，“归”指归并排序，“队”指堆排序，这四种排序的平均时间复杂度为O()，其他都是O()。
(2)空间复杂度：快速排序为O()，归并排序为O(n)，基数排序为O()，其他都为O(1)。
(3)初始序列已经有序，直接插入排序时间复杂度为O(n)，冒泡排序时间复杂度为O(n)。
算法稳定性总结：
一句话记忆，“记忆排序算法复杂度很容易遗忘，记的不稳定，快些选一堆容易记忆的把”，“快”指快速排序，“些”指希尔排序，“选”指简单选择排序，“堆”指堆排序。除这4种以外，其他都是稳定的。
排序原理总结：
(1)经过一趟排序，保证一个关键字到达最终位置的排序算法为交换类排序（冒泡排序、快速排序），选择类排序（简单选择排序、堆排序）。
(2)关键字比较次数和原始序列无关的算法——简单选择排序和折半插入排序。
(3)排序趟数和原始序列无关的算法——交换类排序。
注：
- 稳定：当a与b相等时，如果a原本在b前面，排序之后a仍然在b的前面。
- 不稳定：当a与b相等时，如果a原本在b的前面，排序之后 a 可能会出现在 b 的后面。
- 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
- 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
三、插入类排序
1.直接插入排序
(1)基本思想
将待插入元素依次跟前面已经排好的元素相比较，如果选择的待插入元素比已排序的元素小，则已排序元素后移，待插入元素继续与前一个元素比较，直到找到合适插入位置插入。
使用直接插入排序方法为一列数字进行排序过程
(2)算法描述
具体算法描述如下：
①从第一个元素开始，该元素可以认为已经被排好序；
②取出下一个元素，在已经排好序的元素序列中从后向前扫描；
③如果该元素（已排好序中元素）大于新元素(待插入元素)，则将该元素移到下一位置；
④重复步骤③，直到找到已排好序的元素小于或者等于新元素的位置；
⑤将新元素插入到该位置；
⑥重复步骤②~⑤。
直接插入排序演示
(3)代码实现
//直接插入排序——C语言实现
//本算法中使用了监视哨，主要是为了避免数据在后移时丢失。
#include
int insort(int s[], int n) /* 自定义函数 insort()*/
{
int i,j;
for(i=2;i<=n;i++) //数组下标从2开始，s[0]做监视哨，s[1]一个数据无可比性
{
s[0]=s[i]; //给监视哨陚值
j=i-1; //确定要比较元素的最右边位黄
while(s[0] 运行结果：
请输入10个数据：
25 12 36 45 2 9 39 22 98 37
原始顺序：
25 12 36 45 2 9 39 22 98 37
插入数据排序后顺序：
2 9 12 22 25 36 37 39 45 982.折半插入排序
(1)基本思想
折半插入排序的基本思想和直接插入排序类似，区别是查找插入位置的方法不同，折半插入排序是采用折半查找法来查找插入位置的。
(2)算法描述
举一趟排序为例：
现在序列为13 38 49 65 76 97 27 49
将要插入27，此时序列在数组中的情况为：
| 已经排序 | 未排序 | |||||||
| 关键字 | 13 | 38 | 49 | 65 | 76 | 97 | 27 | 49 |
| 数组下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
①low = 0，high = 5，m = (0+5)/2 = 2(向下取整)，下标为2的关键字为49,27 < 49，所以27应该插入到49的低半区，改变high = m-1=1，low仍然为0。
②low = 0，high = 1，m = (0+1)/2 = 0(向下取整)，下标为0的关键字为13,27 > 13，所以27应该插入到13的高半区，改变low = m+1=1，high仍然为1。
③low = 1，high = 1，m = (1+1)/2 = 1(向下取整)，下标为1的关键字为38,27 < 38，所以27应该插入到38的低半区，改变high = m-1=0，low仍然为1。此时low > high，折半查找结束，27的插入位置为下标为high的关键字之后，即13之后。
④依次向后移动关键字97,76,65,49,38，然后将27插入，这一趟折半插入排序结束。执行完这一趟排序结果为：
13 27 38 49 65 76 97 49
(3)代码实现
//折半插入排序算——C语言实现
#include
void print(int a[], int n ,int i){
printf("%d:",i);
for(int j=0; jtemp) {
high=mid-1;
}else{
low=mid+1;
}
}
//有序表中插入位置后的元素统一后移
for (j=i; j>low; j--) {
a[j]=a[j-1];
}
a[low]=temp;//插入元素
print(a, 8, i);
}
}
int main(){
int a[8] = {3,1,7,5,2,4,9,6};
BInsertSort(a, 8);
return 0;
} 运行结果：
1:13752496
2:13752496
3:13572496
4:12357496
5:12345796
6:12345796
7:123456793.希尔排序
(1)基本思想
希尔排序演示
希尔排序又叫缩小增量排序，其本质还是插入排序，只不过将待排序列按某种规则分为几个子序列，分别对这几个子序列进行直接插入排序。这个规则的体现就是增量的选取，将待排序数组按照增量进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次再将增量折半减小，循环上述操作；当增量等于1时，利用直接插入，完成排序。
可以看到增量的选择是希尔排序的重要部分。只要最终增量为1任何步长序列都可以工作。一般来说最简单的增量取值是初次取数组长度的一半为增量，之后每次再减半，直到增量为1。
(2)算法描述
具体算法描述如下：
①选择一个增量序列t1，t2，…ti，tj，...tk，其中ti>tj，tk=1；（一般初次取数组半长，之后每次再减半，直到增量为1）
②按增量序列个数k，对序列进行k 趟排序；
③每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子序列进行直接插入排序。仅当增量为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
(3)代码实现
//希尔排序——C语言实现
//自定义函数 shsort()，实现希尔排序。
#include
int shsort(int s[], int n) /* 自定义函数 shsort()*/
{
int i,j,d;
d=n/2; /*确定固定增虽值*/
while(d>=1)
{
for(i=d+1;i<=n;i++) /*数组下标从d+1开始进行直接插入排序*/
{
s[0]=s[i]; /*设置监视哨*/
j=i-d; /*确定要进行比较的元素的最右边位置*/
while((j>0)&&(s[0] 运行结果：
请输入 10 个数据：
69 56 12 136 3 55 46 99 88 25
排序后的顺序是：
3 12 25 46 55 56 69 88 99 136四、交换类排序
1.冒泡排序
(1)基本思想
冒泡排序是通过一系列的“交换”动作完成的，首先第一个关键字和第二个关键字比较，如果第一个大，则二者交换，否则不交换；然后第二个关键字和第三个关键字比较，如果第二个大，则二者交换，否则不交换......一直按照这种方式进行下去，最终最大的那个关键字被交换到最后，一趟冒泡排序完成。经过多趟这样的排序，最终使得整个序列有序。
冒泡排序演示
(2)算法描述
具体算法描述如下：
①比较相邻的元素。如果第一个比第二个大，就交换他们两个。
②对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
③针对所有的元素重复以上的步骤，除了最后一个。
④重复上面的步骤①~③对未排序元素排序，直到在一趟排序过程中没有发生关键字交换。
(3)代码实现
//冒泡排序——C语言实现
//通过两个 for 循环实现冒泡排序的全过程，外层 for 循环决定冒泡排序的趟数，内层 for 循环决定每趟所进行两两比较的次数。
/*冒泡法的基本思路是，如果要对 n 个数进行冒泡排序，那么要进行 n-1 趟比较，在第 1 趟比较中要进行 n-1 次两两比较，在第 j 趟比较中要进行 n-j 次两两比较。从这个基本思路中就会发现，趟数决定了两两比较的次数，这样就很容易将两个 for 循环联系起来了。*/
#include
int main()
{
int i,j,t,a[11]; //定义变量及数组为基本整型
printf("请输入10个数：\n");
for(i=1;i<11;i++)
scanf("%d",&a[i]); //从键盘中输入10个数
for(i=1;i<10;i++) //变量i代表比较的趟数
for(j=1;j<11-i;j++) //变最j代表每趟两两比较的次数
if(a[j]>a[j+1])
{
t=a[j]; //产利用中间变童实现两值互换
a[j]=a[j+1];
a[j+1]=t;
}
printf("排序后的顺序是：\n");
for(i=1;i<=10;i++)
printf("%5d",a[i]); //将胃泡排序后的顺序输出
printf("\n");
return 0;
} 运行结果：
请输入10个数：
66 32 23 45 25 5 15 69 46 37
排序后的顺序是：
5 15 23 25 32 37 45 46 66 692.快速排序
(1)基本思想
快速排序的基本思想：挖坑填数+分治法。
每一趟选择当前所有子序列中的一个关键字（通常是第一个）作为枢轴，将子序列中比枢轴小的移到枢轴前边，比枢轴大的移到枢轴后边；当本趟所有子序列都被枢轴以上述规则划分完毕后会得到新的一组更短的子序列，他们成为下一趟划分的初始序列集。分别对这两部分子序列继续进行排序，以达到整个序列有序。
快速排序演示
(2)算法描述
具体算法描述如下：
①i = L; j = R; 将基准数挖出形成第一个坑a[i]。
②j--，由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
③i++，由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
④再重复执行②，③二步，直到i==j，将基准数填入a[i]中。
(3)代码实现
//快速排序——C语言实现
/*自定义一个函数 qusort()，实现快速排序。
快速排序是冒泡排序的一种改进，主要的算法思想是在待排序的 n 个数据中取第一个数据作为基准值，将所有记录分为 3 组，使第一组中各数据值均小于或等于基准值，第二组做基准值的数琚，第三组中各数据值均大于或等于基准值。这便实现了第一趟分割，然后再对第二组和第兰组分别重复上述方法，依次类推，直到每组中只有一个记录为止。*/
#include
int qusort(int s[],int start,int end) //自定义函数 qusort()
{
int i,j; //定义变量为基本整型
i=start; //将每组首个元素赋给i
j = end; //将每组末尾元素赋给j
s[0]=s[start]; //设置基准值
while(i 运行结果：
请输入10个数：
99 45 12 36 69 22 62 796 4 696
排序后的顺序是：
4 12 22 36 45 62 69 99 696 796五、选择类排序
1.简单选择排序
(1)基本思想
选择排序的基本思想：比较 + 交换。
简单选择排序采用最简单的选择方式，从头至尾顺序扫描序列，找出最小的一个关键字，和第一个关键字交换，接着从剩下的关键字中继续这种选择和交换，最终使得序列有序。
简单选择排序演示，红色表示当前最小值，黄色表示已排序序列，蓝色表示当前位置。
(2)算法描述
具体算法描述如下：
①从待排序序列中，找到关键字最小的元素；
②如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
③从余下的 N - 1 个元素中，找出关键字最小的元素，重复①、②步，直到排序结束。
(3)代码实现
//选择排序——C语言实现
/*选择排序的基本算法是从待排序的区间中经过选择和交换后选出最小的数值存放到 a[0] 中，再从剩余的未排序区间中经过选择和交换后选出最小的数值存放到 a[1] 中，a[1] 中的数字仅大于 a[0]，依此类推，即可实现排序。
程序中用到T两个 for 循环语句。第一个 for 循环是确定位置的，该位置是存放每次从待排序数列中经选择和交换后所选出的最小数。第二个 for 循环是实现将确定位置上的数与后面待排序区间中的数进行比较的。*/
#include
int main()
{
int i,j,t,a[11]; //定义变量及数组为基本整型
printf("请输入10个数：\n");
for(i=1;i<11;i++)
scanf("%d",&a[i]); //从键盘中输入要排序的10个数字
for(i=1;i<=9;i++)
for (j=i+1;j<=10;j++)
if(a[i]>a[j]) //如果前一个数比后一个数大，则利用中间变量t实现两值互换
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
printf("排序后的顺序是：\n");
for(i=1;i<=10;i++)
printf("%5d", a[i]); //输出排序后的数组
printf("\n");
return 0;
} 运行结果：
请输入10个数：
526 36 2 369 56 45 78 92 125 52
排序后的顺序是：
2 36 45 52 56 78 92 125 369 5262.堆排序
(1)基本思想
堆是一种数据结构，可以把堆看成一颗完全二叉树，这颗完全二叉树满足：任何一个非叶子结点的值都小于等于(或大于等于)其左右孩子结点的值。若父亲大孩子小，则这样的堆叫作大顶堆；若父亲小孩子大，则这样的堆叫作小顶堆。
根据堆的定义知道，代表堆的这棵完全二叉树的根节点的值是最大(或最小)的，因此将一个无序的序列调整为一个堆，就可以找出这个序列的最大（或最小）值，然后将找出的这个值交换到序列的最后（或最前），这样，有序序列的关键字增加1个，无序序列中关键字减少1个，对新的无序序列重复这样的操作，就实现了排序。这就是堆排序的思想。
堆排序中最关键的操作就是将序列调整为堆。整个序列的过程就是通过不断的调整，使得不符合堆定义的完全二叉树变为符合堆定义的完全二叉树。
(2)算法描述
举一趟排序为例：
原始序列：49 38 65 97 76 13 27 49
1）建堆
现将这个序列调整为一个大顶堆，原始序列对应的完全二叉树如下图所示，在这个完全二叉树中，结点76、13、27、49是叶子结点，他们没有左右孩子，所以他们满足堆的定义。从97开始，按97、65、38、49的顺序依次调整。
①调整97。97>49，所以97和它的孩子49 满足堆的定义，不需要调整。
②调整65。65>13，65>27，所以65和它的孩子13、27满足堆的定义，不需要调整。
③调整38。97>38，76>38，不满足堆的定义，需要调整。在这里，38的两个孩子结点值都比38大，应该和哪个交换呢？显然应该是和两者中最大的交换啊。如果和76交换，则76<97仍然不满足堆的定义。因此，将38和97交换，交换后38成了49的根结点，49>38，仍然不满足，需要继续调整，将38和49交换，结果如下图
④调整49。49<97，49<65不满足定义，需要调整。因此和97交换，交换后49<76仍不满足堆的定义，继续调整，将49和76交换，结果如下图
2）排序
可以看到，此时已经建立好了一个大顶堆。对应的序列为：97 76 65 49 49 13 27 38。将堆顶记录97和序列最后一个记录38交换。第一趟堆排序完成。97到达其最终的位置。将除97外的序列38 76 65 49 49 13 27重新调整为大顶堆。现在这个堆只有38不满足堆的定义，其他的记录都满足，所以只需要调整一个38就足够了。调整38，结果如下图
现在的序列为76 49 65 38 49 13 27 97。将堆顶记录76和最后一个记录27交换，第二趟堆排序完成，76到达其最终位置，此时序列如下：27 49 65 38 49 13 76 97。然后对除76和97的序列依照上面的方法继续处理，直到树中只剩下1个结点时排序完成。
堆排序算法过程描述：
①从无序序列所确定的完全二叉树的第一个非叶子结点开始，从右至左，从下至上，对每个结点进行调整，最终将得到一个大顶堆；
对结点的调整方法： 当前节点的值（假设为a）与其孩子结点进行比较，如果存在大于a的孩子结点，则从中选出最大的一个与a交换。当a来到下一层的时候重复上述操作，直到a的孩子结点值都小于a的值为止。
②将当前无序序列中第一个元素，反映在树中是根结点（假设为a）与无需序列中最后一个元素交换（假设为b）。a进入有序序列，到达最终位置。无序序列中元素减少1个，有序序列中元素增加1个。此时只有结点b可能不满足堆的定义，对其进行调整。
③重复②中过程，直到无序序列中的元素剩下1个时排序结束。
(3)代码实现
//堆排序——c++实现
#include
#include
using namespace std;
/*该函数完成对在数组R[low]到R[high]范围内，对在low上的结点进行调整（大堆）*/
void heapAdjust(int R[], int low, int high)
{
int i = low;
int j = i *2+1; //R[j]是R[i]的左孩子节点 （此时对应数组从0开始，若从1开始则 j=i*2）
int temp = R[i];
while (j < high)
{
if (j < high&&R[j] < R[j + 1])
++j; //若右孩子较大，则把 j 指向右孩子
if (temp < R[j])
{
R[i] = R[j]; //将 R[j] 调整到双亲节点的位置上
i = j; //修改 i 和 j 的值，以便继续向下调整
j = 2 * i+1;
}
else
break;
}
R[i] = temp;
}
/*堆排序函数*/
void heapSort(int R[], int n)
{
int i;
int temp;
for (i = n / 2-1; i >= 0; --i) //建立初始堆（大顶堆）（此时对应的数组下标从0开始，若从1开始第一个非叶子结点为 i=n/2）
heapAdjust(R, i, n-1);
for (i = n-1; i >= 1; --i) //进行 n-1 次循环，完成堆排序
{
/*此交换将根结点元素刚入最终的位置上*/
temp = R[0];
R[0] = R[i];
R[i] = temp;
heapAdjust(R, 0, i - 1); //在较少了 1 个元素的无序序列中进行调整
}
}
void main()
{
int R[8] = {49,38,65,97,76,13,27,49 };
heapSort(R, 8);
for (int i = 0; i < 8; i++)
cout << R[i] << " ";
cout << endl;
} 运行结果：
13 27 38 49 49 65 76 97六、归并排序
1.二路归并排序
(1)基本思想
归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
二路归并演示
(2)算法描述
归并排序可通过两种方式实现：
- 自上而下的递归
- 自下而上的迭代
1）递归法（假设序列共有n个元素）：
①将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
②将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
③重复步骤②，直到所有元素排序完毕。
2）迭代法
①申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
②设定两个指针，最初位置分别为两个已经排序序列的起始位置
③比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
④重复步骤③直到某一指针到达序列尾
⑤将另一序列剩下的所有元素直接复制到合并序列尾
(3)代码实现
//归并排序——C语言实现
/*归并是将两个或多个存序记录序列合并成一个有序序列。归并方法有多种，一次对两个有序记录序列进行归并，称为路归并排序，也有三路归并排序及多路归并排序。本代码是二路归并排序，基本方法如下：
(1) 将 n 个记录看成是 n 个长度为 1 的有序子表。
(2) 将两两相邻时有序无表进行归并。
(3) 重复执行步骤 (2) 直到归并成一个长度为 n 的有序表。*/
#include
int merge(int r[],int s[],int x1,int x2,int x3) //自定义实现一次归并样序的函数
{
int i,j,k;
i=x1; //第一部分的开始位置
j=x2+1; //第二部分的开始位置
k=x1;
while((i<=x2)&&(j<=x3)) //当i和j都在两个要合并的部分中时
if(r[i]<=r[j]) //筛选两部分中较小的元素放到数组s中
{
s[k] = r[i];
i++;
k++;
}
else
{
s[k]=r[j];
j++;
k++;
}
while(i<=x2) //将x1〜x2范围内未比较的数顺次加到数组r中
s[k++]=r[i++];
while(j<=x3) //将x2+l〜x3范围内未比较的数顺次加到数组r中
s[k++]=r[j++];
return 0;
}
int merge_sort(int r[],int s[],int m,int n)
{
int p;
int t[20];
if(m==n)
s[m]=r[m];
else
{
p=(m+n)/2;
merge_sort(r,t,m,p); //递归调用merge_soit()函数将r[m]〜r[p]归并成有序的t[m]〜t[p]
merge_sort(r,t,p+1,n); //递归一调用merge_sort()函数将r[p+l]〜r[n]归并成有序的t[p+l]〜t[n]
merge(t,s,m,p,n); //调用函数将前两部分归并到s[m]〜s[n】*/
}
return 0;
}
int main()
{
int a[11];
int i;
printf("请输入10个数：\n");
for(i=1;i<=10;i++)
scanf("%d",&a[i]); //从键盘中输入10个数
merge_sort(a,a,1,10); //调用merge_sort()函数进行归并排序
printf("排序后的顺序是：\n");
for(i=1;i<=10;i++)
printf("%5d",a[i]); //输出排序后的数据
printf("\n");
return 0;
} 运行结果：
请输入10个数：
695 458 362 789 12 15 163 23 2 986
排序后的顺序是：
2 12 15 23 163 362 458 695 789 986七、基数排序
1.基数排序
(1)基本思想
它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
基数排序按照优先从高位或低位来排序有两种实现方案：
-
MSD（Most significant digital） 从最左侧高位开始进行排序。先按k1排序分组, 同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后，再将各组连接起来，便得到一个有序序列。MSD方式适用于位数多的序列。
-
LSD （Least significant digital）从最右侧低位开始进行排序。先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。LSD方式适用于位数少的序列。
基数排序
从最右侧低位开始进行排序(LSD)演示
(2)算法描述
我们以LSD为例，从最低位开始，具体算法描述如下：
①取得数组中的最大数，并取得位数；
②arr为原始数组，从最低位开始取每个位组成radix数组；
③对radix进行计数排序（利用计数排序适用于小范围数的特点）；
参考资料：
数据结构常见的八大排序算法（详细整理）
必须知道的八大种排序算法【java实现】
八大排序算法总结与java实现
JS中可能用得到的全部的排序算法
Quick Sort(排序算法网站)
数据结构高分笔记