[数据结构笔记]常见排序算法

分类与性能

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	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)	不稳定

代码实现

排序算法实现

Sort.h

#pragma once
#include<stdio.h>

void PrintArray(int* a, int n);

void InsertSort(int* a, int n);
void ShellSort(int* a, int n);
void SelectSort(int* a, int n);
void HeapSort(int* a, int n);
void BubbleSort(int* a, int n);
void QuickSort(int* a, int begin, int end);
int PartSort1(int* a, int begin, int end);
int PartSort2(int* a, int begin, int end);
int PartSort3(int* a, int begin, int end);
void QuickSortNonR(int* a, int begin, int end);
void MergeSort(int* a, int n);
void MergeSortNonR(int* a, int n);

Sort.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++) {//进行n趟冒泡
		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&&防止越界，>=而不是>以防止死循环
			right--;
		}
		//左先走，找大的
		while (left < right && a[left] <= a[keyi]) {//left<right&&防止越界，<=而不是<以防止死循环
			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;
}

栈结构实现

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDatatype;

typedef struct Stack {
	STDatatype* arr;
	int capacity;
	int top;//栈顶元素的下一位的下标
}ST;

void StackInit(ST* ps);//初始化
void StackDestroy(ST* ps);//销毁
void StackPush(ST* ps,STDatatype x);//入栈
void StackPop(ST* ps);//出栈

bool StackEmpty(ST* ps);//检测空
int StackSize(ST* ps);//返回元素数量
STDatatype StackTop(ST* ps);//取栈顶元素

Stack.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的值即为元素数量
}

测试代码

#include "Sort.h"

void TestInsertSort(){
	printf("InsertSort:\n");
	int a[] = { 9, 1, 2, 5, 7, 4, 8, 6, 3, 5 };
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

void TestShellSort(){
	printf("ShellSort:\n");
	//int a[] = { 9, 1, 2, 5, 7, 4, 8, 6, 3, 5 };
	int a[] = { 9,8,7,6,5,4,3,2,1,0,5,4,2,3,6,2,0,2,1,-1,-2,-1,-3 };
	PrintArray(a, sizeof(a) / sizeof(int));
	ShellSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

void TestSelectSort(){
	printf("SelectSort:\n");
	int a[] = { 9, 1, 2, 5, 7, 4, 8, 6, 3, 5 };
	SelectSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

void TestBubbleSort(){
	printf("BubbleSort:\n");
	int a[] = { 9, 1, 2, 5, 7, 4, 8, 6, 3, 5 };
	BubbleSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

void TestQuickSort(){
	printf("QuickSort:\n");
	//int a[] = { 6, 1, 6, 7, 6, 6, 4, 5, 6, 8 };
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//int a[] = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
	QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
	//QuickSortNonR(a, 0, sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

void TestMergeSort(){
	printf("MergeSort:\n");
	//int a[] = { 6,1,2,7,9,3,4,5,8,10,8 };
	int a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 6, 8 };
	//int a[] = {10,6,7,1,3,9,4,2 };
	MergeSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

int main(){
	TestInsertSort();
	TestShellSort();
	TestSelectSort();
	TestBubbleSort();
	TestQuickSort();
	TestMergeSort();

	return 0;
}

测试结果：