作者:小 琛
欢迎转载,请标明出处
引言:排序算法是生活中一种常见算法,用途非常广泛。因此在任何的笔试面试中都几乎为必考内容。本博文汇总所有的排序算法,分析其逻辑思路,并进行代码实现,同时对其性能进行分析。
-
插入排序
-
希尔排序
-
堆排序——引用于博主“阿顾同学”博文
-
选择排序
-
冒泡排序
-
快速排序(三种写法)
文章目录
插入排序
逻辑思想
将一个数插入到另一组已知的有序数列中去。
我们可以将待排序的一组数的第一个数看为一个已知的有序数列,将第二个数进行插入并形成新的有序数列,之后再将第三个数插入到前两个数构成的有序数列,依次类推。
而如何实现将一个数插入到一个已知的有序数列中?看下图,这里是一个实现单次插入的逻辑导图,首先设定一个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;
}