排序（五）——非比较排序+排序总结

1.非比较排序

我们前面讲的排序算法都是通过比较大小来进行排序的，他们都是比较排序。

像基数排序、计数排序和桶排序等都不是通过比较大小来排序的，是非比较排序，在这里我们讲一下其中的计数排序和基数排序，而桶排序实现起来太挫，是一种类似哈希的结构，我们之后会学到哈希结构，就不学习桶排序了。

1.1计数排序

计数排序是怎么不通过比较两个元素的大小进行排序的呢？假设我们有下面这样一组数据：

对于这样的数据，我们前面学的排序当然都可以解决，但是这里我们要用一种很巧妙的方法，相信大家在做题的过程中肯定遇见过这样的一类题：某个数组包含 0~n 的数据，每一数组都只出现了一次，而有一个数据缺失了，只遍历这个原数组一遍找出这个缺少的数。在做这个题的时候，我们用到了一种方法，就是创建容纳一个 n+1 个整形的数组，用calloc，开辟的时候顺便初始化为0，然后遍历原数组一遍，以原数组的元素作为下标访问我们开辟的新数组，把该下标位置的0加一变成1。最后遍历一遍用来计数的数组，看哪个下标的元素为0，就代表着这个下标在原数组中没有出现过。而我们计数排序就是通过统计数组中每一个元素出现的个数来进行排序的。

首先我们要创建一个数组来统计个数，我们看到前面的数组的最大值就是9，所以我们就开创一个十个整形大小的数组。

	//遍历一遍找最大数
	int max = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
	}
	//创建一个 max+1的数组
	int* count = (int*)calloc(max + 1, sizeof(int));
	assert(count);

第二步就是遍历数组统计次数

	//遍历一遍统计个数
	for (int i = 0; i < n; i++)
	{
		count[a[i]]++;
	}

当把每个数出现的次数统计出来之后，我们就看艳照出现的次数将其依次覆盖回原数组。覆盖完之后就已经把元数据排好序了，最后释放掉count数组

	int j = 0;
	//覆盖回原数组
	for (int i = 0; i < max + 1; i++)
	{
		while (count[i]--)
		{
			a[j++] = i;
		}
	}

	free(count);

这个算法的思路很简单，同时，我们在统计数组元素个数时，以计数数组的下标来代表元素，这种就是映射，下标的之就代表元素的值，就是绝对映射。

但是对于这样一组数据呢？

他们之中的最大值是120，那是不是意味着我们就要开辟一块容纳 121 个整形的空间呢？如果我们开辟这么大一块空间，那么前面的一百个空间是不是浪费了？而统计的时候我们只会用到后面的二十一块空间。或者说如果要排序下面一个数组：

这里的数据有负数，而下标是不可能出现负数，这种情况该怎么处理呢？

这就引申出了第二种思路，相对映射

相对映射具体做法是这样的，我们用 0 下标来代表数组中最小的数据，下标 1 代表最小的数据+1，以此类推。这样一来，我们的计数的数组只要算出数组中的最大值和最小值，他们的差值+1就是我们要开辟的数组要统计的出现次数的数据的个数。

比如第一个数组，我们用0下标来代表100，用1下标来代表101... ...用20下标来代表20，这样一来我们就只要开辟21个整形大小的空间就能完成计数了，大大减小了空间浪费

对于存在负数的数组也是一样的，我们用下标 0 来代表最小值 -5，用下标 1 来代表 -4 ... ...用下标 10代表 5 。

这时候我们就可以先遍历一边数组来找出最小值和最大值，然后求出数据范围。其他的操作还是跟之前一样

void CountSort(int* a, int n)
{
	assert(a);

	int min = a[0];
	int max = a[0];
	//遍历一遍找最小值和最大值
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	//求数据个数（范围）
	int range = max - min + 1;
	//计数数组
	int* count = (int*)calloc(range, sizeof(int));
	assert(count);
	//统计个数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	int j = 0;
	//覆盖
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
	free(count);
}

相对映射比绝对映射更适合大多数场景。

对于计数排序，适合对数据范围相对集中的数据进行排序，效率很高，只需要遍历两遍数组，O(N+range)的时间复杂度和O(range)的空间复杂度。

他的缺点就是：1.不适合数值分散的数据

2.只适用于整形，不适合浮点数和字符串的排序

字符和负数的排序只要范围相对集中就都能用计数排序进行处理。

1.2基数排序

基数排序其实我们在生活中经常用到，比如打扑克的时候，一张牌的大小取决于它的数值和他的花色，我们对其排序的时候可以先根据他的花色分分组，然后在按其数值进行分组，这样一来政府派的大小就排好序了。

基数排序的思想就是两部：分发数据和回收数据。具体的概念很复杂，但是实现起来其实不是很难。对于基数排序方式有两种：MSD（最高位优先）LSD（最低位优先）

我们直接举例来实现一次基数排序，对于下面的这一组数据

这样的一组数据我们可以根据他的个位十位和百位分别进行分组和回收，这样一来，我们就只有十个分组的基，因为每一位的数值都在0~9之间。

首先我们以个位进行分组

以个位分完组之后进行回收，相同的组里先进来的先出去。

然后再以十位进行分组。

分发完数据之后再进行回收

最后再以百位分发数据

再次回收

这次回收数据之后我们就发现他已经排成有序了，分发和回收数据的次数取决于它的最大的数据有几位。这就是一种基数排序的应用。我们前面说了先进入分组的先出去，这时候我们就可以用队列来实现了。

//分发和回收数据
void Radix(int* a, int n, int k,Queue*q)
{
	//先取出每一个数，找到它的那一位,放进相应的队列中
	for (int i = 0; i < n; i++)
	{
		int num = a[i];
		int key = 0;
		int c = k;
		while (c--)
		{
			key = num % 10;
			num = num / 10;
		}
		//求出他的指定位的数字
		//放进指定的队列中
		QueuePush(&q[key], a[i]);
	}
	//回收数据
	int j = 0;
	for (int i = 0; i < 10; i++)
	{
		while (!QueueEmpty(&q[i]))
		{
			a[j++] = QueueFront(&q[i]);
			QueuePop(&q[i]);
		}
	}
}

//主逻辑
void RadixSort(int* a, int n, int k)
{
	assert(n);
	//k趟分发和回收
	Queue q[10];
	for (int i = 0; i < 10; i++)
	{
		QueueInit(&q[i]);
	}
	for (int i = 1; i <= k; i++)
	{
		Radix(a, n, i,q);
	}


	for (int i = 0; i < 10; i++)
	{
		QueueDestroy(&q[i]);
	}

}