计数排序和桶排序

上述的排序方法是博主的前四篇博客介绍的常见排序方法，它们有一个共同的特征，都是比较排序，今天我们介绍一下非比较排序，常见的非比较排序有：计数排序、基数排序。

计数排序

计数排序(Count Sort)是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为$O(n+k)$（其中$k$是整数的范围），快于任何比较排序算法。

计数排序的思想类似于哈希表中的直接定址法，在给定的一组序列中，先找出该序列中的最大值和最小值，从而确定需要开辟多大的辅助空间，每一个数在对应的辅助空间中都有唯一的下标。

1. 找出序列中最大值和最小值，开辟Max-Min+1的辅助空间，起初辅助空间的值全置零。
2. 最小的数对应下标为0的位置，遇到一个数就给对应下标处的值+1,。
3. 遍历一遍辅助空间，就可以得到有序的一组序列

#include<iostream>
#include<vector>

using namespace std;
void CountSort(int* arr,int len)
{
	int min = arr[0], max = arr[0];
	for (int i = 0; i < len; i++)//遍历数组找到最大值和最小值
	{
		if (arr[i] < min)
			min = arr[i];
		if (arr[i]>max)
			max = arr[i];
	}

	vector<int> v(max - min + 1, 0);
	for (int i = 0; i < len; i++)//统计次数
	{
		v[arr[i] - min]++;
	}

	int index = 0;
	for (size_t i = 0; i < v.size(); i++)//遍历辅助空间
	{
		while (v[i]--)//辅助空间的值表示该下标出现的次数
		{
			arr[index++] = i + min;
		}
	}
}
int main()
{
	int arr[] = { 4, 6, 6, 7, 9, 9, 9, 1, 1, 3, 5, 8 };
	int len = sizeof(arr) / sizeof(arr[0]);
	CountSort(arr,len);
	for (int i = 0; i < len; i++)
		cout << arr[i] << "  ";
	cout << endl;
	system("pause");
	return 0;
}

计数排序的特性总结

1. 计数排序是一种以空间换时间的排序算法，并且只适用于待排序列中所有的数较为集中时，比如一组序列中的数据为0 1 2 3 4 999;就得开辟1000个辅助空间。
   时间复杂度
2. 计数排序的时间度理论为$O(n+k)$,其中$k$为序列中数的范围。 不过当$O(k)>O(n\ast log(n))$的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是$O(n\ast log(n))$, 如归并排序，堆排序），空间复杂度：O(k)。
3. 稳定性：稳定

桶排序/基数排序（假设待排序数组最多两位）

给定一组数据，我可以先按个位的大小对所有数进行排序，然后再按十位进行排序，一直到最高位，这样就可以使整组数据变得有效，这样从最低位开始的方法称为最低位优先(Least Significant Digit first)

反之，如果先从最高为的关键字开始，最后再比较最低位，则称之为最高位优先(Most Significant Digit first)

分配计数后，接下来再将所有桶中的所盛的数据依次重新串联起来，得到如下数据：14，22，28，39，43，55，65，73，81，93。

x是一个两位数，x/10是这个两位数的十位的数值，x%10是这个数的个位数的数值。

#include<iostream>
#include<vector>

using namespace std;
void BucketSort(int* arr, int len)
{
	vector<vector<int>> LSD(10);
	vector<vector<int>> MSD(10);
	for (int i = 0; i < len; i++)//将数组元素扔进个位桶
	{
		LSD[arr[i] % 10].push_back(arr[i]);
	}

	for (int i = 0; i < 10; i++)//将二维数组LSD中的数字依次扔进十位桶
	{
		if (LSD[i].size()>0)
		{
			for (size_t j = 0; j < LSD[i].size(); j++)
			{
				int insert = LSD[i][j];
				MSD[insert / 10].push_back(insert);
			}
		}
	}

	int index = 0;//将数据拷贝回原数组
	for (int i = 0; i < 10; i++)//将二维数组LSD中的数字依次扔进十位桶
	{
		if (MSD[i].size()>0)
		{
			for (size_t j = 0; j < MSD[i].size(); j++)
			{
				arr[index++] = MSD[i][j];
			}
		}
	}
}

int main()
{
	int arr[] = { 73, 22, 93, 43, 55, 14, 28, 65, 39, 81 };
	int len = sizeof(arr) / sizeof(arr[0]);
	BucketSort(arr,len);
	for (int i = 0; i < len; i++)
		cout << arr[i] << "  ";
	cout << endl;
	system("pause");
	return 0;
}

基数排序的时间复杂度可以理解为$O(d\ast n)$，$d$为序列中最大的位数，适用于n值很大，但是$d$较小的序列。