常见排序算法及其实现

周微苔

已于 2023-08-09 20:33:01 修改

阅读量337

点赞数

分类专栏：数据结构文章标签：排序算法算法

于 2023-08-09 20:31:56 首次发布

本文链接：https://blog.csdn.net/m0_52025138/article/details/132168354

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. 写在前面

我相信在每一个程序员进行编程入门的过程中，当涉及到算法学习时，排序算法定首当其冲！所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。同时，排序算法在实际过程中也有着非同小可的作用，如经过排序的数据可以显著提高搜素效率、使数据更易观察和理解等；因此笔者的这篇博客，主要来记录与总结一下笔者最近对常见排序算法的学习要点以及它们的实现（C语言实现）。

主要内容如下：

2. 插入排序

2.1 直接插入排序

基本思想

将待排序的记录(数据)按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，最后得到一个新的有序序列。

插入排序思想在实际生活中的体现：扑克牌游戏

Tips: 直接插入排序算法能够进行排序的前提是，已经有一个排好序的有序序列！

动图演示

代码实现

// 插入排序
void InsertSort(int* a, int n)
{
	assert(a);
	int i = 0;
	for (i = 0; i < n - 1; i++) // 共遍历n-2填，最后一个end为序列中倒数第二个数值，倒数第一个数值用来插入
	{
		// 单趟排序
		// 将下标end+1处的值，插入到有序区间[0,end]当中
		int end = i;
		int tmp = a[end + 1]; // 记录下标end+1处的值
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];   // 后移覆盖
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

void Test1()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	InsertSort(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定
元素集合越接近有序，插入排序算法的时间效率就越高！

2.2 希尔排序

基本思想

先选定一个整数gap，把待排序文件中的所有记录分成gap组，所有记录之间距离为gap的分为一组，并对每一组内的记录进行排序；然后，减小gap的值，重复上述分组和排序的过程；当gap=1时，则所有记录已有序。

希尔排序又被称为缩小增量排序，是直接插入排序的优化！

动图演示

代码实现

// 希尔排序
void ShellSort(int* a, int n)
{
	assert(a);

	// 预排序
	int i = 0;
	int gap = n;
	while (gap > 1)
	{  
		// gap不为1，即为预排序；gap为1，即为直接插入排序，保证最后的结果是有序的
		gap = gap / 3 + 1;
		// 另一种预排序的写法
		for (i = 0; i < n - gap; i++)
		{
			// 单组预排序
			int end = i;
			int tmp = a[end + gap]; // 记录下标end+1处的值
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];   // 后移覆盖
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

void Test2()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	ShellSort(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N^1.3)
空间复杂度：O(1)
稳定性：不稳定

3. 选择排序

3.1 选择排序

基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置（末尾位置），直到全部待排序的数据元素排完。

动图演示

代码实现

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 选择排序
void SelectSort(int* a, int n)
{
	assert(a);
	// 遍历选择出最小值与最大值的下标，之后将最小值交换到序列的最左边(升序)，将最大值交换到序列的最右边(升序)
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		int i = 0;
		for (i = begin + 1; i <= end; i++)
		{
			if (a[i] < a[mini])
				mini = i;

			if (a[i] > a[maxi])
				maxi = i;
		}
		Swap(&a[begin], &a[mini]);
		if (begin == maxi)
		{
			maxi = mini;
		}
		Swap(&a[maxi], &a[end]);
		begin++;
		end--;
	}
}	

void Test4()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	SelectSort(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定
直接选择排序很好理解，但效率不高，实际中很少使用

3.2 堆排序

基本思想

堆排序是指利用堆这种数据结构所设计的一种排序算法，是选择排序的一种。它是通过堆来进行选择数据。

Tips：

排升序，建大堆
排降序，建小堆

动图演示

建堆

排序

动图来源： (堆排序_6风筝9_博客园(cnblogs.com))

代码实现

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 向下调整算法
void AdjustDown(int* a, int size, int parent)
{
	// 1. 选出左右孩子中较小的一个
	int leftchild = parent * 2 + 1;
	int rightchild = parent * 2 + 2;  // 注意：存在越界问题
	int minchild = 0;
	if (rightchild < size)  //  若右孩子节点存在
		minchild = a[leftchild] > a[rightchild] ? leftchild : rightchild;
	else
		minchild = leftchild;   // 若没有右孩子节点，minchild直接赋值为左孩子节点

	// 2. 小的孩子节点的值与父亲节点的值，进行比较；
	//    若比父亲小则交换，继续向下调整；若比父亲大，则结束

	while (minchild < size)  // 孩子节点已经不存在，无法比较则结束循环
	{
		if (a[minchild] > a[parent])
		{
			Swap(&a[minchild], &a[parent]);
			parent = minchild;
			leftchild = parent * 2 + 1;
			rightchild = parent * 2 + 2;  // 若没有右孩子节点，会产生越界问题吗？
			if (rightchild < size)
				minchild = a[leftchild] > a[rightchild] ? leftchild : rightchild;
			else
				minchild = leftchild;   // 若没有右孩子节点，minchild直接赋值为左孩子节点
		}
		else

		{
			break;
		}
	}
}

void HeapSort(int* a, int sz)
{
	assert(a);

	// 建堆
	// 方式一：从第二个节点处，开始向后进行向上调整 O(N * logN)
	//int i = 0;
	//for (i = 1; i < size; i++)
	//{
	//	AdjustUp(arr, i);
	//}

	// 方式二: 从倒数第一个非叶子节点处，开始向前进行向下调整  O(N)
	int i = 0;
	int parent = (sz - 1 - 1) / 2; // 最后一个节点的父亲节点
	for (i = parent; i >= 0; i--)
	{
		AdjustDown(a, sz, i);
	}
	/*for (i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");*/
	// 升序 - 建大堆
	// 降序 - 建小堆
	int end = sz - 1;
	while (end > 0) // O(N * logN)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);  // O(logN)
		end--;
	}
}

void Test3()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	HeapSort(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定

4. 交换排序

4.1 冒泡排序

基本思想

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置；将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

动图演示

代码实现

// 冒泡排序
void BubbleSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int j = 0;
		int exchange = 0;

		for (j = 1; j < n - 1 - i; j++)
		{
			if (a[j - 1] > a[j])
			{
				Swap(&a[j - 1], &a[j]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}


void Test5()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	BubbleSort(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

4.2 快速排序

基本思想

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右序列重复该过程，直到所有元素都排列在相应位置上为止。

动图演示

hoare版本

挖坑版

前后指针版

代码实现

hoare版本

// hoare版
int PartSort1(int* a, int begin, int end)
{
	int left = begin, right = end;
	int keyi = left;
	while (left < right)
	{
		// 右边先走，找小
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}

		// 左边后走，找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);
	return keyi;
}

void QuickSort(int* a, int begin, int end)
{
	// 当区间不存在或只剩一个数值时，结束排序
	if (begin >= end)
		return;

	if (end - begin > 10)
	{
		int keyi = PartSort1(a, begin, end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	else // 较小区间时，直接使用插入排序，进行排序，停止递归
	{
		InsertSort(a + begin, end - begin + 1);
	}
}

void Test6()
{
	int arr[] = { 9,1,2,8,7,4,5,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	QuickSort(arr, 0, sz - 1);
	//QuickSortNonR(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

挖坑版

// 坑位法
int PartSort2(int* a, int begin, int end)
{
	int key = a[begin];
	int pit = begin;
	int left = begin, right = end;
	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;
}

void QuickSort(int* a, int begin, int end)
{
	// 当区间不存在或只剩一个数值时，结束排序
	if (begin >= end)
		return;

	if (end - begin > 10)
	{
		int keyi = PartSort2(a, begin, end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	else // 较小区间时，直接使用插入排序，进行排序，停止递归
	{
		InsertSort(a + begin, end - begin + 1);
	}
}

void Test6()
{
	int arr[] = { 9,1,2,8,7,4,5,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	QuickSort(arr, 0, sz - 1);
	//QuickSortNonR(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

前后指针版

// 三位取中
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[mid] > a[end] && a[begin] < a[end])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
	else  // a[begin] >= a[mid]
	{
		if (a[begin] < a[end])
		{
			return begin;
		}
		else if (a[begin] > a[end] && a[end] > a[mid])
		{
			return end;
		}
		else
		{
			return mid;
		}
	}
}
// 前后指针版本
int PartSort3(int* a, int begin, int end)
{
	// 代码极致的简洁
	int prev = begin;
	int cur = begin + 1;
	int keyi = begin;
	// 选出数组第一个元素、中间元素、与最后一个元素中的中间值；以保证key的位置上，既不是最大值也不是最小值
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[keyi], &a[mid]);

	while (cur <= end)  // cur未越界
	{
		// cur位置的值小于key,向前交换
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		cur++;
	}

	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}

void QuickSort(int* a, int begin, int end)
{
	// 当区间不存在或只剩一个数值时，结束排序
	if (begin >= end)
		return;

	if (end - begin > 10)
	{
		int keyi = PartSort3(a, begin, end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	else // 较小区间时，直接使用插入排序，进行排序，停止递归
	{
		InsertSort(a + begin, end - begin + 1);
	}
}

void Test6()
{
	int arr[] = { 9,1,2,8,7,4,5,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	QuickSort(arr, 0, sz - 1);
	//QuickSortNonR(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

非递归版（栈模拟递归实现）

// 使用栈模拟快速排序递归
void QuickSortNonR(int* a, int left, int right)
{
	Stack 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 keyi = PartSort3(a, left, right);

		if (keyi + 1 < right)
		{
			StackPush(&st, right);
			StackPush(&st, keyi + 1);
		}

		if (left < keyi - 1)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, left);
		}
	}
	StackDestory(&st);
}


void Test6()
{
	int arr[] = { 9,1,2,8,7,4,5,6,3,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	//QuickSort(arr, 0, sz - 1);
	QuickSortNonR(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N*logN)
空间复杂度：O(logN)
稳定性：不稳定

5. 归并排序

5.1 归并排序

基本思想

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序得序列；即先使每个子序列有序，再使子序列段间有序。

动图演示

代码实现

递归版

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 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, (end - begin + 1) * sizeof(int));
}


// 归并排序递归实现
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("MergeSort::malloc");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

void Test7()
{
	int arr[] = { 9,1,3,0,11,4,5,6,2,8,10,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	MergeSort(arr, sz);
	//MergeSortNonR(arr, sz);
	PrintArray(arr, sz);
}

非递归版

// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("MergeSort::malloc");
		exit(-1);
	}

	int i = 0;
	int gap = 1;
	while (gap < n)
	{
		for (i = 0; i < n; i += 2 * gap)
		{
			// [i,i+gap-1][i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			int j = begin1;

			// 修正边界
			// end1越界
			if (end1 >= n)
			{
				//将最后的数字，也进行归并
				end1 = n - 1;
				// end1已经越界，所以[begin2,end2]区间不存在，将[begin2,end2]区间舍弃
				begin2 = n;
				end2 = n - 1;
			}

			// begin2越界
			if (begin2 >= n)
			{
				// 将[begin2,end2]区间舍弃
				begin2 = n;
				end2 = n - 1;
			}

			// end2越界
			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);
		gap *= 2;
	}
}


void Test7()
{
	int arr[] = { 9,1,3,0,11,4,5,6,2,8,10,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	PrintArray(arr, sz);
	//MergeSort(arr, sz);
	MergeSortNonR(arr, sz);
	PrintArray(arr, sz);
}

复杂度分析

时间复杂度：O(N*logN)
空间复杂度：O(N)
稳定性：稳定

6. 算法复杂度总结

排序算法	时间复杂度	空间复杂度	稳定性
直接插入排序	O(n^2)	O(1)	稳定
希尔排序	O(n^1.3)	O(1)	不稳定
选择排序	O(n^2)	O(1)	不稳定
堆排序	*O(nlogn)**	O(1)	不稳定
冒泡排序	O(n^2)	O(1)	稳定
快速排序	*O(nlogn)**	O(logn)~O(n)	不稳定
归并排序	*O(nlogn)**	O(n)	稳定