【数据结构】常见排序算法——常见排序介绍、归并排序、各大排序复杂度和稳定性
文章目录
- 1.常见排序
- 2.归并排序
-
- 2.1归并排序基本思想
- 2.2归并排序的实现
- 2.3归并排序特性总结
- 3.各大排序复杂度和稳定性
1.常见排序
2.归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：
2.1归并排序基本思想
归并排序是一种基于分治思想的排序算法。它将待排序的序列分成若干个子序列，每个子序列都是有序的，然后再将这些有序的子序列合并成一个大的有序序列。具体的实现过程通常采用递归的方法。
归并排序的基本思想是先将待排序序列划分成若干个子序列，每个子序列都是有序的，然后再将这些子序列两两合并，直至最终只剩下一个有序的序列，即为排序后的序列。
归并排序的时间复杂度为O(nlogn)，具有稳定性，适用于对链表等非顺序存储的数据结构进行排序。
2.2归并排序的实现
归并排序通常使用递归来实现，实现过程可以分为两个主要步骤：
（1）分割：将待排序的序列递归地分成两个子序列，直到每个子序列中只有一个元素为止。
（2）合并：将已经有序的两个子序列合并成一个有序序列。
实现归并排序：
归并排序需要一个临时的空间来进行分割元素的合并，所有我们创建一个和原数组一样大小的临时空间tmp，为了方便空间的使用，我们建立一个归并排序函数MergeSort的子函数_MergeSort。
函数MergeSort是对_MergeSort的调用，在排序前会先申请一个临时数组tmp，然后将整个数组进行归并排序，最后释放临时数组的内存空间。
函数_MergeSort实现了归并排序的递归过程。参数a是待排序的数组，begin和end表示要排序的子数组的起始下标和结束下标，tmp是用来暂存排序结果的临时数组。函数首先将子数组分成两半，然后递归地对左右子数组进行排序，排序完成后再将两个有序子数组合并成一个有序数组。
这个过程中使用了三个指针：begin1和end1指向左子数组的起始和结束下标，begin2和end2指向右子数组的起始和结束下标，i指向存放排序结果的临时数组中的当前位置。在合并的过程中，依次比较左右子数组中的元素，将较小的元素存入临时数组中，直到任一子数组中的元素全部比较完毕， 然后将另一个子数组中的所有元素直接存入临时数组中，最后将临时数组中的元素复制回原数组的相应位置。
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);
// [begin, mid] [mid+1,end]归并
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[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = 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 fail\n");
return;
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
归并排序的非递归实现：
归并排序通过这样的循环非递归实现，可以避免递归带来的额外计算和栈空间的消耗，使归并排序更为高效。
函数MergeSortNonR需要传入一个待排序的数组a和数组的长度n作为参数。首先申请一个大小为n的临时数组tmp，用于排序过程中存储临时结果。然后，MergeSortNonR使用一个循环，每次将待排序的序列分成大小为2×gap的小数组，并将相邻的两个小数组合并成一个有序数组。
此后，将gap的大小翻倍，继续合并两个有序数组，直到合并后的数组大小为原数组大小为止。在每次合并的过程中，依次比较左右两个小数组中的元素，将较小的元素依次存到临时数组tmp中。
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
// [begin1,end1][begin2, end2]
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
int j = i;
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++];
}
// 拷贝
}
gap *= 2;
}
free(tmp);
}
2.3归并排序特性总结
（1）归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
（2）时间复杂度：O(N*logN)
（3）空间复杂度：O(N)
（4）稳定性：稳定
3.各大排序复杂度和稳定性
| 排序方法 | 平均情况 | 最好情况 | 最坏情况 | 辅助空间 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
| 简单选择排序 | O(n2) | O(n2) | O(n2) | O(1) | 不稳定 |
| 直接插入排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
| 希尔排序 | O(nlogn)~O(n2) | O(n1.3) | O(n2) | O(1) | 不稳定 |
| 堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(1) | 不稳定 |
| 归并排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(n) | 稳定 |
| 快速排序 | O(nlogn) | O(nlogn) | O(n2) | O(logn)~O(n) | 不稳定 |
这些就是数据结构中归并排序简单介绍了
如有错误❌望指正，最后祝大家学习进步✊天天开心✨