📟作者主页：慢热的陕西人
🌴专栏链接：数据结构
📣欢迎各位大佬👍点赞🔥关注🚓收藏，🍉留言
本博客讲解八大排序，及其优化
文章目录
- 排序
- Ⅰ插入排序：
- Ⅱ希尔排序：
- Ⅲ选择排序：
- ①直接选择排序：
- 优化：
- ②堆排序：
- Ⅳ交换排序：
- ①冒泡排序：
- ②快速排序：
- （1）hoare 法：
- 优化：
- ①对于取key的优化：
- ②对于小区间的优化：
- ③对于具有较多相同值的优化：
- （2）挖坑法
- （3）前后指针法：
- （4）非递归方法：
- Ⅴ归并排序：
- （1）递归：
- （2）非递归：
- Ⅵ基数排序：
- 1.1基数排序原理图：
- 1.2代码实现:
排序
Ⅰ插入排序：
复杂度分析：
时间复杂度O(N^2);
空间复杂度O(N);
算法思路：
原理就是通过构建有序序列，对于未排序的序列，在有序数组中进行扫描在合适的位置插入未排序的数字；
代码：
//插入排序
void InsertSort(int* a, int size)
{
for (int i = 0; i < size - 1; i++)
{
int end = i;
int temp = a[end + 1];
while (end >= 0)
{
//升序
if (temp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = temp;
}
}
Ⅱ希尔排序：
复杂度分析：
时间复杂度O(N^1.3);
空间复杂度O(N);
算法思路：
首先希尔排序的本质就是在插入排序的基础上进行多次的预排序；
预排序：就是将原本数组中的数据用一个变化的间距gap分割成多个组然后对每个组进行插入排序；
关于gap:
gap开始的大小越大，所获得的效益越大，因为可以让小的数据快速的交换到数组的前面，大的数据快速的交换到数组的后面；
gap之后慢慢变小，这时候交换的效率就慢慢降低，但是数组就会越接近有序；
排序的过程如下：
代码：
//希尔排序
void ShellSort(int* a, int size)
{
int gap = size;
while (gap > 1)
{
gap = gap /= 2;
for (int i = 0; i < size - gap; i++)
{
int end = i;
int temp = a[end + gap];
while (end >= 0)
{
//升序
if (temp < a[end])
{
a[end + gap] = a[end];
end-= gap;
}
else
{
break;
}
}
a[end + gap] = temp;
}
}
}
Ⅲ选择排序：
复杂度分析：
时间复杂度O(N^2);
空间复杂度O(N);
①直接选择排序：
算法思路：
假设从小到大排列：
那么就遍历数组找到最小的元素和第一个元素交换，接着在剩下的数字中进行这种选择，然后交换。直到遍历到最后一个数字。最终就会得到一个有序数组。
算法演示：
代码：
int[] arr = { 3, 7, 6, 2, 4, 1, 8, 9, 5 };
int n = 9;
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
if(arr[i] < arr[j])
{
int cmp = arr[j];
arr[j] = arr[i];
arr[i] = cmp;
}
}
}
优化：
默认升序的情况，循环内部可以每次同时找到最大值和最小值的下标。然后将最小值放到数组头，最大值放到数组尾；
代码：
//选择排序
void SelectSort(int* a, int size)
{
int begin = 0;
int end = size - 1;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = begin + 1; i <= end; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
Swap(&a[begin] , &a[mini]);
//排除max在begin位置的情况
if (maxi == begin)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
②堆排序：
复杂度分析：
时间复杂度近似O(N*log N);
空间复杂度O(N);
算法思路：利用堆这种数据结构来进行排序(用堆来选择数据)。
需要注意的是，升序建大堆，降序建立小堆;
以升序为例：
①首先建大堆(从最后一个父节点开始向下调整，直到根节点)；
②然后每次将根节点位置的数据(也就是当前的最大数据)和堆尾的数据交换，然后再对剩下的数据进行向下调整；
代码：
//向下调整 O(N)
void AdjustDown(int* a, int size, int parent)
{
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && a[child + 1] < a[child])
{
child++;
}
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//堆排序
void HeapSort(int* a, int size)
{
//升序：大堆
for (int i = (size - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, size, i);
}
int end = size - 1;
while (end > 0)
{
Swap(&a[end], &a[0]);
AdjustDown(a, end, 0);
--end;
}
}
Ⅳ交换排序：
①冒泡排序：
复杂度分析：
时间复杂度O(N^2);
空间复杂度O(N);
算法思路：
从前往后多次遍历数组，将相邻的两个元素如果不符合预期的要求就进行交换。
首先要调用两次循环外层循环控制的是整个循环要遍历数组的趟数
内部循环主要的作用是为了将每次将相邻的两个不符合预期要求的两个数字调换位置。
代码：
//冒泡排序
void BubbleSort(int* a, int size)
{
for (int i = 0; i < size; i++)
{
int flag = 0;
for (int j = 1; j < size - i; j++)
{
if (a[j - 1] > a[j])
{
Swap(&a[j - 1], &a[j]);
flag = 1;
}
}
//如果一轮冒泡没有交换数据的话，那么就表示已经有序了
if (flag == 0)
{
break;
}
}
}
②快速排序：
复杂度分析：
时间复杂度O(N*log N);
空间复杂度O(log N);
（1）hoare 法：
复杂度分析：
时间复杂度近似：O(N*log N);
空间复杂度O(N);
算法思路：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
代码：
//快速排序
void QuickSort(int* a, int begin, int end)
{
//如果区间不存在就直接返回
if (begin >= end)
{
return;
}
int left = begin, right = end;
int keyi = left;
while (left < right)
{
//右边先走，找小
while (left < right && a[right] >= a[keyi])
{
right--;
}
//左边找大
while (left < right && a[left] <= a[keyi])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[keyi]);
keyi = left;
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
优化：
①对于取key的优化：
首先我们分析当数组为乱序的时候我们这时候选择首元素为key值可以接近于最优的情况或者接近最优的情况；
这时候函数递归的深度大约是log N；
但是当数据接近有序或者有序，那么我们在选择key值的时候只选择首元素为key值的话。这时候就会导致key值排好后的位置恰好在数组头或者尾部的情况，那么就会导致递归深度的大大增加，导致栈溢出，而且时间复杂度也会上升到O(N^2)的情况。
那么这时候我们就可以写一个函数来选key值：
这个函数的原理就是在begin，end和mid这三个位置来选择一个中间值作为key值；
代码：
//三数选择
int GetMidIndex(int* a, int begin, int end)
{
int mid = (begin + end) >> 1;
if (a[begin] < a[mid])
{
if (a[mid] < a[end])
{
return mid;
}
else if (a[begin] > a[end])
{
return begin;
}
else//a[begin] < a[end] && a[end] < a[mid]
{
return end;
}
}
else//a[begin] > a[mid]
{
if (a[mid] > a[end])
{
return mid;
}
else if (a[end] > a[begin])
{
return begin;
}
else
{
return end;
}
}
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
//如果区间不存在就直接返回
if (begin >= end)
{
return;
}
int mid = GetMidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int left = begin, right = end;
int keyi = left;
while (left < right)
{
//右边先走，找小
while (left < right && a[right] >= a[keyi])
{
right--;
}
//左边找大
while (left < right && a[left] <= a[keyi])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[keyi]);
keyi = left;
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
②对于小区间的优化：
所谓小区间就是区间内含有的数据量比较少的时候，这时候我们如果还是老老实实的还是调用递归的话，那么我们所需要的栈空间的成本就很大，如下图所示小区间的调用递归接近整个的一半以上：
所以我们可以采取一种优化方式就是在小区间的情况下，采用插入排序来代替原有的递归，以达到优化的目的；
代码：
//插入排序
void InsertSort(int* a, int size)
{
for (int i = 0; i < size - 1; i++)
{
int end = i;
int temp = a[end + 1];
while (end >= 0)
{
//升序
if (temp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = temp;
}
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
//如果区间不存在就直接返回
if (begin >= end)
{
return;
}
//如果是小区的话那么我们就采用插入排序的方法；
if ((end - begin) < 15)
{
InsertSort(a, end - begin);
}
int mid = GetMidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int left = begin, right = end;
int keyi = left;
while (left < right)
{
//右边先走，找小
while (left < right && a[right] >= a[keyi])
{
right--;
}
//左边找大
while (left < right && a[left] <= a[keyi])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[keyi]);
keyi = left;
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
③对于具有较多相同值的优化：
算法原理：
采用三路划分的思想：
①跟key相等的值放在中间；
②比key小的值放到左边；
③比key大的值放在右边；
代码：
//快速排序
void QuickSort(int* a, int begin, int end)
{
//三路划分
if (begin >= end)
{
return;
}
{
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = a[left];
int cur = begin + 1;
while (cur <= right)
{
if (a[cur] < key)
{
Swap(&a[cur], &a[left]);
cur++;
left++;
}
else if (a[cur] > key)
{
Swap(&a[cur], &a[right]);
--right;
}
else // a[cur] == key
{
cur++;
}
}
// [begin, left-1][left, right][right+1,end]
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}
}
（2）挖坑法
相较于 hoare 法是多了一个坑位的办法，将key值存储在一个变量里，更加容易的理解。
算法原理：
①先将第一个数据存储到临时变量中，这样就第一个位置也就是left的位置就形成了一个坑位；
②然后先让right指针寻找小于key的值，找到之后就和right交换，交换完之后right的位置就是新的坑位的位置；
③让left指针寻找大于key的值，找到之后就和right交换，那么left的位置就形成了一个新的坑位；
然后递归上面的过程；
代码：
//三路划分
if (begin >= end)
{
return;
}
{
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = a[left];
int cur = begin + 1;
while (cur <= right)
{
if (a[cur] < key)
{
Swap(&a[cur], &a[left]);
cur++;
left++;
}
else if (a[cur] > key)
{
Swap(&a[cur], &a[right]);
--right;
}
else // a[cur] == key
{
cur++;
}
}
// [begin, left-1][left, right][right+1,end]
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}
}
（3）前后指针法：
算法原理：
定义两个指针prev和cur指针；
①cur指针找比key小的，找到后停下来；
②prev++,交换prev和cur的值；
prev的位置就是key的位置
最后交换prev和key(begin)的数据即可；
代码：
//三路划分
if (begin >= end)
{
return;
}
{
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = a[left];
int cur = begin + 1;
while (cur <= right)
{
if (a[cur] < key)
{
Swap(&a[cur], &a[left]);
cur++;
left++;
}
else if (a[cur] > key)
{
Swap(&a[cur], &a[right]);
--right;
}
else // a[cur] == key
{
cur++;
}
}
// [begin, left-1][left, right][right+1,end]
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}
}
（4）非递归方法：
利用栈来模拟实现函数递归的效果
算法原理：
①首先将begin和end入栈；
②进入循环每次先去到栈顶的前两个数据分别对应right和left(顺序很重要)；
③随便选一种方法（hoare，挖坑法，前后指针法）进行排序；
④排完序后将两个区间入栈(需要注意顺序，详细看代码)；
重复循环以上②③④步骤；
代码：
//快速排序
void QuickSort(int* a, int begin, int end)
{
如果区间不存在就直接返回
//if (begin >= end)
//{
// return;
//}
如果是小区的话那么我们就采用插入排序的方法；
//if ((end - begin + 1) < 15)
//{
// InsertSort(a + begin, end - begin + 1);
//}
// int keyi = PartSort3(a, begin, end);
//
// QuickSort(a, begin, keyi - 1);
// QuickSort(a, keyi + 1, end);
//三路划分
if (begin >= end)
{
return;
}
{
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = a[left];
int cur = begin + 1;
while (cur <= right)
{
if (a[cur] < key)
{
Swap(&a[cur], &a[left]);
cur++;
left++;
}
else if (a[cur] > key)
{
Swap(&a[cur], &a[right]);
--right;
}
else // a[cur] == key
{
cur++;
}
}
// [begin, left-1][left, right][right+1,end]
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}
}
Ⅴ归并排序：
（1）递归：
时间复杂度分析：
时间复杂度：O(N * log N)
空间复杂度：O(N)
算法原理(如下图所示)：
①将原数组进行分解，分解到不能分解为止
②然后开始合并，合并的时候按照合并两个有序数组的思路来合并；
代码：
//归并排序
void _MergeSort(int* a, int begin, int end, int* tmp)
{
//递归的截止条件
if (begin >= end)
{
return;
}
int mid = (begin + end) / 2;
//分成两个区间开始递归[begin, mid]/[mid+1, end];
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid + 1, end, tmp);
//归并
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] > a[begin2])
{
tmp[i++] = a[begin2++];
}
else
{
tmp[i++] = a[begin1++];
}
}
//迁移剩下的部分
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end1)
{
tmp[i++] = a[begin2++];
}
//转移数据
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int size)
{
int* tmp = (int*)malloc((size) * sizeof(int));
if (tmp == NULL)
{
perror("malloc failed");
exit(-1);
}
_MergeSort(a, 0, size - 1, tmp);
}
（2）非递归：
利用循环的方式来非递归实现
算法原理：
定义一个变量 rangeN 来记录间距的问题， 定义一个tmp数组用来存储每次归并的结果；
rangeN从1开始每次*2来时归并的过程；
最后归并结束后将tmp中的存储的数据全部拷贝到原数组中
如下图的方法来实现用 rangeN 来分割数组：
越界问题：
当我们不对边界做判断处理的时候就容易出现越界的情况，导致排序的结果中有随机值的情况；
观察可知：
①begin1不可能越界；
②end1， begin2，end2 越界；
解决方案：
end1修正为当前区间的结尾；
将begin2 和 end2的置成不存在区间
③begin2， end2 越界；
解决方案：
将begin2 和 end2的置成不存在区间
④end2 越界；
解决方案：
将end2修正为第二个小区间的结尾
代码：
void MergeSortS(int* a, int size)
{
int* tmp = (int*)malloc(sizeof(int) * size);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
// 归并每组数据个数，从1开始，因为1个认为是有序的，可以直接归并
int rangeN = 1;
while (rangeN < size)
{
for (int i = 0; i < size; i += 2 * rangeN)
{
// [begin1,end1][begin2,end2] 归并
int begin1 = i, end1 = i + rangeN - 1;
int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
int j = i;
// end1 begin2 end2 越界
// 修正区间 ->拷贝数据 归并完了整体拷贝 or 归并每组拷贝
if (end1 >= size)
{
end1 = size - 1;
// 不存在区间
begin2 = size;
end2 = size - 1;
}
else if (begin2 >= size)
{
// 不存在区间
begin2 = size;
end2 = size - 1;
}
else if (end2 >= size)
{
end2 = size - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
}
// 也可以整体归并完了再拷贝
memcpy(a, tmp, sizeof(int) * (size));
rangeN *= 2;
}
free(tmp);
tmp = NULL;
}
Ⅵ基数排序：
1.1基数排序原理图：
1.2代码实现:
#define _CRT_SECURE_NO_WARNINGS 1
#include"RadSort.h"
Queue q0;
Queue q1;
Queue q2;
Queue q3;
Queue q4;
Queue q5;
Queue q6;
Queue q7;
Queue q8;
Queue q9;
//初始化
void Init()
{
QueueInit(&q0);
QueueInit(&q1);
QueueInit(&q2);
QueueInit(&q3);
QueueInit(&q4);
QueueInit(&q5);
QueueInit(&q6);
QueueInit(&q7);
QueueInit(&q8);
QueueInit(&q9);
}
Queue* q[10] = { &q0,&q1,&q2,&q3,&q4,&q5,&q6,&q7,&q8,&q9 };
//获取key
int GetKey(int value, int k)
{
int key = 0;
while (k >= 0)
{
key = value % 10;
value /= 10;
k--;
}
return key;
}
//放数据
void PushNum(int arr[], int left, int right, int k)
{
for (int i = left; i < right; i++)
{
int key = GetKey(arr[i], k);
QueuePush(q[key], arr[i]);
}
}
//回收数据
void CollectNum(int arr[])
{
int j = 0;
for (int i = 0; i < 10; i++)
{
while (!QueueEmpty(q[i]))
{
arr[j++] = QueueFront(q[i]);
QueuePop(q[i]);
}
}
}
//打印数组
void Print(int arr[], int size)
{
for (int i = 0; i < size; i++)
{
printf("%d ", arr[i]);
}
}
//基数排序
void RadSort(int arr[], int left, int right, int k)
{
Init();
for (int i = 0; i < k; i++)
{
//放数据
PushNum(arr, left, right, i);
//回收数据
CollectNum(arr);
}
//打印结果
Print(arr, right);
}
到这本篇博客的内容就到此结束了。
如果觉得本篇博客内容对你有所帮助的话，可以点赞，收藏，顺便关注一下！
如果文章内容有错误，欢迎在评论区指正
![[Java] 如何理解和设置ThreadPoolExecutor三大核心属性？什么情况下工作线程数会突破核心线程数？任务拒绝策略都有哪些？](https://img-blog.csdnimg.cn/1eafac10fced4f5b9ed42940c1c63f1f.png)
