DSA之十大排序算法第八种：Counting Sort

最新推荐文章于 2021-03-17 10:57:23 发布

孤傲小二~阿沐

最新推荐文章于 2021-03-17 10:57:23 发布

阅读量5.5k

点赞数 2

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/weixin_43949535/article/details/100182691

版权

数据结构与算法专栏收录该内容

29 篇文章 7 订阅

订阅专栏

计数排序 2019年9月1日13:48:16
相较于之前的比较式的排序算法，计数排序就大大的不同了。计数排序不是比较排序，排序的速度当然也就快于任何比较排序算法。其基本思想：将待排序的数据值转化为键存储在额外开辟的数组空间中。对每一个输入的元素data，确定出小于data的元素的个数。于是那么就可以把data 直接放到相应的位置上。
它作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。（我这里统一处理为：myvec.push_back(rand() % 11);//这组数据的范围是：0---10）因此当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。

因为用来计数的数组temp_src的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计次数减去 1 的原因。
排序步骤就是：

找出待排序的数组中最大的元素maxval，将临时存放次数的数组temp_src 开辟出来。
统计数组中每个值为i的元素出现的次数，存入数组temp_src的第i项。所以这也是为什么要开辟maxval+1 的空间。把maxval也作为一个下标。
对所有的计数累加（从temp_src中的第1 号元素开始，每一项和前一项相加）
反向填充目标数组：将src数组的每个元素src[i] 放在新数组new_src的第temp_src【i 】项，每放一个元素就将temp_src【src[i]】减去1。表示放置了一个元素，统计次数可以减一。

分析具体实现：

如上图所示（从菜鸟网站“拿”来的）：面对下面的一组数据：

2,5,3,0,2,3,0,3

首先统计出来：size=8，maxval=5。所以说：开辟一个 6个空间大小的数组即可，即temp_src(maxval + 1)。接下来：把src【i】的数据作为这个temp_src的下标，进行统计每个数据出现的次数，并把这个次数作为新记录数组的下标。

再接下来就是统计出来：待排序列中小于等于每一个元素data的个数，并把结果记录到辅助数组temp_src[0~maxval]中，从而确定data在排好序的新数组中的位置。如下：

	for (int i = 1; i < temp_src.size(); ++i)
	{
		temp_src[i] += temp_src[i - 1];//小于当前数据元素的个数
	}

最后就可以进行反向处理数组，放置元素。我把步骤打开，这样便于理解。

	int new_index_of_newsrc = 0;//新空间  元素的下标
	for (int i = size - 1; i >= 0; --i)
	{
		new_index_of_newsrc = --temp_src[src[i]];
		new_src[new_index_of_newsrc] = src[i];
	}

反向处理，把src中的数据一个个的取出来进行操作。temp_src数组里面存放的是：这个元素 i 应该在新的数组new_src中的第几个位置，所以这里需要先进行–temp_src[src[i]]操作，以得到正确的下标。接下来就可以把这个数据元素src[i] 值放入新数组中的了。很巧妙的是：在其中，重复数据的下标也得到了处理。

分析排序算法：

计数排序是一种线性排序算法，不用比较元素的大小。待排序序列中元素都是整数，且在0~maxval之间，maxval为整数。稳定性强，时间复杂度为O(n+maxval)，n为输入元素个数，maxval为待排序列中最大的数。但局限性大，只限于对整数进行排序。
这种通过牺牲空间复杂度来获取高效的时间的排序方式，空间复杂度为O(n)。

排序算法实现（标准版本）：

