🌈个人主页：Yui_
🌈Linux专栏：Linux
🌈C语言笔记专栏：C语言笔记
🌈数据结构专栏：数据结构
文章目录
1. 排序的概念及其应用
1.1 排序的概念
排序：所谓排序，就是使一连串记录，按照其中的某个或者某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假如在待排序的记录序列中，存在多个具有相同关键字的记录中，如果经过排序，这些记录的相对次序保存不变，就是说在原序列中，r[i] = r[j]，且r[i]在r[j]前，然后在后序的排序后，r[i]仍在r[j]前，那么就叫这种排序是稳定的，否则就是不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存间移动数据的排序。
1.2 排序的应用场景
排序的应用场景非常广泛，任何邻域都存在竞争，只要存在竞争就会有比较，那么就有了高低之分了，比如高校排名：
1.3 常见的排序算法
插入排序
- 直接插入排序
- 希尔排序
选择排序 - 选择排序
- 堆排序序
交换排序 - 冒牌排序
- 快速排序
归并排序 - 归并排序
2.常见排序算法的实现
2.1 插入排序
2.1.1 基本思想
直接插入排序是一种简单的插入排序算法，其基本思想为：
把待排序的数据按其关键码值的大小逐个插入到一个已经排好序的有序个体中，直到所有的数据插入完为止，得到一个新的有序序列。
就像我打扑克牌一样，当我们手中的牌位3 4 5 7的时候，此时摸到了6就会把6插入5和7的中间的到3 4 5 6 7的顺子。
2.1.2 直接插入排序
当插入第i(i>=1)个数据时，前面的array[0]，array[1]，array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]，array[i-2]的排序码顺序进行比较，找到插入位置便将array[i]插入，原来位置的元素顺序后移。
#include <stdio.h>
//维持[0,end]有序
//通过比较把end+1的数据插入到[0,end]中合适的位置，来保存[0,end]的持续有序
void InsertSort(int* arr, int n)
{
for (int i = 0; i < n - 1; ++i)
{
int end = i;
int tmp = arr[end + 1];//防止end+1位置的数据丢失
while (end >= 0)
{
if (tmp < arr[end])
{
arr[end + 1] = arr[end];
end -= 1;
}
else
{
break;
}
}
arr[end+1] = tmp;
//当我们比较到最后，是tmp大于arr[end]所以tmp要在end的后面
//可不能写成arr[end] = tmp，这样写程序会崩溃的
}
}
int main()
{
int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
InsertSort(arr, 10);
for (int i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//打印结果：
/*
0 1 2 3 4 5 6 7 8 9
*/
总结：
- 元素越接近有序，直接插入排序算法时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定的排序算法
2.1.3 希尔排序
希尔排序又称缩小增量法。希尔排序法的基本思想：先选定一个数，把待排序文件中所有文件分成个组，所有距离的记录分在同一组内，并对每一组内的记录进行排序。然后，取重复上述分组和排序的工作。当到达gap = 1时，所有记录在统一组内排好序。
本质就是先进行预排序，然后在用直接插入排序。预排序的目的就是为了让数组变得更加有序，而直接插入排序的效率是和数据的有序程度挂钩的，越有序效率越高。
如此一来，代码就好写了，既然最后一次是直接插入排序的逻辑，那么也就说明了主体代码不会有太大的变化，还有因为gap是变化的，我们用一个循环来处理gap。令初始的gap为5，后序的gap = gap/2.循环的执行条件就是gap!=0；
然后因为gap会将数组分组，后续我们就要把i限制在n-gap中了。
#include <stdio.h>
void ShellSort(int* arr, int n)
{
int gap = 5;
while (gap)
{
for (int i = 0; i < n - gap; i+=1)
{
int end = i;
int tmp = arr[end + gap];
while (end >= 0)
{
if (tmp < arr[end])
{
arr[end + gap] = arr[end];
end -= gap;
}
else
{
break;
}
}
arr[end + gap] = tmp;
}
gap /= 2;
}
}
int main()
{
int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
ShellSort(arr, 10);
for (int i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//打印结果
/*
0 1 2 3 4 5 6 7 8 9
*/
关于gap的取值
gap当然不是固定的，gap的取值是根据数组大小进行变化的。目前主流的gap取值是n/3+1
后续的变化也是gap = gap/3+1
修改后的代码：
void ShellSort(int* arr, int n)
{
int gap = n;
while (gap>1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i+=1)
{
int end = i;
int tmp = arr[end + gap];
while (end >= 0)
{
if (tmp < arr[end])
{
arr[end + gap] = arr[end];
end -= gap;
}
else
{
break;
}
}
arr[end + gap] = tmp;
}
}
}
总结：
- 希尔排序是对直接插入排序的优化
- 当gap>1时都是预排序，目的是为了让数组更接近有序。当gap = 1时，数组已经接近有序了，这样直接插入排序就会很快。整体而言，可以达到优化的效果。
- 希尔排序的时间复杂度不好计算，因为gap的取值方法多样，导致很难取计算，因此许多书给出的希尔排序的时间复杂度都不固定
- 稳定性：不稳定。
下面是一些介绍希尔排序的书籍：
《数据结构（C语言版）》 — 严蔚敏
《数据结构-用面向对象方法与C++描述》 – 殷人昆
2.2 选择排序
2.2.1 基本思想
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
2.2.2 直接选择排序
- 在元素集合array[i]—array[n-1]中选择关键码最大/小的数据元素。
- 如果它不是这组数据中的最后一个元素/第一个元素，那么将它与这组元素中的最后一个/第一个元素交换
- 在剩余的array[i] --array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余一个元素。
#include <stdio.h>
void swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void slectsort(int* arr, int n)
{
for (int i = 0; i < n; ++i)
{
int _min = i;
for (int j = i; j < n; ++j)
{
if (arr[j] < arr[_min])
{
_min = j;
}
}
swap(&arr[_min], &arr[i]);
}
}
int main()
{
int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
slectsort(arr, 10);
for (int i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
总结：
- 直接选择排序思考非常好理解，但是效率不是很好，实际中很少用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
2.2.3堆排序
堆排序就是利用堆的思想进行排序，总共分为两个步骤：
建堆
- 升序：建大堆
- 降序：建小堆
利用向下调整建堆
提问：为什么向下调整可以建堆
回答：
向下调整的关键就除了要调节的地方不对，其下方都为正确的堆。
以下图为例：以10为根的左右子树，都满足小堆（堆）的性质，只有根节点不满足时，因此只需将根节点往下调，整合到合适的位置就可以了。
为了我只有由后往前向下调整就可以了，第一次要传的参数就是最后一个节点的父节点。然后依次传入前面是位置就可以了。
#include <stdio.h>
void swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
//建大堆
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 = child + 1;
}
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
int main()
{
int arr[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };//初始化一个小堆
int n = sizeof(arr) / sizeof(arr[0]);
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(arr, n, i);//通过向下调整建立大堆
}
for (int i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//打印结果：
/*
100 70 60 65 32 50 8 3 7 4 2 5 6
*/
利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整就可以完成堆排序。
提问：为什么升序需要建大堆呢？
回答：堆排序的本质是选择排序，每次都要选择一个最大的数到数组的最后一位，那么问题就变成了如何选择最大的数到数组最后一位，要找出堆中最大数就必须要用到大堆，因为大堆中最大的数就在堆堆顶，通过一次次的选择就可以将数组排序。
下面是画图解释：
#include <stdio.h>
void swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
//建大堆
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 = child + 1;
}
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
int main()
{
int arr[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };
int n = sizeof(arr) / sizeof(arr[0]);
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(arr, n, i);
}
//排序
for (int end = n - 1; end >= 0; --end)
{
swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
}
for (int i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//打印结果：
/*
2 3 4 5 6 7 8 32 50 60 65 70 100
*/
总结：
- 堆排序使用堆来选数，效率高
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
2.3 交换排序
基本思想：所谓交换，就是根据序列中的两个记录键位的比较结果来交换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
2.3.1 冒泡排序
冒泡排序的特点就是，从前到后两两比较找到最大的数放在数组的末尾。因为已经找到数组最大元素并放置在末尾，也就是说最大元素已经放置在最终的位置，我们接下来就是把末尾提前来来一次找到数组中次大的元素，以此类推将数组彻底排序。
#include <stdio.h>
void swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void bubblesort(int* a, int n)
{
for (int i = 0; i < n - 1; ++i)
{
int flag = 1;
for (int j = 0; j < n - i - 1; ++j)
{
if (a[j] > a[j + 1])
{
swap(&a[j], &a[j + 1]);
flag = 0;
}
}
if (flag)
break;
}
}
int main()
{
int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
//slectsort(arr, 10);
bubblesort(arr, 10);
for (int i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//打印结果
/*
0 1 2 3 4 5 6 7 8 9
*/
冒泡排序总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
2.3.2 快速排序
快速排序是Hoare在1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序的元素序列中的某元素作为基准，按照该排序码将待排序序集分割成两子序列，左子序列中所有元素均小于其基准值，右子序列中的所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
下面会给出快速排序递归实现的主框架，发现于二叉树前序遍历的逻辑非常像，大家在写递归框架时可以想想二叉树前序遍历的过程快速写成来。后续只需要分析如何对区间中的数据进行划分就可以了。
//假设按照升序对arr数组中的[left,right]区间中的元素进行排序
void quicksort(int* a, int left,int right)
{
if (left >= right)
return;
//按照基准值对arr数组的[left，right]区间中的元素进行划分
int mid = PartSort1(a, left, right);
//划分成功后以mid为边界形成左右两部分[left,mid-1][mid+1,right]
//递归排[left，mid-1]
quicksort(a, left, mid - 1);
//递归排[mid+1,right]
quicksort(a, mid + 1, right);
}
将区间按照基准值划分为左右部分的常见方式：
- hoare版本
通过动图我们可以发现，hoare版本的做法就是先确立一个基准值key的坐标，然后定义两个指针一左一右，左指针找大于a[key]的，右指针找小于a[key]的，找到后交换左右的数据，一直进行到左右指针相遇，相遇后就把a[key]和左右指针相遇的位置的数据交换。如此一来，就做到了把a[key]放到数组的最终位置，因为此时a[key]的左边都是小于它的数，右边都是大于它的数，不就是a[key]的最终位置嘛。
提问：为什么最终左右指针相遇时的数据一定小于a[key]?
回答：这就关系到左右指针谁先走的问题。当我排升序的时候一定要让右指针先走，右指针是找小嘛。在它们相遇前会存在两种情况：
- 左指针去与右指针相遇，因为右指针是先走的，同时右指针又是找小于a[key]的值，所以如果是左指针去与右指针相遇，此时的右指针移动指向了一个小于a[key]的值。
- 右指针去与左指针相遇，因为右指针先走，左指针就会有两种情况：还没走，指向a[key]，走过了，走过了然后于右指针交换数据，导致指向小于a[key]的数据。当右指针与左指针相遇时的数据还是小于a[key]的数据
如此一来就说明了最终左右指针相遇时的数据一定小于a[key]
//hoare版本
int PartSort1(int* a, int left, int right)
{
int key = left;
while (left < right)
{
while (right > left && a[right] >= a[key])
right -= 1;
while (right > left && a[left] <= a[key])
left += 1;
swap(&a[left], &a[right]);
}
swap(&a[left], &a[key]);
return left;
}
优化
这种情况有个致命的缺陷，当数组接近有序时效率就会退化为O(N^2)。如图所示：
为了解决这个问题，我们在选择基准值的时候可以不选择数组的第一个数字，而是选择数组中大小适中的元素。我们把这个方法叫做三数取中法。
修改后的版本：
//三数取中
int GetMidi(int* a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] > a[mid])
{
if (a[mid] > a[right])
return mid;
else
{
if (a[left] > a[right])
return right;
else
return left;
}
}
else//left<=mid
{
if (a[mid] < a[right])
return mid;
else//mid>right
{
if (a[left] > a[right])//mid>left>right
return left;
else
return right;
}
}
}
//hoare版本
int PartSort1(int* a, int left, int right)
{
int mid = GetMidi(a, left, right);
swap(&a[mid], &a[left]);
int key = left;
while (left < right)
{
while (right > left && a[right] >= a[key])
right -= 1;
while (right > left && a[left] <= a[key])
left += 1;
swap(&a[left], &a[right]);
}
swap(&a[left], &a[key]);
return left;
}
- 挖坑法
解释：先利用key保存基准值，初始让left为坑位，然后开始左右指针的遍历，让右指针先走去找小于key的值，找到后将值填入坑位，然后更新坑位为right，同理左指针是找大，找到大于key的值后，将值填入坑位，然后再更新坑位位left，直到相遇。循环结束后将基准值填入左右指针相遇位置。
//挖坑法
int PartSort2(int* a, int left, int right)
{
int mid = GetMidi(a, left, right);
swap(&a[mid], &a[left]);
int hole = left;
int key = a[left];
while (left < right)
{
while (left < right && a[right] >= key)
right -= 1;
a[hole] = a[right];
hole = right;
while (left < right && a[left] <= key)
left += 1;
a[hole] = a[left];
hole = left;
}
a[left] = key;
return left;
}
- 前后指针版本
创建两个指针，一前一后，正常情况我们一定cur指针去遍历数组每当我们指向的数据小于a[key]时，就让prev+=1，然后交换a[prev]和a[cur]的值。
//前后指针法
int PartSort3(int* a, int left, int right)
{
int mid = GetMidi(a, left, right);
swap(&a[left], &a[mid]);
int key = left;
int prev = left;
int cur = prev + 1;
while (cur<=right)
{
if (a[cur] < a[key])
{
prev += 1;
swap(&a[prev], &a[cur]);
}
cur += 1;
}
swap(&a[prev], &a[key]);
return prev;
}
2.3.2 快速排序非递归
利用迭代的方式来模仿递归，快速排序递归的本质也就是它可以拿到那些待排序的区间，那么不就说明了只要我们右那些待排序的区间就可以不再需要递归了。
为此我们只需要用一个容器来存储这些区间就可以了，在众多的数据结构中我选择利用栈来实现这个方法，如果你要用队列也可以，只是存储区间而已。那么如何获取这些区间呢？
正常情况我们只有整个数组的区间，然后我们对这个区间"排序"，拿到基准值后新的区间就又出现了，新的区间就是区间的左端到该基准值-1的位置即[left,key-1],同理另一个就是[key+1,right]。好像和递归差不多，每次就是差不多，快速排序的逻辑是不会变的，我们只把原来的递归处理改成了迭代。
将区间保存到栈中可以写一个结构体，也可以直接传，取出时也一次取两个就可以了，不影响的。
//非递归版本
void QuickSortNonR(int* a, int begin, int end)
{
stack s;
InitStack(&s);
//先入left再入right
PushStack(&s, begin);//注意传入区间的顺序与取出时相反
PushStack(&s, end);
while (!EmptyStack(&s))//只要栈不为空就继续循环
{
int right = TopStack(&s);
PopStack(&s);
int left = TopStack(&s);
PopStack(&s);
int mid = PartSort1(a, left, right);//此处调用的是hoare法，其他法都可以
if (mid + 1 < right)//保证区间的有效性
{
PushStack(&s, mid + 1);
PushStack(&s, right);
}
if (left < mid - 1)//保证区间的有效性
{
PushStack(&s, left);
PushStack(&s, mid - 1);
}
}
DestoryStack(&s);
}
快速排序的总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
2.4 归并排序
基本思想：
归并排序（MERGT-SORT）是建立在归并操作上的一种有效的排序算法，该算法是采用分治（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：
合并时的动图：
其实归并排序很简单，像分解的过程，不是和快速排序很像嘛，都是传数组和区间。不同的是，因为快速排序是确定基准值，因为基准值已经到了它排序后的最终位置，后续传区间就是基准值的左右区间，但是归并排序可不是这样的，归并排序是直接找数组的中间下标，然后将数组一分为二，这样的话也就表示了再这过程中是，中间元素是不会到达最终位置，所以我们的区间要包括中间元素。
后序关于合并的问题就更简单了，在链表期间，我们就应该写过一个合并两个有序链表的问题，这个和那题是没有本质区别的：逻辑都在两个区间中找小，找到后将较小的数据取出，然后移动找到小数据那边的指针，最后当比较完毕后，大概会有一个区间没有走完我们只要再把那个没有走完数据的区间取出即可。
void _MergeSort(int* a, int* tmp, int begin, int end)
{
//确定递归出口
if (begin >= end)
return;
int mid = (begin + end) / 2;//划分数组，将数组一分为二
//以下为分解逻辑
_MergeSort(a, tmp, begin, mid);
_MergeSort(a, tmp, mid + 1, end);
//以下为合并逻辑
int begin1 = begin,end1 = mid;
int begin2 = mid + 1, end2 = end;
int index = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
tmp[index++] = a[begin1++];
else
tmp[index++] = a[begin2++];
}
//处理剩余元素
while (begin1 <= end1)
tmp[index++] = a[begin1++];
while (begin2 <= end2)
tmp[index++] = a[begin2++];
//将临时数组存放的数据重新复制到原数组
memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);//临时数组，存放合并时的数据
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
//归并排序的核心逻辑，再封装一个函数来实现
_MergeSort(a, tmp, 0, n - 1);
}
归并排序的特性总结：
- 归并排序缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
3.排序算法复杂度及稳定性分析
1080
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
