八大排序（下）

📋 个人简介

• 💖 作者简介：大家好，我是菀枯😜

• 🎉 支持我：点赞👍+收藏⭐️+留言📝

• 💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️

  

前言

😄上一次我们聊到了：冒泡排序，选择排序，希尔排序，插入排序。那么今天呢，我们聊聊剩下的四种排序算法：堆排序，快速排序，归并排序，计数排序。

堆排序

什么是堆排序

⭐️堆排序是一种特殊的选择排序，只不过它不再像简单选择排序一样，通过遍历数组来找到其中的最小值（最大值），而是通过堆这个特殊的数据结构来帮助我们选择。不知道堆是什么的朋友可以去看看这篇文章：⭐️C语言实现堆⭐️

⭐️接下来我们用一个动图来看看选择排序的过程：

1. 首先我们把一个无序数组建成堆

   

2. 取出根节点放到数组的尾部。

   

3. 然后将最后一个元素放到根的位置。

   

4. 进行调整使它重新变成堆，然后重复上述步骤

堆排序基本思想

⭐️堆排序是一种特殊的选择排序，它适用堆这种数据结构来帮助我们更快的选择到我们需要的数据，然后来进行排序。

⭐️时间复杂度：$O(nlogn)$

C语言实现堆排序

void AdjustDown(int* a, int size, int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			int tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int size)
{
	for (int i = (size - 2) / 2; i >= 0; i--)  // (1)
	{
		AdjustDown(a, size, i);
	}

	for (int i = size - 1; i > 0; i--)        //  (2)
	{
		int tmp = a[0];
		a[0] = a[i];
		a[i] = tmp;
		AdjustDown(a, i, 0);
	}
}

1. 使排序数组变成堆。
2. 取出根元素置于原数组末尾，然后重新建堆。

快速排序

什么是快速排序

🍀快速排序，听名字就知道它比较快。快速排序其实是我们之前讲到的冒泡排序的一种变形。它采用了分治的思想，使得时间复杂度大大减少。

🍀接下来让我们用一个动画来看看快速排序的过程：

1. 选择一个比较对象*(动画黄色的柱子)*
2. 然后遍历整个数组，将小于比较对象的元素*(动画中绿色的柱子)放到左边，将大于比较对象的元素(动画中紫色的柱子)*放到右边。
3. 这样数组就被划分成了两个区间，然后分别对两个区间进行同样的操作即可
4. 当左区间和右区间都只有一个元素时，排序完成。

快速排序基本思想

🍀通过一趟排序将数据分割成对立的两部分，其中一部分的数据都小于另一部分。则可分别对这两部分进行排序，以达到整个数组有序。

🍀时间复杂度：一般情况下：$O(nlogn)$。最坏情况：$O(n^2)$

C语言实现快速排序*(递归版)*

void QuickSort(int* a, int left, int right)
{
	if (left >= right)                            //(1)
	{
		return;
	}
	int pivot = a[left];                          //(2)
	int i = left - 1, j = right + 1;
	while (i < j)                                 //(3)
	{
		do
		{
			i++;
		} while (a[i] < pivot);
		do
		{
			j--;
		} while (a[j] > pivot);
		if (i < j)
		{
			int tmp = a[i];
			a[i] = a[j];
			a[j] = tmp;
		}
	}
	QuickSort(a, left, j);                       //(4)
	QuickSort(a, j + 1, right);                  //(5)
}

1. 如果区间小于等于一个元素，则排序完成
2. 选择比较对象
3. 遍历整个区间，找到大于比较对象和小于比较对象的元素，进行交换
4. 递归排序左区间
5. 递归排序右区间

C语言实现快速排序(非递归版)

🍀可能有的小伙伴会很疑惑，我们已经写了一个递归版本的快速排序了，那么为什么还需要非递归的呢❓❓❓

这是因为：递归是在内存上的栈区进行的，而栈区是一个相对比较小的区域，而当我们的数据比较多的时候。栈可能会因为大小不够，而导致程序错误，所以我们需要一个非递归的版本来处理数据比较多的情况。

那么该如何实现呢？？？？

我们先来看看 递归的原理 来理一理，它是怎么是实现排序的

