作者：小 琛
欢迎转载，请标明出处
引言：排序算法是生活中一种常见算法，用途非常广泛。因此在任何的笔试面试中都几乎为必考内容。本博文汇总所有的排序算法，分析其逻辑思路，并进行代码实现，同时对其性能进行分析。
-
插入排序
-
希尔排序
-
堆排序——引用于博主“阿顾同学”博文
-
选择排序
-
冒泡排序
-
快速排序(三种写法)
文章目录
插入排序
逻辑思想
将一个数插入到另一组已知的有序数列中去。
我们可以将待排序的一组数的第一个数看为一个已知的有序数列，将第二个数进行插入并形成新的有序数列，之后再将第三个数插入到前两个数构成的有序数列，依次类推。
而如何实现将一个数插入到一个已知的有序数列中？看下图，这里是一个实现单次插入的逻辑导图，首先设定一个end指向该序列尾，定义tmp储存要插入的数，令end从尾向头移动，若end指向的数大，则end+1=end来实现后移，当end小于tmp时，再将end+1=tmp，从而实现
当实现了单个数的插入后，实现整个数组便非常简单，只需要使用一个循环，令end最初的指向为第一个数，知道实现最后一个数插入为止。
代码实现
void InsertSort(int *a, int count)
{
for (size_t i = 0; i<count - 1; i++) //这里i<count-1,最后一个数为count-1，则end只需要为倒数第二数即可
{
int end = i;
int tmp = a[end + 1];//将本轮进行插入的数临时储存
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
性能分析
- 通过对代码的理解，不难得到当元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)，不需要额外的空间，比较稳定
- 稳定性：稳定
- 缺点：当序列非常无序甚至倒序时，该算法非常笨重
希尔排序
希尔的思考
在已经掌握了插入排序的基础上，我们能分析出，插入排序有其优点的同时也有缺点，即在该序列足够有序的时候，插入排序会非常快，但如果一个序列不够有序呢？是否能通过一些手段来优化插入排序，这就是希尔的思考。
希尔排序的逻辑
设定一个gap，以gap为间隔进行分组，分成若干组后，每组进行插入排序
其实，当gap等于1的时候，所谓的希尔排序就是插入排序，因此对于代码的编写，只需要在插入排序上修改即可🤭
代码实现
void ShellSort(int *a, int count)
{
int gap = count;
while (gap > 1)
{
gap = gap / 3 + 1;
for (size_t i = 0; i<count - gap; i += gap)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
小技巧：将插入排序的代码中的所有“1”改换为gap，再加入一个以gap为判断的大循环
性能分析
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
- 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N1.3—N2）
- 稳定性：不稳定
- 不可对一组接近有序的数据进行希尔排序，因为其本身就接近有序而再去进行预排序则会起到反作用
堆排序
逻辑思想：
1.首先将待排序的数组构造成一个大根堆，此时，整个数组的最大值就是堆结构的顶端
2.将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为n-1
3.将剩余的n-1个数再构造成大根堆，再将顶端数与n-1位置的数交换，如此反复执行，便能得到有序数组
具体实现
- 构造堆
将无序数组构造成一个大根堆（升序用大根堆，降序就用小根堆）
假设存在以下数组
主要思路：第一次保证0-0位置大根堆结构，第二次保证0-1位置大根堆结构，第三次保证02位置大根堆结构…直到保证0n-1位置大根堆结构（每次新插入的数据都与其父结点进行比较，如果插入的数比父结点大，则与父结点交换，否则一直向上交换，直到小于等于父结点，或者来到了顶端）
插入6的时候，6大于他的父结点3，即arr(1)>arr(0)，则交换；此时，保证了0~1位置是大根堆结构，如下图：
插入8的时候，8大于其父结点6，即arr(2)>arr(0),则交换；此时，保证了0~2位置是大根堆结构，如下图
插入5的时候，5大于其父结点3，则交换，交换之后，5又发现比8小，所以不交换；此时，保证了0~3位置大根堆结构，如下图
插入7的时候，7大于其父结点5，则交换，交换之后，7又发现比8小，所以不交换；此时整个数组已经是大根堆结构
2. 固定最大值再构造堆
此时，我们已经得到一个大根堆，下面将顶端的数与最后一位数交换，然后将剩余的数再构造成一个大根堆
此时最大数8已经来到末尾，则固定不动，后面只需要对顶端的数据进行操作即可，拿顶端的数与其左右孩子较大的数进行比较，如果顶端的数大于其左右孩子较大的数，则停止，如果顶端的数小于其左右孩子较大的数，则交换，然后继续与下面的孩子进行比较
下图中，5的左右孩子中，左孩子7比右孩子6大，则5与7进行比较，发现5<7，则交换；交换后，发现5已经大于他的左孩子，说明剩余的数已经构成大根堆，后面就是重复固定最大值，然后构造大根堆
如下图：顶端数7与末尾数3进行交换，固定好7
剩余的数开始构造大根堆 ，然后顶端数与末尾数交换，固定最大值再构造大根堆，重复执行上面的操作，最终会得到有序数组
总结
到这里，大家应该对堆排序都有了自己的见解，我们对上面的流程总结下：
1、首先将无需数组构造成一个大根堆（新插入的数据与其父结点比较）
2、固定一个最大值，将剩余的数重新构造成一个大根堆，重复这样的过程
选择排序
逻辑思想
选择排序是这几种排序中最简单最好理解的一种，多数人写选择排序的时候会采取每次选择一个数，这里给大家讲一个每次选择两个数(即一个最大一个最小)的办法
注意这里操作的均为数组下标
设定一个begin和end，初始为第一和最后位置，代表一个最大数一个最小数的位置，定义maxi、mini即最大、最小数，利用循环遍历，每次选择出以begin为头以end为尾的区间内的最大和最小数，将其分别与begin、end交换，再将begin++，end–，以begin<end为判断条件
在具体实现代码的时候要注意一个问题，如下序列
在进行选择排序的时候会出现一个问题：begin所指的正好是最大的数maxi，因此交换会出错，所以我们在编写代码的时候要加以判断
代码实现
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin;
int mini = begin;
for (int i = begin; i <= end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);//Swap为交换函数
if (maxi == begin)//排除bug情况
maxi = mini;
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
性能分析
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用或者说几乎不用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
冒泡排序
逻辑思想
冒泡排序是每个代码学习者必会的一种排序，这里不进行过多分析，其思想为：一共有n个数，则进行n-1趟，每一趟通过相邻两数比较并交换使最大的数后移
代码实现
void BubbleSort(int* a, int n)
{
int count = 0;
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - i - 1; j++)
{
if (a[j]>a[j + 1])
{
Swap(&a[j], &a[j + 1]);
count++;
}
}
if (count == 0)
{
break;
}
}
}
性能分析
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
快速排序
快速排序是排序算法中非常重要的一种，同时也是最有优势和应用最广的一种。快排的思想其实启蒙于堆，现在常用的写法有三种，不过具体逻辑都一样。
- hoare版本
- 挖坑法
- 前后指针版本
注意，这里的三种版本更多的差别在于代码编写方法的不同，其本质思想其实类似
hoare版本代码逻辑思想
例如上面序列，我们选定一个key，通常是第一个数或者最后一个，这里选第一个，再定义一个begin一个end分别指向头和尾，如下图
此时我们进行得操作如下：end率先行动，寻找比key小的数停下，随之begin再走，寻找比key大的数停下，随之交换，直到begin和end相遇为止
注意：这里end要率先行动非常重要，如果你选择begin为key，则end先动，反之选择end为key则要begin先动
到该步，将begin和end指向的数与key交换
这时，我们已经理清楚了快排的单趟排序。
可以写一下代码
int quick_part(int *a, int begin, int end)
{
int key = begin;//以begin为key
while (begin < end) //以二者相遇为界
{
while (begin < end && a[end] >= a[key]) //end先走，寻找小于key的
{
end--;
}
while (begin < end && a[begin] <= a[key])//begin再走找大于key的
{
begin++;
}
Swap(&a[begin], &a[end]); //进行交换
}
Swap(&a[begin], &a[key]);//当begin、end相遇，此时的位置就是key应该在的位置
return begin;//返回该趟的下标，以便于接下来的操作
}
当我们完成到这步，已经成功了一大半，接下来的操作看图：
void quicksort(int *a, int left, int right)
{
if (left >= right) //当left=right时即为一个数，这里要包含大于的特殊情况
{
return;
}
int keyIndex = quick_part2(a, left, right);//第一次快排
quicksort(a, left, keyIndex - 1);//以得到的已经归为的值为界限分别快排递归
quicksort(a, keyIndex + 1, right)；
}
但此时我们要思考一个问题：我们选择的key，在什么情况下会让快排更加高效？
答案：key越接近中位数越高效，不难理解，加入我们选择的key正好是最小的，那么对于序列的切割几乎是没作用的
因此，为了避免最坏情况的发生，我们要在快排中加入一个算法，来尽量让选的key接近中位数，通常采用三位取中法
三位取中法：其实不是什么高端算法，仅仅是将第一个数begin、最后一个数end、中间的数(begin+end) /2 的三个数选出中间的一个作为key，然后每次调用该函数进行选取，和begin交换
这里不讲述逻辑了，比较简单
int getmidIndex(int* a, int left, int right)
{
int mid = left + ((right - left) >> 1);
if (a[left] > a[mid])
{
if (a[mid] > a[right])
return mid;
else if (a[left] < a[right])
return left;
else
return right;
}
else//a[left]<a[mid]
{
if (a[mid] < a[right])
return mid;
else if (a[left]>a[right])
return left;
else
return right;
}
}
到这里，我们将快排就全部写完了
代码实现
int getmidIndex(int* a, int left, int right)
{
int mid = left + ((right - left) >> 1);
if (a[left] > a[mid])
{
if (a[mid] > a[right])
return mid;
else if (a[left] < a[right])
return left;
else
return right;
}
else//a[left]<a[mid]
{
if (a[mid] < a[right])
return mid;
else if (a[left]>a[right])
return left;
else
return right;
}
}
int quick_part2(int *a, int begin, int end)
{
int mid = getmidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int key = a[begin];
while (begin < end)
{
while (begin<end && a[end] >= key)
{
end--;
}
a[begin] = a[end];
while (begin < end && a[begin] <= key)
{
begin++;
}
a[end] = a[begin];
}
a[begin] = key;
return begin;
}
int quick_part(int *a, int begin, int end)
{
int mid = getmidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int key = begin;//以begin为key
while (begin < end) //以二者相遇为界
{
while (begin < end && a[end] >= a[key]) //end先走，寻找小于key的
{
end--;
}
while (begin < end && a[begin] <= a[key])//begin再走找大于key的
{
begin++;
}
Swap(&a[begin], &a[end]); //进行交换
}
Swap(&a[begin], &a[key]);//当begin、end相遇，此时的位置就是key应该在的位置
return begin;//返回该趟的下标，以便于接下来的操作
}
void quicksort(int *a, int left, int right)
{
if (left >= right)
{
return;
}
if (right - left + 1 < 10)
{
InsertSort(a + left, right - left + 1);
}
else
{
int keyIndex = quick_part2(a, left, right);
quicksort(a, left, keyIndex - 1);
quicksort(a, keyIndex + 1, right);
}
}
//三数取中
int getmidIndex(int* a, int left, int right)
{
int mid = left + ((right - left) >> 1);
if (a[left] > a[mid])
{
if (a[mid] > a[right])
return mid;
else if (a[left] < a[right])
return left;
else
return right;
}
else//a[left]<a[mid]
{
if (a[mid] < a[right])
return mid;
else if (a[left]>a[right])
return left;
else
return right;
}
}
//单次快排实现
int quick_part(int *a, int begin, int end)
{
int mid = getmidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int key = begin;//以begin为key
while (begin < end) //以二者相遇为界
{
while (begin < end && a[end] >= a[key]) //end先走，寻找小于key的
{
end--;
}
while (begin < end && a[begin] <= a[key])//begin再走找大于key的
{
begin++;
}
Swap(&a[begin], &a[end]); //进行交换
}
Swap(&a[begin], &a[key]);//当begin、end相遇，此时的位置就是key应该在的位置
return begin;//返回该趟的下标，以便于接下来的操作
}
//递归实现总快排
void quicksort(int *a, int left, int right)
{
if (left >= right)
{
return;
}
if (right - left + 1 < 10)//在小于10个数据可以考虑采用插入排序
{
InsertSort(a + left, right - left + 1);
}
else
{
int keyIndex = quick_part2(a, left, right);
quicksort(a, left, keyIndex - 1);
quicksort(a, keyIndex + 1, right);
}
}
性能分析
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定，在数据量庞大的时候最有优势，但选择key始终存放不稳定性
接下来介绍快排的另外两种代码思路，本质逻辑其实是一样的，区别仅仅在与单次写法的不同，因此以下就只写单次排序的代码部分
挖坑法的思想
挖坑法是快排的一种写法，特点是比较好理解且不容易出错，在之前讲述的写法中我们知道：代码编写的时候要注意的地方很多，不然会出错，例如，while的判断条件要是<=和>=，选择begin一定要end先走等等。挖坑法的就不会有这些
紧接着end成为新坑之后，begin寻找比key大的数，填坑形成新坑，直到begin和end相遇为止
到此就完成了挖坑法的单趟，其余部分都是一样的
代码如下：
int quick_part2(int *a, int begin, int end)
{
int mid = getmidIndex(a, begin, end);//三数取中
Swap(&a[mid], &a[begin]);
int key = a[begin];//选begin为key，也是初始坑位
while (begin < end)
{
while (begin<end && a[end] >= key)//end寻找小于key的数
{
end--;
}
a[begin] = a[end];//填坑，end形成新坑
while (begin < end && a[begin] <= key)//begin寻找大于key的数
{
begin++;
}
a[end] = a[begin];//填坑，形成新坑
}
a[begin] = key;//begin、end相遇的位置就是key的应该位置
return begin;//返回key，即完成切割
}
前后指针法
这种写法是一种新的代码编写方法，特定就就在逻辑上不好理解，但在代码的编写上特别的简单。
思路：定义两个指针cur和prev，一个指向begin即第一个数，另一个指向cur之前的位置，仍然选取begin处的数为key。cur开始寻找小于key的数，找到停下，此时prev向前进一位并将二者进行交换。以cur走到最完一位为终止条件。
最终结果：
代码编写：
int quick_part3(int *a, int begin, int end)
{
int midIndex = getmidIndex(a, begin, end);
Swap(&a[midIndex], &a[begin]);
int key = a[begin];
int cur = begin;
int prev = cur - 1;
while (cur <= end)
{
while (cur <= end && a[cur] >= key)
{
cur++;
}
if (cur > end)
break;
else
{
prev++;
Swap(&a[prev], &a[cur]);
}
}
return prev;
}
771
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
