文章详细解析八种排序算法逻辑、实现过程、时间复杂度与稳定性，包括直接插入、希尔、选择、堆、冒泡、快速、归并及计数排序，提供优化技巧如快速排序的三数取中避免最坏情况，附代码示例与效率比较。
本篇文章是我对之前写过的八个排序算法的总结，感兴趣的小伙伴可以去我的八大排序算法专栏浏览，也可以点击下方标题跳转。
提示：本篇博客篇幅较长，建议小伙伴们查看目录，按需浏览
目录
正文
本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析（算法逻辑、具体实现过程、时间复杂度、稳定性），并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。
注：在本文中，均以升序排序进行讲解
1 直接插入排序
基本思想：
-
直接插入排序是一种简单明了的插入排序法，其基本思想是：把待排序的数据按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有数据插入完为止。
-
在现实生活中，我们玩扑克对牌进行排序就运用了这种思想。
整体插入思想：
统一使用升序
-
当插入第（i >= 1）个元素时，前面的array[0], array[1], ……, array[i - 1]已经有序，此时用array[i]的值与array[i - 1], array[i - 2],……的值顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。
-
如对数组{2, 5, 4, 6, 8, 7, 1}进行升序排序：
代码实现：
-
我们假设数组中[0,end]的数据已经有序，要将nums[end + 1]这个元素插入到[0,end]中，使[0,end + 1]也有序
-
因为可能要进行数据后移的操作，为防止nums[end + 1]被覆盖而无法得到其值，要事先用临时变量保存
int end;
int temp = nums[end + 1]; -
运用插入排序的思想，将nums[end + 1]（即temp）从后往前依次与有序的元素进行比较，满足条件就插入
while (end >= 0)
{
/*
如果后面的数比前面的小，那就将前面的数后移
继续将后面的数与更前面的数（即更小的数）比较
*/
if (temp < nums[end])
{
nums[end + 1] = nums[end];
end--;
}
/*
否则，如果后面的数比前面的大
那么满足升序条件，将temp插入到nums[end]的后面
*/
else
nums[end + 1] = temp;
}-
但是，上面这段代码还是存在一个小小的bug，即如果我们要插入的元素temp比有序序列的第一个元素nums[0]还要小，那么执行完
nums[end + 1] = nums[end];end--;这一操作后，end就等于-1了，而循环的条件是end >= 0，无法进入循环，end[0]这一位置也无法被赋值，因此，我们要进行改进：
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + 1] = nums[end];
end--;
}
/*
如果后面的数比前面的大
那么满足升序条件，直接退出循环
*/
else
break;
}
//将（end >= 0 && temp > nums[end]）和 （end == -1）这两种情况整合到一起
nums[end + 1] = temp;-
设待排序数组有numsSize个元素，因此要使数组有序，就要用一层for循环来分别判断数组的每个值是否处于正确的位置。
//为防止数组越界，i的最大值为numsSize - 2
for (int i = 0; i < numsSize - 1; i++)
{
int end = i;
int temp = nums[end + 1];
…………
}动图演示：
实现代码：
void sort(int* nums, int numsSize)
{
//为防止数组越界，i的最大值为numsSize - 2
for (int i = 0; i < numsSize - 1; i++)
{
/*
假设[0,end]已经有序
要将nums[end + 1]这个元素插入到[0,end]中，使[0,end + 1]也有序
*/
int end = i;
int temp = nums[end + 1]; //因为可能要进行数据后移的操作，为防止nums[end + 1]被覆盖而无法得到其值，要事先用临时变量保存
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + 1] = nums[end];
end--;
}
/*
如果后面的数比前面的大
那么满足升序条件，直接退出循环
*/
else
break;
}
//将（end >= 0 && temp > nums[end]）和 （end == -1）这两种情况整合到一起
nums[end + 1] = temp;
}
}时间复杂度：
统一为升序排序
-
最好的情况：最好的情况就是数组已经升序有序，只有最外面一层for循环遍历一次数组，里面的while循环每一次都是直接退出，因此最好的情况时间复杂度为O(N)
-
最坏的情况：最坏的情况就是数组是降序排序，里面while循环的时间复杂度为O(N)，因此最坏情况下，时间复杂度为O(N^2)
-
综上，直接插入法的时间复杂度为O(N^2)
2 希尔排序
注1：本篇是基于对直接插入排序法的拓展，如果对直接插入法不了解，建议先看看直接插入排序
注2：本篇统一采用升序排序
基本思想：
-
希尔排序法又称缩小增量法。
-
希尔排序其实是直接插入排序的改进。
-
其基本思想是：先选定一个整数gap，把待排序文件中所有记录分成数组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后缩小gap，重复上述步骤，当gap == 1时，所有记录在统一组内已经排好序。
整体插入思想：
-
在直接插入排序中，我们知道最坏的情况是待排序列降序逆序的情况，如序列：
8,7,6,5,4,3,2,1，这时时间复杂度为O(N2)，显然效率不高
-
而希尔排序的思想，就是先对待排序列进行预排序，使待排序列接近有序。我们知道，当待排序列接近有序时，直接插入排序法的时间复杂度接近O(N)，效率很高，因此预排序过后，就使用直接插入排序法，从而提高了效率。
预排序：
-
预排序实际上也是直接插入排序，但是是将待排序列分成数组来排
-
根据基本思想，规定间隔为gap的数为一组
-
我们以数组
{9,8,7,6,5,4,3,2,1}，gap = 3为例：-
每gap为一组：
-
对第一组排序：
-
对第二组排序：
-
对第三组排序：
-
-
这时相较于最开始，待排序列更加接近于有序，此时我们不断缩小gap，不断预排序，直到最后gap == 1时最后使用一次直接插入排序（gap == 1时的直接插入排序实际上就是最原始的直接插入排序），使待排序列有序。
-
又例如：
结论：
-
希尔排序实际上就是多组间隔为gap的预排序，gap由大到小
-
gap越大，大的数能越快到后面，小的数能越快到前面
-
gap越大，预排序之后待排序列越不接近于有序
-
gap越小，预排序之后待排序列越接近于有序
-
当gap == 1时，预排序实际上就是对整个序列进行直接插入排序，排完后序列即有序
-
因此，最后一次预排序，gap必须为1.
代码实现：
-
对每间隔gap的一组数据进行排序，本质上就是直接插入排序，故不作过多讲解
int end;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;-
对多组间隔为gap的数据进行预排序
-
以这张图为例：
-
我们上面的步骤只是将间隔为pap的一组数据进行了排序，但待排序列不止一组间隔为gap的数据，因此我们要做到将所有间隔为gap的每组数据都进行排序。
-
怎么实现呢？可能最容易想到的是分别将每组间隔为gap的数据进行排序，例如上面分别对第一组，第二组，第三组排序，但是这样做效率不高，且操作复杂。因此我们要换一种想法，即把间隔为gap的数据同时排序。
-
如图：
-
for (int i = 0; i < numsSize - gap; i++)
{
int end = i;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;
}-
最后还要不断缩小gap的值，直到gap == 1
int gap = numsSize;
while (gap > 1)
{
gap /= 2; //不断缩小gap
/*
也可以写成 gap = gap / 3 + 1;
总之，必须要保证最后一次gap == 1
*/
for (int i = 0; i < numsSize - gap; i++)
{
int end = i;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;
}
}动图演示：
实现代码：
void ShellSort(int* nums, int numsSize)
{
int gap = numsSize;
while (gap > 1)
{
gap /= 2;
for (int i = 0; i < numsSize - gap; i++)
{
int end = i;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;
}
}
}直接插入排序与希尔排序的效率比较：
-
看到希尔排序有三层循环，可能有小伙伴会疑惑希尔排序为什么会比直接插入排序快，这里我们先上测试代码，直观的来感受这两个排序算法之间的差距：
测试代码：
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
//直接插入排序
void InsertSort(int* nums, int numsSize)
{
for (int i = 0; i < numsSize - 1; i++)
{
int end = i;
int temp = nums[end + 1];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + 1] = nums[end];
end--;
}
else
break;
}
nums[end + 1] = temp;
}
}
//希尔排序
void ShellSort(int* nums, int numsSize)
{
int gap = numsSize;
while (gap > 1)
{
gap /= 2;
for (int i = 0; i < numsSize - gap; i++)
{
int end = i;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;
}
}
}
int main()
{
srand((unsigned int)time(NULL));
//创建两个大小为N的数组
const int N = 100000;
int* a1 = (int*)malloc(sizeof(int) * N);
int* a2 = (int*)malloc(sizeof(int) * N);
//为数组赋随机值
for (int i = 0; i < N; i++)
{
a1[i] = rand();
a2[i] = a1[i];
}
/*
clock()函数可以记录当前时间
begin和end的差即排序算法运行的时间
注：时间的单位为毫秒(ms)
*/
int beginl = clock();
InsertSort(a1, N);
int end1 = clock();
int begin2 = clock();
ShellSort(a2, N);
int end2 = clock();
printf("InsertSort:%d\n", end1 - beginl);
printf("ShellSort:%d\n", end2 - begin2);
//释放内存
free(a1);
free(a2);
return 0;
}-
测试结果：
-
我们可以看到，当数据个数为十万个时，直接插入排序所需要的时间是的希尔排序的100多倍
-
当数据个数为一百万个时，直接插入排序所需要的时间时希尔排序的2000倍、
-
可见，数据越多，希尔排序的优势就越明显，节省点时间就越多
时间复杂度：
-
从上面的测试中，我们直观的感受到了相较于直接插入排序，希尔排序的优越性，那么具体的希尔排序的时间复杂度为多少呢？
-
我们先来看最外层的循环：
int gap = numsSize;
while (gap > 1)
{
gap /= 2;
…………
}-
设最外层循环运行了x次，那么2x = numsSize，x = log2N，即最外层的时间复杂度为log2N
-
再看里面两层循环：
for (int i = 0; i < numsSize - gap; i++)
{
int end = i;
int temp = nums[end + gap];
while (end >= 0)
{
if (temp < nums[end])
{
nums[end + gap] = nums[end];
end -= gap;
}
else
break;
}
nums[end + gap] = temp;
}-
当gap很大时，尽管有两层循环，但数据之间跳跃的很大，需要排序的次数很少，因此时间复杂度为O(N)，例如这种情况：
-
当gap很小时，尽管有两层循环，但此时数据已经接近有序，需要排序的次数也很少，因此时间复杂度也为O(N)。
-
综上，希尔排序的时间复杂度为O(NLogN)
-
也可以认为时间复杂度为O(N^1.3)
3 直接选择排序
以升序排序为例
算法步骤：
方法一：直接交换数组元素
-
将第一个元素与其他元素进行比较，若其他元素小于第一个元素，则交换位置，最后第一个元素为最小元素
-
将剩余元素的第一个元素与其他元素进行比较，若其他元素小于第一个元素，则交换位置
-
重复上述步骤，直到第（n-1）个元素比较完毕
方法二：利用数组下标间接交换数组元素
-
将第一个元素的下标标记为min，将第一个元素与其他元素进行比较，若其他元素小于第一个元素，则令该元素的数组下标为min，一轮比较完后，若第一个元素的下标不等于min，则交换第一个元素与下标为min的元素的位置
-
对剩下的元素重复上述步骤，直到没有元素需要交换位置
动图演示：
实现代码：
#include<stdio.h>
void WayOne(int *p,int num) //利用直接交换数组元素，从小到大排列数组
{
int i,j,temp;
for(i=0;i<num-1;i++) //需比较（数组元素-1）次
for(j=i+1;j<num;j++)
if(p[i]>p[j])
{
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
for(i=0;i<num;i++)
printf("%-5d",p[i]);
}
void WayTwo(int *p,int num) //利用元素下标间接交换数组元素，从大到小排列数组
{
int i,j,temp,max;
for(i=0;i<num-1;i++)
{
max=i; //设置标记
for(j=i+1;j<num;j++)
if(p[j]>p[max])
max=j;
if(max!=i)
{
temp=p[max];
p[max]=p[i];
p[i]=temp;
}
}
for(i=0;i<num;i++)
printf("%-5d",p[i]);
}
int main()
{
int a[]={12,134,46,688,563,145,7357,26,24};
WayOne(a,sizeof(a)/sizeof(int));
printf("\n");
WayTwo(a,sizeof(a)/sizeof(int));
return 0;
}3.1 改进算法（双指针）
具体步骤：
-
上面的直接选择排序每一次只能选出一个数据，但是，我们可以用双指针的方法进行改进，做到每一次可以选出两个数据
-
首先，我们令begin指向数组第一个元素，end指向数组最后一个元素
-
然后，遍历
[begin,end]这一块区域，同时保存最大值和最小值元素的下标max_index、min_index -
由于进行的是升序排序，begin位置应该放置最小值，end位置应该放置最大值，我们就可以利用下标来交换begin、min_index和end、max_index的数据
-
缩小区域
[begin,end]，重复上述步骤，直到不能满足条件begin < end
实现代码：
void SelectSort(int* nums, int numsSize)
{
int begin = 0;
int end = numsSize - 1;
while (begin < end)
{
int max_index = end;
int min_index = begin;
for (int i = begin; i <= end; i++)
{
//得到最小值的下标
if 
扫一扫
5324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
