Hark的数据结构与算法练习之计数排序

算法说明

计数排序属于线性排序,它的时间复杂度远远大于常用的比较排序。(计数是O(n),而比较排序不会超过O(nlog2nJ))。

其实计数排序大部分很好理解的,唯一理解起来很蛋疼的是为了保证算法稳定性而做的数据累加,大家听我说说就知道了:

1、首先,先取出要排序数组的最大值,假如我们的数组是int[] arrayData = { 2, 4, 1, 5, 6, 7, 4, 65, 42 };,那么最大值就是65.(代码17-21行就是在查找最大值)

2、然后创建一个计数数组,计数数组的长度就是我们的待排序数组长度+1。即65+1=66。计数数组的作用就是用来存储待排序数组中,数字出现的频次。 例如,4出现了两次,那么计数数组arrayCount[4]=2。 OK,现在应该明白为什么计数数组长度为什么是66而不是65了吧? 因为为了存储0

然后再创建一个存储返回结果的数组,数组长度与我们的原始数据长度是相同的。(24和26行)

3、进行计数(代码29至31行)

4、将计数数组进行数量累计,即arrayCount[i]+=arrayCount[i-1](代码35行至代码37行)。 

   目的是为了数据的稳定性, 这块我其实看了许久才看懂的…再次证明我的资质真的很差劲。 我来尽力解释一下:

其实这个与后边那步结合着看理解起来应该更容易些。

例如我们计数数组分别是 1 2 1 2 1 的话,那么就代表0出现了一次,1出现了两次,2出现了一次,3出现了两次。

  这个是很容易理解的。 那我们再换个角度来看这个问题。

  我们可以根据这个计数数组得到每个数字出现的索引位置,即数字0出现的位置是索引0,数字1出现的问题是索引1,2;数字2出现的位置是索引3,数字4出现的位置是索引4,5。。。。

  OK,大家可以看到,这个索引位置是累加的,所以我们需要arrayCount[i]+=arrayCount[i-1]来存储每个数字的索引最大值。 这样为了后边的输出

5、最后,把原始数据从后往前输出;然后每个数字都能找到计数器的最后实现索引。  然后将数字存储在实际索引的结果数组中。 然后计数数组的索引--, 结果就出来了。

PS:计数排序其实是特别吃内存的,所以应用场景是最大值确定并且不大,必须是正整数。

时间复杂度:

O(n+k)

请对照下方代码:因为有n的循环,也有k的循环,所以时间复杂度是n+k

空间复杂度:

O(n+k)

请对照下方代码:需要一个k+1长度的计数数组,需要一个n长度的结果数组,所以空间复杂度是n+k

代码

使用的是java

/*
 * 计数排序
 */
public class CountingSort {
	public static void main(String[] args) {
		int[] arrayData = { 2, 3, 1, 5, 6, 7, 4, 65, 42 };
		int[] arrayResult = CountintSort(arrayData);
		for (int integer : arrayResult) {
			System.out.print(integer);
			System.out.print(" ");
		}
	}

	public static int[] CountintSort(int[] arrayData) {
		int maxNum = 0;
		// 取出最大值
		for (int i : arrayData) {
			if (i > maxNum) {
				maxNum = i;
			}
		}

		// 计数数组
		int[] arrayCount = new int[maxNum + 1];
		// 结构数组
		int[] arrayResult = new int[arrayData.length];

		// 开始计数
		for (int i : arrayData) {
			arrayCount[i]++;
		}

		// 对于计数数组进行 i=i+(i-1)
		// 目的是为了保证数据的稳定性
		for (int i = 1; i < arrayCount.length; i++) {
			arrayCount[i] = arrayCount[i] + arrayCount[i - 1];
		}

		for (int i = arrayData.length - 1; i >= 0; i--) {
			arrayResult[arrayCount[arrayData[i]] - 1] = arrayData[i];
			arrayCount[arrayData[i]]--;
		}

		return arrayResult;

	}
}

结果

1 2 3 4 5 6 7 42 65

参考:

http://blog.csdn.net/sjin_1314/article/details/8655061

http://www.cnblogs.com/eaglet/archive/2010/09/16/1828016.html

时间: 2024-10-02 04:25:11

Hark的数据结构与算法练习之计数排序的相关文章

Hark的数据结构与算法练习之Bogo排序

