[数据结构笔记]常见排序算法
分类与性能
![[数据结构笔记]常见排序算法_第1张图片](http://img.e-com-net.com/image/info8/9fb698b48f3b4095af5e3ca92b4be847.jpg)
| 排序方法 | 平均情况 | 最好情况 | 最坏情况 | 辅助空间 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(N^2) | O(N) | O(N^2) | O(1) | 稳定 |
| 简单选择排序 | O(N^2) | O(N^2) | O(N^2) | O(1) | 不稳定 |
| 直接插入排序 | O(N^2) | O(N) | O(N^2) | O(1) | 稳定 |
| 希尔排序 | O(N*logN) ~ O(N^2) | O(N^1.3) | O(N^2) | O(1) | 不稳定 |
| 堆排序 | O(N*logN) | O(N*logN) | O(N*logN) | O(1) | 不稳定 |
| 归并排序 | O(N*logN) | O(N*logN) | O(N*logN) | O(N) | 稳定 |
| 快速排序 | O(N*logN) | O(N*logN) | O(N^2) | O(logN) ~ O(N) | 不稳定 |
代码实现
栈实现
Stack.h
#pragma once
#includeStack.c
#include"Stack.h"
void StackInit(ST* ps) {
assert(ps);
ps->arr = (STDatatype*)malloc(sizeof(STDatatype) * 4);
if (ps->arr == NULL) {
perror("malloc failed");
exit(-1);
}
ps->top = 0;//栈顶元素的下一位的下标
ps->capacity = 4;
}
void StackDestroy(ST* ps) {
assert(ps);
free(ps->arr);
ps->arr = NULL;
ps->top = ps->capacity = 0;
}
void StackPush(ST* ps, STDatatype x) {
assert(ps);
if (ps->top == ps->capacity) {
STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * ps->capacity * 2);
if (tmp == NULL) {
perror("realloc failed");
exit(-1);
}
ps->arr = tmp;
ps->capacity *= 2;
}
ps->arr[ps->top] = x;
ps->top++;
}
bool StackEmpty(ST* ps) {
assert(ps);
return ps->top == 0;//判断的结果本身就是布尔值
}
void StackPop(ST* ps) {
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
//tip:动态开辟的一段空间不能只free一部分
}
STDatatype StackTop(ST* ps) {
assert(ps);
assert(!StackEmpty(ps));
return ps->arr[ps->top - 1];//top是栈顶后一位的下标,要-1才是栈顶的下标
}
int StackSize(ST* ps) {
assert(ps);
return ps->top;//top的值即为元素数量
}
排序算法实现
Sort.h
#pragma once
#includeSort.c
#include"Sort.h"
#include"Stack.h"
void PrintArray(int* a, int n) {
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
//交换元素
void Swap(int* p1, int* p2) {
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向下调整-堆排附属
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n) {
// 确认child指向大的那个孩子
if (child + 1 < n && a[child + 1] > a[child]) {
++child;
}
// 1、孩子大于父亲，交换，继续向下调整
// 2、孩子小于父亲，则调整结束
if (a[child] > a[parent]) {
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
//三数取中，用于快排选key的优化
int GetMidIndex(int* a, int begin, int end) {
int mid = (begin + end) / 2;
if (a[begin] < a[mid]) {
if (a[mid] < a[end]) {
return mid;
}
else if (a[begin] > a[end]) {
return begin;
}
else {
return end;
}
}
else {//a[begin]>a[mid]
if (a[mid] > a[end]) {
return mid;
}
else if (a[begin] < a[end]) {
return begin;
}
else {
return end;
}
}
}
//插入排序
void InsertSort(int* a, int n) {
//向前插入排序：先令前n-1个元素有序，再将第n个向前比较然后插入
//最坏O(N^2)，逆序等差数列
//最好O(N)，接近顺序有序
for (int i = 0; i < n-1; i++) {//下标从0开始，所以结束条件不能是n
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;
}
}
//希尔排序
void ShellSort(int* a, int n) {
//希尔排序(最小增量排序)：改良的插入排序，在插排之前先进行预排序(以gap为步长分成gap组，再组内排序(普通插入排序看作gap=1))
//每组最坏情况挪动次数：(1+2+...+n/gap-1)*gap 。实际排序中只在最开始时可能有最差情况，后续每组越来越接近有序
//最好O(N)
int gap = n;
while (gap > 1){//gap>1则预排序，gap==1则直接插入排序
gap = gap / 3 + 1;//自适应gap，n越大gap越大。除3必须+1以保证gap最少为1。
for (int i = 0; i < n - gap; i++) {//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;
}
PrintArray(a, n);
}
}
//直接选择排序
void SelectSort(int* a, int n) {
//O(N^2)
//相比之下直接插入更好，因其对于有序或局部有序的情况效率更高。
//而直接选择排序任何情况下都是O(N^2)，所以直接选择排序是最差的排序方式。
int begin = 0, end = n - 1;
while (begin<end){//偶数个元素的情况会错开，而奇数个会相遇
int mini = begin, maxi = begin;
for (int i = begin + 1; i <= end; i++) {//找出最大与最小元素
if (a[i] < a[mini]) {
mini = i;
}
if (a[i] > a[maxi]) {
maxi = i;
}
}
//将最小的元素换到begin处，最大的换到end处
Swap(&a[begin], &a[mini]);
//若交换前最大元素为首元素，则第一次交换会将最大元素交换到最小元素原本的位置去
//，而此时maxi依旧“指向”begin位置。
//于是在交换最大元素前，maxi实质上“指向”的会是刚交换过来的最小元素。需要对此情况单独处理。
//(若是先交换max再交换min，则需考虑最小元素在end位置的情况)
if (maxi == begin) {
maxi = mini;//将maxi“指向”刚被交换过去的，身为最大元素的原首元素，以完成修正。
}
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
//堆排序(基于二叉树的一种选择排序)
void HeapSort(int* a, int n){
// O(N*logN)
// 向下调整建堆 -- O(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;
}
}
//冒泡排序(一种交换排序)
void BubbleSort(int* a, int n) {
//O(N^2)
for (int j = 0; j < n; j++) {
int exchange = 0;
for (int i = 1; i < n - j; i++) {
if (a[i - 1] > a[i]) {
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
if (exchange == 0) {//若一趟冒泡过程中未发生交换，则该部分已为有序，可以跳过
break;
}
}
}
}
//从Hoare的原版快排拆出的单趟排序
int PartSort1(int* a, int begin, int end) {
//优化最值位于两端之一时key的选择，使得快排几乎不会出现最坏情况，在原版基础上进行此优化后近似为O(N*logN)
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int keyi = left;
while (left < right) {
//右先走，找小的
while (left < right && a[right] >= a[keyi]) {//left=而不是>以防止死循环
right--;
}
//左先走，找大的
while (left < right && a[left] <= a[keyi]) {//left
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[keyi]);
keyi = left;
return keyi;
}
//快排-挖坑法:左边挖坑右边填，最初的坑内数据由临时变量key保存，然后右边挖坑左边填，直到二者于同一坑相遇，key内数据填入坑中
int PartSort2(int* a, int begin, int end) {
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = a[left];
int hole = left;
while (left < right) {//当左右未相遇
while (left < right && a[right] >= key) {//右边找小值
right--;
}
a[hole] = a[right];//右边找到小值后填到左侧坑内
hole = right;//右边挖新坑
while (left < right && a[left] <= key){//左边找大值
left++;
}
a[hole] = a[left];//左边找到大值后填到左侧坑内
hole = left;//左边挖新坑
}
a[hole] = key;//左右相遇后，key内数据填入最后的坑中
return hole;//返回hole就是返回本趟排序的key3
}
//快排-前后指针法
int PartSort3(int* a, int begin, int end){
int mid = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[mid]);
int keyi = begin;
int prev = begin, cur = begin + 1;
while (cur <= end){//<=而不是<,防越界
//cur找到比key小的值时停下，++prev，然后交换prev与cur位置的值。
//由此可确保prev与cur之间的值比key大，而prev与cur构成的区间本身在向后移动，如此便使得比key大的值集中在后部
if (a[cur] < a[keyi] && ++prev != cur)//++prev != cur 跳过无意义的自我交换
Swap(&a[prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[keyi]);//交换prev与key，以使得key大于前方元素而小于等于后方元素
keyi = prev;
return keyi;
}
//快速排序及其优化(基于二叉树的一种交换排序)
void QuickSort(int* a, int begin, int end) {
//原版快排单趟O(N)
if (begin >= end) {
return;//待排序元素只剩一个的情况为递归终止条件
}
//小区间优化，对于少于15个元素(未规定具体数值)的区间不再递归处理，而是直接使用插入排序
if ((end - begin + 1) < 15) {
InsertSort(a + begin, end - begin + 1);
}
else {
int keyi = PartSort3(a, begin, end);//这里将单趟排序拆分并单独作一个函数，便于比较各种单趟实现方式
//单趟排序结束，已分成三个区间: [begin,keyi-1] keyi [keyi+1,end]
//然后开始对每个区间递归地进行排序
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
}
//快排-非递归。递归层数多了总归是容易爆栈的，非递归实现比较稳妥。
//简单的递归改非递归通常使用循环代替，而复杂的经常使用栈来辅助实现
void QuickSortNonR(int* a, int begin, int end){
//用栈保存区间，动态开辟的空间位于内存的堆区，远比函数递归调用时用的栈区的空间大
ST st;
StackInit(&st);
StackPush(&st, begin);
StackPush(&st, end);
while (!StackEmpty(&st)){
int right = StackTop(&st);
StackPop(&st);
int left = StackTop(&st);
StackPop(&st);
int keyi = PartSort3(a, left, right);
//[left, keyi-1] keyi [keyi+1, right]
if (keyi + 1 < right){
StackPush(&st, keyi + 1);
StackPush(&st, right);
}
if (left < keyi - 1){
StackPush(&st, left);
StackPush(&st, keyi - 1);
}
}
StackDestroy(&st);
}
//快排的阶段性排序结果的特点是:第i趟完成时，会有i个以上的数出现在它最终将要出现的位置，即它左边的数都比它小，它右边的数都比它大
//归并排序递归用的子函数
void _MergeSort(int* a, int begin, int end, int* tmp){
//时间复杂度：O(N*logN)
//空间复杂度：O(N)
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 failed");
exit(-1);
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
tmp = NULL;
}
//归并排序-非递归实现
void MergeSortNonR(int* a, int n){
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL){
perror("malloc failed\n");
exit(-1);
}
//归并的每组数据个数。从1开始是因为单1个元素视作有序，可直接归并
int rangeN = 1;
while (rangeN < n){
for (int i = 0; i < n; 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;
// 修正区间 ->拷贝数据 归并完了整体拷贝 or 归并每组拷贝
if (end1 >= n){
end1 = n - 1;
//不存在区间
begin2 = n;
end2 = n - 1;
}
else if (begin2 >= n){
// 不存在区间
begin2 = n;
end2 = n - 1;
}
else if (end2 >= n){
end2 = n - 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) * (n));
rangeN *= 2;
}
free(tmp);
tmp = NULL;
}