数据结构之排序总结
文章目录
1.排序的概念及其运用
1.1.排序的概念
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
1.2.排序的运用
1.在上体育课时，将学生按照大小个进行排序。
2.在网购时，习惯将价格由低到高进行排序。
3.在填报志愿时，查看大学的排名情况。
1.3.常见的排序
2.常见排序算法的实现
注：本文所涉及的排序算法均为升序算法
2.1.插入排序
基本思想
直接插入排序是一种简单的插入排序法，基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
例如：在玩扑克牌时就用到了插入排序思想。
2.1.1.直接插入排序
1.基本思想
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。
2.直接插入排序图示
3.代码表示
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
// 单趟，将tmp插入[0,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;
}
} // 插入排序4.直接插入排序的特性总结
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定
2.1.2.希尔排序
1.基本思想
希尔排序法又称缩小增量法。它是直接插入排序的优化排序。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成若干组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取重复上述分组和排序的工作。当到达end=1时，所有记录在统一组内排好序。
2.希尔排序图示
3.代码表示
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - 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;
}
}
}
} // 希尔排序4.希尔排序的特性总结
1. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap = 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
2. 希尔排序的推导出来平均时间复杂度： O(N^1.3) - O(N^2)
3. 稳定性：不稳定
2.2.选择排序
基本思想
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
2.2.1.直接选择排序
1.基本思想
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素。
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素。
2.选择排序图示
3.代码表示
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (end > begin)
{
int mini = begin, maxi = 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]);
if (begin == maxi)
maxi = mini;
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
} // 选择排序4.直接选择排序的特性总结
1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用。
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
2.2.2.堆排序
1.基本思想
堆排序是利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。
注意：排升序建大堆，排降序建小堆。口诀：大升小降
2.升序(降序)通过向下(向上)调整算法实现
关于堆排序的向下调整算法查看博客二叉树关于堆的相关介绍。二叉树传送门
3.代码表示
void HeapSort(int* a, int n)
{
//升序建大堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
} // 堆排序4.堆排序的特性总结
1.堆排序利用堆来选数，效率高了很多。
2.时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
2.3.交换排序
基本思想
所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
2.3.1.冒泡排序
1.基本思想
将最大的数沉底或者将最小的数冒上来。
2.冒泡排序图示
3.代码表示
void BubbleSort(int* a, int n)
{
int exchange = 0;
int end = n;
while (end > 0)
{
for (int i = 0; i < end - 1; i++)
{
if (a[i] > a[i + 1])
{
Swap(&a[i], &a[i + 1]);
exchange = 1; // 冒泡排序的优化
}
}
if (exchange == 0)
break;
--end;
}
} // 冒泡排序4.冒泡排序的特性总结
1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定
2.3.2 快速排序
1.基本思想
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：
1. hoare法
2. 挖坑法
3. 前后指针法
1.1.hoare版本
1.基本思想
这是快排最原始最古老的版本。思想是：定义数组指针两端的指针分别为begin与end，若选右(左)边值做key，则begin(end)指针先走，若begin(end)指针遇到比 key 值大(小)的值则停止，与end(begin)发生交换。直到begin与end相遇为止。
注：若右端为key，begin先走；反之end先走。
2.代码表示
int PartSort1(int* a, int begin, int end)
{
// 三数取中法
int mid = GetMidIndex(a, begin, end);
Swap(&a[mid], &a[begin]);
int key = begin;
while (begin < end)
{
// end先走找小
while (begin < end && a[end] >= a[key])
--end;
// begin再走找大
while (begin < end && a[begin] <= a[key])
++begin;
Swap(&a[begin], &a[end]);
}
Swap(&a[key], &a[begin]);
return begin;
} // 快速排序hoare版本1.2.挖坑法
1.基本思想
挖坑法是网上流传最为广泛的快排思想。思想是：定义数组指针两端的指针分别为begin与end，若选右(左)边值做key，将key值“挖掉”，形成一个“坑”。之后让begin++(end–),直到begin(end)找到比key值大(小)的值。将该值“挖掉”填入刚刚的“坑”里，这时候，又会形成新的“坑”。重复此过程直到begin与end相遇(这里是一个“坑”)。此时将key值填入即可。
2.图示
3.代码表示
int PartSort2(int* a, int begin, int end)
{
// 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;
} // 快速排序挖坑法1.3.前后指针法
1.基本思想
这是代码最为简单的快排版本。思想是：定义两个指针prev(begin - 1)与cur(begin)。选取右边的值为key,若cur指针对应的值 小于 key对应的值，并且++prev与cur不相等时则prev与cur对应的值发生交换。直到cur走完整个数组为止。
2.代码表示
int PartSort3(int* a, int begin, int end)
{
int prev = begin - 1;
int cur = begin;
int key = end;
while (cur < end)
{
if (a[cur] < a[key] && ++prev != cur)
Swap(&a[prev], &a[cur]);
++cur;
}
Swap(&a[++prev], &a[key]);
return prev;
} // 快速排序前后指针法2.快排的递归实现
选取一个记录作为枢轴，经过一趟排序，将整段序列分为两个部分，其中一部分的值都小于枢轴，另一部分都大于枢轴。然后继续对这两部分继续进行排序，从而使整个序列达到有序。
代码表示：
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
if (right - left + 1 < 10)
{
InsertSort(a + left, right - left + 1);
// 小区间优化，当数组小于10时利用直接插入排序而非递归算法可以提高效率
}
else
{
int keyindex = PartSort3(a, left, right);
// [0,keyindex-1] keyindex [keyindex + 1,right]
QuickSort(a, left, keyindex - 1);
QuickSort(a, keyindex + 1, right);
}
} // 快速排序递归实现3.快速排序的优化
如上图所示，若在数组有序的情况下每次key值均最为左端(或最右段)，则需要递归n次才可以。若数组足够大时，则会出现栈溢出的情况。直接导致程序崩溃。针对上述情况，利用三数取中法进行优化。
3.1.三数取中法
选择左右中间三数，取值为中间的数作为key
代码表示
int GetMidIndex(int*a, int begin, int end)
{
int mid = begin + ((end - begin) >> 1);
if (a[begin] < a[mid])
{
if (a[mid] < a[end])
return mid;
else if (a[begin] > a[end])
return begin;
else
return end;
}
else
{
if (a[mid] > a[end])
return mid;
else if (a[begin] < a[end])
return begin;
else
return end;
}
} //三数取中法3.2.直接插入排序
利用直接插入排序可以进行小区间优化，当数组小于10时利用直接插入排序减少递归次数可以一定程度的提高效率
注：三数取中法以加入到PartSort1函数中。直接插入排序已经加入到QuickSort函数中。
4.快速排序的非递归算法
1.基本思想
递归算法主要利用栈帧来划分子区间。而非递归可以使用栈来模拟递归栈帧，因为递归本身就是一个压栈的过程。
注：由于C语言库中没有栈函数，所以必须要自己创建栈。关于栈的部分详见博客栈与队列。
1.栈与队列传送门；2.栈的实现传送门
2.代码表示
void QuickSortNonR(int* a, int left, int right)
{
Stack st;
StackInit(&st);
StackPush(&st, left);
StackPush(&st, right);
while (!StackEmpty(&st))
{
int end = StackTop(&st);
StackPop(&st);
int begin = StackTop(&st);
StackPop(&st);
int keyindex = PartSort3(a, begin, end);
// [begin, keyindex - 1] keyindex [keyindex + 1，end]
if (begin < keyindex - 1)
{
StackPush(&st, begin);
StackPush(&st, keyindex - 1);
}
if (keyindex + 1 < end)
{
StackPush(&st, keyindex + 1);
StackPush(&st, end);
}
}
StackDestory(&st);
} // 快速排序非递归实现5.快速排序的特性总结
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定
2.4.归并排序
2.4.1.归并排序
1.基本思想
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
2.归并排序图示
3.代码表示
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, begin2 = mid + 1;
int end1 = mid, 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);
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
} // 归并排序递归实现4.归并排序的特性总结
1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定
2.5.非比较排序
2.5.1.计数排序
1.基本思想
计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。
操作步骤：
1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中
2.计数排序图示
3.代码表示
void CountSort(int* a, int n)
{
int max = a[0];
int min = a[0];
for (int i = 0; i < n; i++)
{
if(a[i] > max)
max = a[i];
if(a[i] < min)
min = a[i];
}
int range = max - min + 1;
int* countA = (int*)malloc(sizeof(int)*range);
memset(countA, 0, sizeof(int)*range);
// 统计数据出现的次数
for (int i = 0; i < n; i++)
{
int j = a[i] - min;
countA[j]++;
}
// 根据次数排序写回原数组
int index = 0;
for (int i = 0; i < range; i++)
{
while (countA[i]--)
{
a[index++] = i + min;
}
}
free(countA);
} // 计数排序(适用于数字集中的小规模排序)4.计数排序的特性总结
1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定
3.各种(比较类)排序算法的比较
1.性能对比
1.1.性能测试函数
void Testop()
{
// #define N 100000 //在头文件中定义
srand((unsigned)time(NULL));
int* a1 = (int*)malloc(sizeof(int)*N);
int* a2 = (int*)malloc(sizeof(int)*N);
int* a3 = (int*)malloc(sizeof(int)*N);
int* a4 = (int*)malloc(sizeof(int)*N);
int* a5 = (int*)malloc(sizeof(int)*N);
int* a6 = (int*)malloc(sizeof(int)*N);
int* a7 = (int*)malloc(sizeof(int)*N);
int* a8 = (int*)malloc(sizeof(int)*N);
for (int i = 0; i < N; ++i)
{
a1[i] = rand(); // 无序数组
// a1[i] = i; // 有序数组
a2[i] = a1[i];
a3[i] = a1[i];
a4[i] = a1[i];
a5[i] = a1[i];
a6[i] = a1[i];
a7[i] = a1[i];
a8[i] = a1[i];
}
int begin1 = clock();
InsertSort(a1, N);
int end1 = clock();
int begin2 = clock();
ShellSort(a2, N);
int end2 = clock();
int begin3 = clock();
SelectSort(a3, N);
int end3 = clock();
int begin4 = clock();
HeapSort(a4, N);
int end4 = clock();
int begin5 = clock();
BubbleSort(a5, N);
int end5 = clock();
int begin6 = clock();
QuickSort(a6, 0, N - 1);
int end6 = clock();
int begin7 = clock();
QuickSortNonR(a7, 0, N - 1);
int end7 = clock();
int begin8 = clock();
MergeSort(a8, N);
int end8 = clock();
printf("InsertSort:%d\n", end1 - begin1);
printf("ShellSort:%d\n", end2 - begin2);
printf("SelectSort:%d\n", end3 - begin3);
printf("HeapSort:%d\n", end4 - begin4);
printf("BubbleSort:%d\n", end5 - begin5);
printf("QuickSort:%d\n", end6 - begin6);
printf("QuickSortNonR:%d\n", end7 - begin7);
printf("MergeSort:%d\n", end8 - begin8);
free(a1);free(a2);free(a3);free(a4);
free(a5);free(a6);free(a7);free(a8);
} // 测试排序的性能对比1.2.结果对比
在 release 版本(会对代码优化，减少测试时间)下对10W个数字进行数组有序与无序测试。
1.数组无序
2.数组有序
可以看出，快排(优化版)在有序与无序都有优异的表现。并且希尔/堆/归并排序也都有着不错的表现。直接插入/冒泡排序（优化版）在数组有序情况下达到了最优，超越了其他排序算法。而选择排序在有序与无序情况下都不理想。(计数排序不适用大规模排序）
2.比较类排序算法总结
2.1.思维导图
2.2.各类排序比较表
4.排序OJ练习
给定一个整数数组 nums，将该数组升序排列。OJ链接
经过测试可以通过的排序有/希尔/堆/快速/归并/计数排序。OJ代码
6629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