通过上面的动画，我相信各位小伙伴已经理解了递归的过程，那么要实现非递归呢，就要用到我们之前写过的一个数据结构 栈 (不知道的小伙伴可以看看我的这篇文章 ⭐️C语言实现栈⭐️

void QuickSortNone(int* a, int left, int right)
{
	Stack St;                                     //(1)
	StackInti(&St);
	StackPush(&St, left);
	StackPush(&St, right);                        
	while (!StackEmpty(&St))
	{
		int begin, end;
		end = StackTop(&St);
		StackPop(&St);
		begin = StackTop(&St);
		StackPop(&St);                           //(2)
		int pivot = PartSort(a, begin, end);     //(3)
		if (begin >= end)
		{
			continue;
		}
		StackPush(&St, begin);                  //(4)
		StackPush(&St, pivot - 1);
		StackPush(&St, pivot + 1);
		StackPush(&St, end);
	}
	StackDestory(&St);
}

1. 初始化栈，将左端点和右端点入栈。
2. 取出待调整的区间的左右端点。
3. 对此区间作进行调整。
4. 将处理完后的左半边和右半边入栈进行调整。

区间调整的代码如下：

int PartSort(int* a, int left, int right) //交换法
{
	int pivot = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[pivot])
		{
			right--;
		}
		while (left < right && a[left] <= a[pivot])
		{
			left++;
		}
		if (left < right)                                //找到交换位置交换
		{
			Swap(&a[left], &a[right]);
		}
	}
	Swap(&a[pivot], &a[left]);
	return left;
}

归并排序

什么是归并排序

☀️“归并”的含义是将两个或两个以上的有序表合成一个新的有序表。

☀️接下来让我们用一个动画来看看归并排序的过程：

1. 将数组均等的分成左右两个区间，直到成不可再分的部分。

   

2. 然后进行归并

   

   ☀️动图演示：☀️

归并排序基本思想

☀️也是用到了分治的思想，为了可以归并，我们就要保证左右子区间有序。那么为了保证左右子区间有序，我们就要保证子区间的左右子区间有序…这样套娃下去，直到区间不可再分割我们就可以开始归并了

☀️时间复杂度：$O(nlogn)$

C语言实现归并排序

#define N 1000
int tmp[N];                                     //用来存放数据的临时数组
void MergeSort(int* a, int left, int right)
{
	if (left >= right)                         //(1)
	{
		return;
	}
	int mid = (left + right) / 2;
	MergeSort(a, left, mid);                  //(2)
	MergeSort(a, mid + 1, right);             
	int i = left, j = mid + 1;
	int count = 0;
	while (i <= mid && j <= right)            //(3)
	{
		if (a[i] <= a[j])
		{
			tmp[count++] = a[i++];
		}
		else
		{
			tmp[count++] = a[j++];
		}
	}
	while (i <= mid)                        //(4)
	{
		tmp[count++] = a[i++];
	}
	while (j <= right)
	{
		tmp[count++] = a[j++];
	}

	for (int i = left, j = 0; i <= right; i++, j++) //(5)
	{
		a[i] = tmp[j];
	}
}

1. 如果区间已经无法再分割，那就返回。
2. 让左右区间有序。
3. 取左右区间较小的值，放在临时数组中
4. 确保左右区间的所有元素，已经被存放到临时数组中
5. 将临时数组中的元素放回原数组中

计数排序

什么是计数排序

☁️计数排序相对于前面的三种排序来说，要容易理解很多。我们只需要将每个数出现的次数记到临时数组，然后去遍历这个临时数组，将数再取出来就可以了。

☁️接下来让我们用一个动画来看看计数排序的过程：

1. 统计每个数字的个数。
2. 按照顺序和数字将数放回原本的数组中

计数排序基本思想

☁️是对于给定的输入序列中的每一个元素 x，确定该序列中值小于 x 的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。

☁️时间复杂度：$O(n)$

C语言实现计数排序

void CountSort(int* a, int size, int max)
{
	int* tmp = (int*)malloc(sizeof(int) * (max + 1));                //(1)
	memset(tmp, 0, sizeof(int) * (max + 1));                         //(2)
	for (int i = 0; i < size; i++)                                   //(3)
	{
		tmp[a[i]]++;
	}

	int count = 0;
	for (int i = 0; i <= max; i++)                                  //(4)
	{
		while (tmp[i] > 0)
		{
			a[count++] = i;
			tmp[i]--;
		}
	}
}

1. 临时用来存放数组中数据个数的数组
2. 将临时数组中的值归为0
3. 将各个数字的个数计入临时数组
4. 将排序好的数据放回原数组

结语

欢迎各位参考与指导！！！❤️