文章目录
1. 前言
生活中几乎处处都会用到排序,比如:网购时的店铺顺序,学生成绩的排名等,今天我们就来学习数据结构中常见的几种排序算法。
2. 排序
2.1 概念
2.2 常见的排序算法
下面我就为大家介绍这些排序算法的特点及如何实现。
3. 常见排序算法的实现
3.1 直接插入排序
代码实现:
void InsertSort(int* a, int n)
{
int i = 0;
for (i = 0; i < n - 1; i++)
{
//[0,end]有序,把end+1的位置插入,并保持有序
int end = i;
int tmp = a[end + 1];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
3.2 希尔排序
代码实现:
void ShellSort(int* a, int n)
{
//gap > 1时是预排序
//gap 最后一次等于1,是直接插入排序
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
int i = 0;
for (i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
3.3 直接选择排序
我们对直接选择排序进行一点优化,让这个算法每次分别选出一个最大的数和一个最小的数,这样可以两边同时进行排序,减少程序执行的时间。
代码实现:
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = begin; i < end; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
Swap(&a[begin], &a[mini]);
//如果begin和maxi重叠,那么要修正一下maxi的位置
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
3.4 堆排序
代码实现:
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustUp(int* arr, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void AdjustDown(int* arr, int size, int parent)
{
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && arr[child + 1] < arr[child])
{
child = child + 1;
}
if (arr[child] < arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* arr, int size)
{
//排升序建大堆,排降序建小堆
//向上调整建堆O(N*logN)
//int i = 0;
//for (i = 1; i < size; i++)
//{
// AdjustUp(arr, i);
//}
//向下调整建堆O(N)
int i = 0;
for (i = (size - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, size, i);
}
int end = size - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
end--;
}
}
3.5 冒泡排序
代码实现:
void BubbleSort(int* a, int n)
{
for (int j = 0; j < n - 1; j++)
{
int flag = 0;
for (int i = 0; i < n - j; i++)
{
if (a[i] > a[i + 1] && i+1 < n)
{
Swap(&a[i], &a[i + 1]);
flag = 1;
}
}
if (flag == 0)
{
return;
}
}
}
3.6 快速排序
而问题就是如何将一个待排序序列按key分割成两个满足要求的子序列,下面我们来介绍三种最常见的方式。
3.6.1 hoare版本
代码实现:
//hoare版本
int PartSort1(int* a, int left, int right)
{
int begin = left;
int end = right;
int key = left;
while (left < right)
{
//右边先走,找小
while (left < right && a[right] >= a[key])
{
right--;
}
//左边再走,找大
while (left < right && a[left] <= a[key])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[key], &a[left]);
key = left;
return key;
}
3.6.2 挖坑法
代码实现:
//挖坑法
int PartSort2(int* a, int left, int right)
{
int begin = left;
int end = right;
int key = a[begin];
int pit = begin;
while (left < right)
{
//右边先走,找小,填到左边的坑里面去。这个位置形成新的坑
while (left < right && a[right] >= key)
{
right--;
}
a[pit] = a[right];
pit = right;
//左边再走,找大,填到右边的坑里面去。这个位置形成新的坑
while (left < right && a[left] <= key)
{
left++;
}
a[pit] = a[left];
pit = left;
}
a[pit] = key;
return pit;
}
3.6.3 前后指针法
代码实现:
//前后指针法
int PartSort3(int* a, int left, int right)
{
int key = left;
int prev = left;
int cur = left + 1;
while (cur <= right)
{
if (a[cur] < a[key])
{
prev++;
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[key], &a[prev]);
key = prev;
return key;
}
3.6.4 快速排序的优化
3.6.4.1 三数取中法
代码实现:
int GetMid(int* a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] < a[mid])
{
if (a[right] > a[mid])
{
return mid;
}
else if (a[right] < a[left])
{
return left;
}
else
{
return right;
}
}
else //a[left] >= a[mid]
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[right] > a[left])
{
return left;
}
else
{
return right;
}
}
}
3.6.4.2 小区间简化法
3.7 快速排序最优版
最终版快速排序代码如下:
//前后指针法
int PartSort3(int* a, int left, int right)
{
int key = left;
int prev = left;
int cur = left + 1;
//三数取中法优化
int mid = GetMid(a, left, right);
Swap(&a[key], &a[mid]);
while (cur <= right)
{
if (a[cur] < a[key])
{
prev++;
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[key], &a[prev]);
key = prev;
return key;
}
void QuickSort(int* a, int left, int right)
{
//区间不存在,或者只有一个值则不需要在处理
if (left >= right)
{
return;
}
if (right - left > 10)
{
//int key = PartSort1(a, left, right);
//int key = PartSort2(a, left, right);
int key = PartSort3(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1, right);
}
else
{
//递归到小区间的时候,用插入排序
InsertSort(a + left, right - left + 1);
}
}
3.8 快速排序非递归实现
代码如下:
void QuickSortNonR(int* a, int left, int right)
{
ST st;
StackInit(&st);
StackPush(&st, right);
StackPush(&st, left);
while (!StackEmpty(&st))
{
int left = StackTop(&st);
StackPop(&st);
int right = StackTop(&st);
StackPop(&st);
int key = PartSort3(a, left, right);
if (key + 1 < right)
{
StackPush(&st, right);
StackPush(&st, key + 1);
}
if (left < key - 1)
{
StackPush(&st, key - 1);
StackPush(&st, left);
}
}
StackDestroy(&st);
}
3.9 归并排序
代码实现:
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;
int end1 = mid;
int begin2 = mid + 1;
int end2 = end;
int i = begin1;
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)
{
assert(a);
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
3.10 归并排序非递归实现
代码实现:
void MergeSortNonR(int* a, int n)
{
assert(a);
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2*gap)
{
int begin1 = i;
int end1 = i + gap - 1;
int begin2 = i + gap;
int end2 = i + 2 * gap - 1;
//越界-修正边界
if (end1 >= n)
{
end1 = n - 1;
//[begin2, end2]修正为不存在区间
begin2 = n;
end2 = n - 1;
}
else if (begin2 >= n)
{
//[begin2, end2]修正为不存在区间
begin2 = n;
end2 = n - 1;
}
else if (end2 >= n)
{
end2 = n - 1;
}
int j = begin1;
int m = end2 - begin1 + 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 + i, tmp + i, sizeof(int) * m);
}
gap *= 2;
}
free(tmp);
}
4. 排序算法复杂度及稳定性分析
排序方法 | 平均情况 | 最好情况 | 最坏情况 | 辅助空间 | 稳定性 |
---|---|---|---|---|---|
直接插入排序 | O(N^2) | O(N) | O(N^2) | O(1) | 稳定 |
希尔排序 | O(NlogN)~O(N^2) | O(N^1.3) | O(N^2) | O(1) | 不稳定 |
直接选择排序 | O(N^2) | O(N^2) | O(N^2) | O(1) | 不稳定 |
堆排序 | O(NlogN) | O(NlogN) | O(NlogN) | O(1) | 不稳定 |
冒泡排序 | O(N^2) | O(N) | O(N^2) | O(1) | 稳定 |
快速排序 | O(NlogN) | O(NlogN) | O(N^2) | O(logN)~O(N) | 不稳定 |
归并排序 | O(NlogN) | O(NlogN) | O(NlogN) | O(N) | 稳定 |
5. 结尾
关于数据结构中常见的排序算法我就给大家介绍到这里了,要想学会排序算法最重要的是掌握每种排序的思想,熟悉每一种算法的特点、复杂度和稳定性,在不同的场景选择最合适的排序算法。文中难免有很多地方出现错误和纰漏,此文仅供大家学习和参考。如果本文对大家学习排序算法有帮助的话,博主感到非常荣幸。
最后,感谢各位大佬的耐心阅读和支持,觉得本篇文章写的不错的朋友可以三连关注支持一波,如果有什么问题或者本文有错误的地方大家可以私信我,也可以在评论区留言讨论,再次感谢各位。