八大排序的基本知识及其实现
注：这里的八大排序指直接插入，希尔，选择，堆排，冒泡，快排，归并，计数
- 八大排序汇总图：
二、排序概念及应用
1、概念
- 排序：
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作
- 稳定性：
假设在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的(记录的相对次序保持不变)；否则称为不稳定的
- 内部排序：
数据元素全部放在内存中的排序
- 外部排序：
数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序
2、排序应用
- 示例：搜索电影时
三、排序算法接口展示
// 排序实现的接口
// 插入排序
void InsertSort(int\* a, int n);
// 希尔排序
void ShellSort(int\* a, int n);
// 选择排序
void SelectSort(int\* a, int n);
// 堆排序
void AdjustDwon(int\* a, int n, int root);
void HeapSort(int\* a, int n);
// 冒泡排序
void BubbleSort(int\* a, int n)
// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int\* a, int left, int right);
// 快速排序挖坑法
int PartSort2(int\* a, int left, int right);
// 快速排序前后指针法
int PartSort3(int\* a, int left, int right);
void QuickSort(int\* a, int left, int right);
// 快速排序 非递归实现
void QuickSortNonR(int\* a, int left, int right)
// 归并排序递归实现
void MergeSort(int\* a, int n)
// 归并排序非递归实现
void MergeSortNonR(int\* a, int n)
// 计数排序
void CountSort(int\* a, int n)
四、插入排序
1、直接插入排序
直接插入排序是一种简单的插入排序法
- 基本思想：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列
- 动图展示：
- 实现代码：
//直接插入排序
void InsertSort(int\* a, int n)
{
assert(a);//传入数组不为空指针
int i;
for (i = 0; i < n - 1; i++)
//注意：最后一个要插入数据的下标为n-1，此次插入有序数列的end下标为n-2
{
int end = i;//标记当前有序数列的最后一个位置下标
int x = a[end + 1];//要插入的数据为有序数列的后一个位置
while (end >= 0)//进行当前趟次的插入排列
{
//升序
if (a[end] >x)//有序数列的数据比插入数据大，则往后挪动
{
a[end + 1] = a[end];
end--;//向前找，进行排列数据
}
else//遇到不大于要插入数据，则不再往前找
{
break;
}
}
a[end + 1] = x;//将要插入数据插入到不大于该数据的后一个位置
}
}
- 直接插入排序的特性总结：
- 元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)，它是一种稳定的排序算法
- 稳定性：稳定
2、希尔排序
- 基本思想：
对于直接插入排序在面对一些特殊情况时，效率非常低（例如：将降序排成升序），而对于已经接近排好的序列，效率非常高
希尔排序在直接排序之前，进行预排列，将某些极端数据更快的排列到数列前面，构成一个接近排列好的序列，最后再进行一次直接插入排序
预排列的原理也是插入排列，只不过这里的将数组分成了gap组，分别对每一个小组进行插入排序
如下动图：对于升序，当gap从5 – 2 – 1的过程中，排在后面的数值小的数能更快排到前面，当gap为1的时候实际上就是进行了一次插入排序
- 动图展示：
// 希尔排序
void ShellSort(int\* a, int n)
{
//多组预排（一锅炖）+插排
int gap = n;
while (gap > 1)
{
gap /= 2;//保证最后一次分组gap==1,即最后一次为直接插入排序
//gap = gap / 3 + 1;//也可以写成这样，除3预排的效率相比于除2的好点
for (int i = 0; i < n - gap; i++)
{
int end = i;
int x = a[end + gap];
while (end >= 0)
{
if (a[end] > x)
{
a[end + gap] = a[end];
end-=gap;
}
else
break;
}
a[end + gap] = x;
}
}
}
- 希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比
- 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，一般来说为O(n^1.3)
- 稳定性：不稳定
五、选择排序
1、直接选择排序
- 基本思想：
每一次遍历待排序的数据元素从中选出最小（或最大）的一个元素，存放在序列的起始（或者末尾）位置，直到全部待排序的数据元素排完
- 动图展示：
- 实现代码：
// 选择排序
void SelectSort(int\* a, int n)
{
int begin = 0, end = n - 1;//记录下标
while (begin < end)
{
int mini = begin;
for (int i = begin; i <= end; i++)
{
//遍历找到最小数据并记录下标
if (a[i] < a[mini])
mini = i;
}
Swap(&a[begin], &a[mini]);//交换
begin++;//缩小范围
}
}
这里我们还可以对直接选择排序做一个优化：每次遍历待排序数据找出最大和最小的数据，分别排列到序列起始和末尾
- 优化代码：
// 选择排序（优化版）
void SelectSort(int\* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin, 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]);//交换
//当最初始位置begin与对大数据下标重合的情况
if (begin == maxi)//修正下标位置
maxi = mini;
Swap(&a[end], &a[maxi]);
begin++;//缩小范围
end--;
}
}
- 直接选择排序的特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
2、堆排序
堆排序是指利用堆（数据结构）进行选择数据的一种排序算法
- 基本思想:
- 原则：
先将原数组建成堆，需要注意的是排升序要建大堆，排降序建小堆
注：以大堆为例- 建堆：
一个根节点与子节点数据如果不符合大堆结构，那么则对根节点数据进行向下调整，而向下调整的前提是左右子树也符合大堆结构,所以从堆尾数据的根节点位置开始向下调整建大堆- 排序：
大堆堆顶数据一定是待排数据中最大的，将堆顶数据与堆尾数据交换,交换后将除堆尾数据看成新堆，对现堆顶数据进行向下调整成大堆,以此循环直至排列完毕- 向下调整：
找到子节点中的较大数据节点比较，如果父节点数据比大子节点小则交换，直到不符合则停止向下交换，此时再次构成了一个大堆结构
具体堆排序详解：堆排序超详解
- 动图展示：大堆排序
- 实现代码：
void Adjustdown(int\* a, int n,int parent)
{
int child = parent \* 2 + 1;
while (child < n)
{
//找到数据大的子结点
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
//父节点数据小于子节点就交换
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
//更新下标
parent = child;
child = parent \* 2 + 1;
}
else//否则向下调整完毕
break;
}
}
// 堆排序(升序)建大堆
void HeapSort(int\* a, int n)
{
int i;
//建大堆
for (i = (n - 1 - 1) / 2; i >= 0; i--)
{
Adjustdown(a, n, i);
}
//交换调整
for (i = n - 1; i >= 0; i--)
{
Swap(&a[0], &a[i]);//与当前堆尾数据交换
Adjustdown(a, i, 0);//对交换后堆顶数据进行向下调整
}
}
- 直接选择排序的特性总结：
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
六、交换排序
1、冒泡排序
- 基本思想：
每次遍历待排序数组，对相邻数据进行比较，不符合排序要求则交换
- 动图展示：
- 实现代码：
// 冒泡排序
void BubbleSort(int\* a, int n)
{
int i, j;
for (i = 0; i < n - 1; i++)//遍历趟数
{
for (j = 0; j < n - 1 - i; j++)//比较次数
{
if (a[j] > a[j + 1])//升序
Swap(&a[j], &a[j + 1]);//交换
}
}
}
- 冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
2、快速排序
- 基本思想为：
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列
左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值 然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止
- 按基准值划分左右的方式有：
1）hoare
注：基本操作过程如图示
- 实现代码：
// 按基准划分hoare版本
int PartSort1(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);//三数取中（优化取基准值，后面会解释）
Swap(&a[mid], &a[left]);//使得中间值永远在最左，便于决定谁先走
int key = left;
while (left < right)
{
//Key设在左边，先从右边寻找小于a[key]的
while (left < right && a[right] >= a[key])
{
right--;
}
//再从左边寻找大于a[key]的
while (left < right && a[left] <= a[key])
{
left++;
}
//找到后交换
Swap(&a[left], &a[right]);
}
//最后相遇时将key与相遇点交换
Swap(&a[key], &a[left]);
return left;//返回相遇点下标
}
- key的位置与左右下标谁先走的关系：
注：对于排升序来说
一般来说在三数取中后得到中等值key，我们让该值与待排序数组的最左边起始位置交换，使得key永远在最左边，并且之后会让右下标先走找小于key的值，找到后再让左下标走找大于key的值，都找到则交换，相遇后再将key与相遇位置的值交换
- 右下标先走的话，对于两下标相遇的的情况只有两种：
- 右下标走着走着遇到左下标，此时左下标的值一定是小于key的值（交换后左下标是原来右下标的小于key的值）
- 左下标走着走着遇到右下标，此时右下标的值一定是小于key的是（右下标找小于key的值）
- 所以这样保证了最后下标相遇与key交换后，key左边区间一定小于key，右边区间一定大于key
2）挖坑法
注：基本操作过程如图示
- 实现代码：
// 快速排序挖坑法
int PartSort2(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[mid], &a[left]);//使得中间值永远在最左，便于决定谁先走
int key = a[left];//保存key值（基准值）
int pivot = left;//保存坑下标
while (left < right)
{
//右边先找
while (left<right && a[right]>=key)
{
right--;
}
//填坑
a[pivot] = a[right];
pivot = right;
//再从左边找
while (left < right && a[left] <= key)
{
left++;
}
//填坑
a[pivot] = a[left];
pivot = left;
}
//相遇
a[pivot] = key;
return pivot;
}
3）前后指针法
注：基本操作过程如图示
- 实现代码：
// 快速排序前后指针法（推荐）
int PartSort3(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[mid], &a[left]);
//初始化前后指针
int cur = left+1, prev = left;
while (cur < right)
{
if(a[cur]<a[left] )//找到比基准值小的
Swap(&a[++prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[left]);//遍历结束将基准值放在定位点
return prev;
}
注：推荐掌握，简单易于操控
4）优化
- 三数取中：
- 如果基准值取到的是待排序列中的中位数，对于快排来说效率是最优的
- 如果基准值取到的是待排序列中的最大或最小，对于快排来说效率是最差的
为了优化这种特殊情况，我们在取基准值时会采取三数取中，即堆待排序序列的开始处，末尾处和中间处位置的数据进行比较，得到排中的数据，尽量使得快速排序的效率达到理想状态O(N*logN)
- 实现代码：
int GetMidIndex(int\* a, int left, int right)//优化快排(避免特殊情况造成效率降低)
{
int mid = right + (left - right) >> 1;//获取中间下标（注意避免和溢出）
if (a[mid]>a[left])//返回中等数据的下标
{
return a[mid] < a[right] ? mid : right;
}
else//a[mid]<=a[left]
{
return a[left] < a[right] ? left : right;
}
}
整体实现代码：
//快排
void QuickSort(int\* a, int left, int right)
{
//当区间只有一个元素或没有元素时不需要排序了
if (left >= right)
return;
//遍历一趟进行交换排序
int mid=PartSort3(a, left, right);
//递归排序左右区间
QuickSort(a, left, mid - 1);
QuickSort(a, mid+1, right);
}
- 小区间优化：
当待排序数组的区间很小时，递归开辟的函数栈帧数量时很大的，很多时甚至可能造成栈溢出
为了解决这一问题，当区间小到一定程度时，我们选择使用希尔排序，小到一定程度时待排序数列已经快接近有序，而希尔排序对于接近有序数列的排序时非常高效的
- 实现代码：
//快排+局部优化
void QuickSort1(int\* a, int left, int right)
{
**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
**二、Python必备开发工具**
工具都帮大家整理好了，安装就可直接上手！
**三、最新Python学习笔记**
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
**四、Python视频合集**
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
**五、实战案例**
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
**六、面试宝典**
###### **简历模板**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化学习资料的朋友，可以戳这里无偿获取](https://bbs.csdn.net/topics/618317507)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
