【排序五】非比较排序（计数排序&&基数排序）

比较排序：

【排序一】插入排序（直接插入排序&&希尔排序）

【排序二】选择排序（选择排序&&堆排序）

【排序三】交换排序（冒泡排序&&快速排序）

【排序四】归并排序

一、计数排序

1、基本思想

     给定一组要排序的序列，找出这组序列中的最大值，然后开辟一个最大值加1大小的数组，将这个数组里面的元素全部置零，然后用这个数组统计出要排序的序列中各个元素出现的次数。等到统计完成的时候，排序就已经完成了。

图解（假设升序）：

2、算法执行步骤：

1>找出待排序序列里的最大值max；

2>开辟一个大小为max+1的临时数组tmp ，将数组元素的所有初值赋为0；

3>遍历待排序序列，将序列中出现值作为下标,对tmp 数组的对应位置数据进行++；

4>上述操作完成后，tmp中统计了每个数据在待排序列中出现的次数；

3>最后，将tmp数组里值不为0的所有下标拷进原序列（注意同一个下标可能有多个重复值，都要进行拷贝，不能遗漏），排序就算完成。

3、计数排序的优化

      从上面的例子中可以看出，3是待排序序列的最小值，在tmp数组中3 之前的位置并没有什么卵用，那么基于节省空间的角度进行考虑，我们可以开辟更小的临时数组统计次数，同样能完成排序。

    比如要对1000,999,1008这三数进行排序，按照普通的方法前998个空间都被浪费掉了，所以这时候我们对它进行优化。找出要排序的这组元素中的最大值和最小值，这样就确定了这组元素的范围，然后开辟这个范围加1大小的数组，然后再将要排序的元素映射到这个新开辟的数组中就可以了。

结论：计数排序适用于数据比较集中的序列排序。

4、时间复杂度&&空间复杂度

    计数排序是一种非比较的排序方法，它的时间复杂度是O(N+K)，空间复杂度是0(K),其中K是要排序的数组的范围。可以看出计数排序是一种以空间呢换取时间的方法。如果当K>N*logN的时候，计数排序就不是好的选择了，因为基于比较排序的算法的下限是O(N*logN)。 

5、代码实现

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;

void PrintArray(int* a,size_t n)
{
	for (size_t i = 0; i < n; ++i)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}


void CountSort(int* a,size_t n)
{
	//查找待排序序列的最大值
	int max = a[0];
	for (size_t i = 0; i < n-1; ++i)
	{
		if (max < a[i+1])
		{
			max = a[i+1];
		}
	}

	//开辟临时数组用来统计数据出现次数
	int* tmp = new int[max+1];
	//对临时数组初值赋为0
	memset(tmp,0,sizeof(int)*(max+1));
	//统计数据出现次数
	for (size_t i = 0; i < n; ++i)
	{
		tmp[a[i]]++;
	}

	//将数据考回原数组
	int index = 0;
	for (int i = 0; i <= max; ++i)
	{
		while(tmp[i]--)
		{
			a[index] = i;
			++index;
		}
	}
	delete []tmp;
}

//计数排序的优化
void CountSort1(int* a,size_t n)
{
	//找到待排序序列的最大值和最小值
	int max = a[0];
	int min = a[0];
	for (size_t i = 0; i < n-1; ++i)
	{
		if (max < a[i+1])
		{
			max = a[i+1];
		}
		if (min > a[i+1])
		{
			min = a[i+1];
		}
	}

	//开辟适当空间的数组
	int range = max - min + 1;
	int* tmp = new int[range];
	memset(tmp,0,sizeof(int)*(range));
	for (size_t i = 0; i < n; ++i)
	{
		tmp[a[i]-min]++;
	}

	//将数据考回原数组
	int index = 0;
	for (int i = 0; i < range; ++i)
	{
		while(tmp[i]--)
		{
			a[index] = i+min;
			++index;
		}
	}
	delete []tmp;
}

void TestCountSort()
{
	int a[] = {2,5,4,9,3,6,8,7,1,0};
	int a1[] = {73,20,93,43,55,14,28,65,39,81};
	size_t sz = sizeof(a)/sizeof(a[0]);
	size_t sz1 = sizeof(a1)/sizeof(a1[0]);

	CountSort(a,sz);
	CountSort1(a1,sz1);
	PrintArray(a,sz);
	PrintArray(a1,sz1);
}

运行结果：

二、基数排序

1、基数排序的分类
LSD-- Least Significant Digit first（从低位向高位排）
MSD-- Most Significant Digit first（从高位向低位排）

由于原理差不多，此文只针对LSD进行分析。

2、基本思想

    基数排序又称"桶子法"，它从低位开始将待排序的数按照这一位的值放到相应的编号为0到9的桶中。等到低位排完之后得到一个序列，再将这个序列按照次低位的大小进入相应的桶中。以此类推，直到将所有的位都排完之后，这组数就已经有序了。

图解（假设升序）：

3、算法执行步骤

1》统计待排序序列中最大的数是几位数；

2》开辟一个与原数组大小相同的临时数组tmp；

3》用一个count数组统计原数组中某一位（从个位向高位统计）相同的数据出现的次数；

4》用一个start数组计算原数组中某一位（从个位向高位计算）相同的数据出现的位置；

5》将桶中数据从小到大（由顶至底）用tmp数组收集起来；

6》循环3》4》5》直到所有位都被统计并计算过，然后用tmp收集起来；

7》将tmp数组的数据拷回原数组，排序完成。

图解：

4、时间复杂度&&空间复杂度

    基数排序是一种非比较排序，它的时间复杂度是O(N*digit)，其中digit是这组待排序中的最大的数的数量级。基数排序的空间复杂度就是在分配元素时，使用的桶空间，所以基数排序的空间复杂度是O(N)。它是一种稳定的排序方法。

5、代码实现

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;

int GetMaxDigit(int* a,size_t n)//得到数组最大值的位数
{
	int digit = 1;
	int base = 10;

	for (size_t i = 0; i < n; ++i)
	{
		//每次与几位数的最小数据（10、100、1000……）进行比较，
		//优点是相同位数的数据只统计一次
		while(a[i] >= base)
		{
			++digit;
			base *= 10;
		}
	}
	
	return digit;
}

void LSDSort(int* a,size_t n)
{
	assert(a);
	int base = 1;
	int digit = GetMaxDigit(a,n);//统计位数
	int* tmp = new int[n];//开辟临时数组

	while(digit--)
	{
		int count[10] = {0};
		//统计某位相同的数据出现次数
		for (size_t i = 0; i < n; ++i)
		{
			int index = a[i]/base %10;
			count[index]++;
		}

		int start[10] = {0};
		//统计个位相同的数在数组a中出现的位置
		for (size_t i = 1; i < n; ++i)
		{
			start[i] = count[i-1] + start[i-1];
		}

		memset(tmp,0,sizeof(int)*n);//为tmp数组初始化
		//从桶中收集数据（从小到大）
		for (size_t i = 0; i < n; ++i)
		{
			int index = a[i]/base %10;
			tmp[start[index]++] = a[i];
		}

		//将数据拷回原数组
		memcpy(a,tmp,sizeof(int)*n);
		base *= 10;
	}
	delete []tmp;
}

void PrintArray(int* a,size_t n)
{
	for (size_t i = 0; i < n; ++i)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}
void TestLDSort()
{
	int a[] = {73,20,93,43,55,14,28,65,39,81};
	size_t sz = sizeof(a)/sizeof(a[0]);

	LSDSort(a,sz);
	PrintArray(a,sz);
}

运行结果：