算法说明 Bogo排序是交换排序的一种,它是一种随机排序,也是一种没有使用意义的排序,同样也是一种我觉得很好玩的排序. 举个形象的例子,你手头有一副乱序的扑克牌,然后往天上不停的扔,那么有一定机率会变成有序的. 哈哈,就是这样. 看一下代码大家就知道了. 代码 使用的是java package hark.sort.exchangesort; import java.util.Random; /* * Bogo排序 */ public class BogoSort { public static

Hark的数据结构与算法练习之鸡尾酒排序

算法说明 鸡尾酒排序又叫定向冒泡排序,鸡尾酒搅拌排序,搅拌排序,涟漪排序,回来排序,快乐小时排序. 鸡尾酒排序是交换排序的一种,它是冒泡排序的一个轻微的变种.冒泡是从低向高比较排序,鸡尾酒从低向高,从高向低交换着进行排序.大家看一下代码就知道了. 某些特殊有序数组情况下,鸡尾酒排序是效率略好于冒泡排序,例如: int[] arrayData = { 2, 3, 4, 5, 6, 7, 8, 9, 1 }; 鸡尾酒排序只排序一次就能出结果,而冒泡排序就需要8次才能出结果. 代码 使用的是java

Hark的数据结构与算法练习之奇偶排序

算法说明 奇偶排序又叫奇偶换位排序,砖排序.它是一种交换排序,也是冒泡的一个变种 顾名思义,奇偶排序,其实就是先循环奇数位,然后将奇数位与偶数位比较计算. 然后再循环偶数位,再和奇数位比较运算.看一下代码大家就明白了. 据wiki所述,这种算法是一种并行算法,个人对这块现在不太理解,没明白这块所谓的并行是什么意思,现在只是完成了一个单机版,将来如果明白了再过来进行补充啦. 代码 使用的是java package hark.sort.exchangesort; /* * 奇偶排序 */ publi

Hark的数据结构与算法练习之煎饼排序

算法说明 假设煎锅里边有N个煎饼摞在了一起,它们大小不一并且顺序不一致,我们需要通过拿铲子将它们不停的翻个,进行排序,最终得到一个底下是大的煎饼,上边是小的煎饼的序列.这个排序的过程就是煎饼排序. 这个算法有两种解,一种是普通解,一种是最优解. 普通论证: 例如你的初始煎饼顺序是[2,4,3,1] 然后2与4交换位置,然后4与1交换位置,得出[1,3,2,4]. 然后3与1交换位置,接着3与2交换位置,得出[2,1,3,4]. 最后2与1交换位置,得出结果[1,2,3,4] 通过普通解的过程,我

Hark的数据结构与算法练习之图书馆排序

算法说明 图书馆排序是插入排序的变种,典型的以空间换时间的一种方法.我个人感觉这种思路可以学习借鉴,但直接使用的场景应该不大. 我们知道,真正的插入排序通常往前边插入元素后,我们要把后边所有的元素后移.而图书馆排序的思路就是将每个元素后边都预留N个空间(例如预留10个元素空间),这样往某个元素前插入时,在预留空间足够的前题下,只会移动少少几个的元素. 代码 因为4月要考试,所以代码暂不写,以后有时间时补上 参考 http://www.cnblogs.com/kkun/archive/2011/1

Hark的数据结构与算法练习之希尔排序

算法说明 希尔排序是插入排序的优化版. 插入排序的最坏时间复杂度是O(n2),但如果要排序的数组是一个几乎有序的数列,那么会降低有效的减低时间复杂度. 希尔排序的目的就是通过一个increment(增量)来对数列分组进行交换排序,最终使数列几乎有序,最后再执行插入排序,统计出结果. 通过increment=n/2, 也就是如果9个数的话,增量为4,2,1.   如果是20个数的话,增量就是10,5,2,1.  当increment为1时,其实对几乎有序的数列进行插入排序啦啦. 时间复杂度 O(n

Hark的数据结构与算法练习之桶排序

算法说明 桶排序的逻辑其实特别好理解,它是一种纯粹的分而治之的排序方法. 举个例子简单说一下大家就知道精髓了. 假如对11,4,2,13,22,24,20 进行排序. 那么,我们将4和2放在一起,将11,13放在一起,将22,24,20放在一起.  然后将这三部分分别排序(可以根据实现情况任意选择排序方式,我的代码中使用的是快排),将子数组排序后,再顺序输出就是最终排序结果了(大概应该明白了,我们是根据数字大小进行分组的,故而顺序输出即可) 怎么样,很简单吧. 具体实现大家看代码就行,我实现的其

【数据结构】非比较排序算法(实现计数排序和基数排序)

● 计数排序 1.算法思想: 计数排序是直接定址法的变形.通过开辟一定大小的空间,统计相同数据出现的次数,然后回写到原序列中. 2.步骤: 1)找到序列中的最大和最小数据,确定开辟的空间大小. 2)开辟空间,利用开辟的空间存放各数据的个数. 3)将排好序的序列回写到原序列中. 具体实现如下: void CountSort(int *arr, int size) {  assert(arr);  int min = arr[0];  int max = arr[0];  int num = 0;

非基于比较的排序算法之一:计数排序

计数排序(Counting sort)是一种稳定的排序算法.计数排序使用一个额外的数组C,其中第i个元素是待排序数组A中值小于等于i的元素的个数.然后根据数组C来将A中的元素排到正确的位置. 限制:所有值得取值范围不能太大,并且需要知道确切的取值范围.本算法需要的辅助空间要求较高. 当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k).计数排序不是比较排序,排序的速度快于任何比较排序算法. 现在给出C#实现的计数排序(counting sort) public vo