void Counting_sort(vector<int>& src)
{
	int size = src.size();
	static int count = 0;//记录循环进入的次数
	int maxval = src[0];//记录数组中元素的最大值

	for (int i = 1; i < size; ++i)
	{
		if (src[i] > maxval)
			maxval = src[i];
	}

	//所以说 应该开辟的大小就是maxval+1
	vector<int>temp_src(maxval + 1);//这是临时开辟的数组,全初始化为0

	//统计值为src[i]的个数;而temp_src[i]是等于i的元素个数
	for (int i = 0; i < size; ++i)
	{
		//统计 每个数据出现的次数，并把这个次数作为新记录数组的下标
		temp_src[src[i]]++;
	}
	for (int i = 1; i < temp_src.size(); ++i)
	{
		temp_src[i] += temp_src[i - 1];//小于当前数据元素的个数
	}
	//接下来就是反向处理数组，放置元素
	//需要再额外开辟一块和 src一样大小的数组空间
	vector<int>new_src;
	new_src.resize(size);
	int new_index_of_newsrc = 0;//新空间元素的下标
	for (int i = size - 1; i >= 0; --i)
	{
		new_index_of_newsrc = --temp_src[src[i]];
		new_src[new_index_of_newsrc] = src[i];
		count++;
	}

	src.clear();
	for (int i = 0; i < size; ++i)
	{
		src.push_back(new_src[i]);
	}
	
	cout << "共进入循环次数：" << count << endl;
}

排序算法实现（自创版本）：

注：我在看了最上面的动态演示之后，提笔写出来的代码。我也没有事先阅读源代码，但是等我阅读源代码，之后总是感觉怪怪的：有一种 “脱裤子放屁”的感觉。大家看到这个地方先不要笑，先替我看一下我的代码。如下：

void Counting_sort1(vector<int>& src)
{
	int size = src.size();
	static int count = 0;//记录循环进入的次数
	int maxval = src[0];//记录数组中元素的最大值

	for (int i = 1; i < size; ++i)
	{
		if (src[i] > maxval)
			maxval = src[i];
	}

	//所以说 应该开辟的大小就是maxval+1
	vector<int>temp_src(maxval  + 1);//这是临时开辟的数组,全初始化为0

	for (int i = 0; i < size; ++i)
	{
		//统计 每个数据出现的次数，并把这个次数作为新记录数组的下标
		temp_src[src[i]]++;
	}

	//接下来就是反向处理数组，放置元素
	src.clear();
	for (int i = 0; i < temp_src.size(); ++i)
	{
		while (temp_src[i] != 0)
		{
			src.push_back(i);
			temp_src[i]--;
			count++;
		}
	}
	cout << "共进入循环次数：" << count << endl;
}

2019年9月1日14:38:24
我不想再看了，头疼若有老哥发现问题，定要致谢，还请各位不吝赐教。

全部源代码及测试如下：

/**══════════════════════════════════╗
*作    者：songjinzhou                                                 ║
*CSND地址：https://blog.csdn.net/weixin_43949535                       ║
***GitHub：https://github.com/TsinghuaLucky912/My_own_C-_study_and_blog║
*═══════════════════════════════════╣
*创建时间：2019年9月1日11:34:01                                                            
*功能描述：                                                            
*                                                                      
*                                                                      
*═══════════════════════════════════╣
*结束时间: 2019年9月1日13:50:07                                                            
*═══════════════════════════════════╝
//                .-~~~~~~~~~-._       _.-~~~~~~~~~-.
//            __.'              ~.   .~              `.__
//          .'//              西南\./联大               \\`.
//        .'//                     |                     \\`.
//      .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
//    .'//.-"                 `-.  |  .-'                 "-.\\`.
//  .'//______.============-..   \ | /   ..-============.______\\`.
//.'______________________________\|/______________________________`.
*/
#include <iostream>
#include <vector>
#include <iomanip>
#include <time.h>

using namespace std;

const int MAX = 15;

void Counting_sort1(vector<int>& src)
{
	int size = src.size();
	static int count = 0;//记录循环进入的次数
	int maxval = src[0];//记录数组中元素的最大值

	for (int i = 1; i < size; ++i)
	{
		if (src[i] > maxval)
			maxval = src[i];
	}

	//所以说 应该开辟的大小就是maxval+1
	vector<int>temp_src(maxval  + 1);//这是临时开辟的数组,全初始化为0

	for (int i = 0; i < size; ++i)
	{
		//统计 每个数据出现的次数，并把这个次数作为新记录数组的下标
		temp_src[src[i]]++;
	}

	//接下来就是反向处理数组，放置元素
	src.clear();

	for (int i = 0; i < temp_src.size(); ++i)
	{
		while (temp_src[i] != 0)
		{
			src.push_back(i);
			temp_src[i]--;
			count++;
		}
	}
	cout << "共进入循环次数：" << count << endl;
}

void Counting_sort(vector<int>& src)
{
	int size = src.size();
	static int count = 0;//记录循环进入的次数
	int maxval = src[0];//记录数组中元素的最大值

	for (int i = 1; i < size; ++i)
	{
		if (src[i] > maxval)
			maxval = src[i];
	}

	//所以说 应该开辟的大小就是maxval+1
	vector<int>temp_src(maxval + 1);//这是临时开辟的数组,全初始化为0

	//统计值为src[i]的个数;而temp_src[i]是等于i的元素个数
	for (int i = 0; i < size; ++i)
	{
		//统计 每个数据出现的次数，并把这个次数作为新记录数组的下标
		temp_src[src[i]]++;
	}
	for (int i = 1; i < temp_src.size(); ++i)
	{
		temp_src[i] += temp_src[i - 1];//小于当前数据元素的个数
	}
	//接下来就是反向处理数组，放置元素
	//需要再额外开辟一块和 src一样大小的数组空间
	vector<int>new_src;
	new_src.resize(size);
	int new_index_of_newsrc = 0;//新空间元素的下标
	for (int i = size - 1; i >= 0; --i)
	{
		new_index_of_newsrc = --temp_src[src[i]];
		new_src[new_index_of_newsrc] = src[i];
		count++;
	}

	src.clear();
	for (int i = 0; i < size; ++i)
	{
		src.push_back(new_src[i]);
	}
	
	cout << "共进入循环次数：" << count << endl;
}

int main()
{
	srand((unsigned)time(nullptr));

	vector<int>myvec;
	for (int i = 0; i < MAX; ++i)
	{
		myvec.push_back(rand() % 11);//这组数据的范围是：0---10
	}
	cout << "数列初始状态：";
	for (int val : myvec)
		cout << setw(2) << val << " ";
	cout << endl;
	cout << "/*------------------------------------*/" << endl;
	Counting_sort1(myvec);
	cout << "/*------------------------------------*/" << endl;
	cout << "数列最终状态：";
	for (int val : myvec)
		cout << setw(2) << val << " ";
	cout << endl;
	cout << "*********************************************" << endl;

	int Array[] = { 2,5,3,0,2,3,0,3 };
	vector<int>myvec1(begin(Array), end(Array));
#if 0
	for (int i = 0; i < MAX; ++i)
	{
		myvec1.push_back(rand() % 11);//这组数据的范围是：0---10
	}
#endif 

	cout << "数列初始状态：";
	for (int val : myvec1)
		cout << setw(2) << val << " ";
	cout << endl;
	cout << "/*---------------------------------------*/" << endl;
	Counting_sort(myvec1);
	cout << "/*---------------------------------------*/" << endl;
	cout << "数列最终状态：";
	for (int val : myvec1)
		cout << setw(2) << val << " ";
	cout << endl;
	
	return 0;
}
/**
*备用注释：
*
*
*
*/

Counting_sort 是教程上和 CSDN各位大佬的版本
Counting_sort1 是我自己随手写的
在这里插入图片描述

孤傲小二~阿沐

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
DSA之十大排序算法第八种：Counting Sort

计数排序 2019年9月1日13:48:16相较于之前的比较式的排序算法，计数排序就大大的不同了。计数排序不是比较排序，排序的速度当然也就快于任何比较排序算法。其基本思想：将待排序的数据值转化为键存储在额外开辟的数组空间中。对每一个输入的元素data，确定出小于data的元素的个数。于是那么就可以把data 直接放到相应的位置上。它作为一种线性时间复杂度的排序，计数排序要求输入的数据必须...
复制链接

扫一扫