排序算法(三)_计数排序、基数排序的Java实现

原创 2013年12月27日 08:38:46

       继续排序相关的内容,上次聊了几个theta(nlgn)的比较型排序,今天聊一下线性时间theta(n)的排序算法。都比较简单,大部分内容来自<算法导论>公开课视频。两个算法分别是计数排序、基数排序,如果不看书的话,真的很难凭空想到。

       计数排序:设有待排序数组A,辅助数组B,结果数组C。计数排序的关键有两点:

       一、在于辅助数组的设计,辅助数组C上元素的索引对应数组A中的某个具体的元素。而C上的元素C[i],则表示了A中有C[i]个元素小于等于值i。

       二、从辅助数组C到结果数组B的还原,从数组末尾向前还原,直觉上的依据就是将符合条件的元素插入到适合范围的最右侧。很绕口哈,举个例子:C[3]=3,说明A中小于等3的有3个元素,而这3个元素必定分布在1,2,3这3个位置。。哎,扯不清了>.<,还是直接上代码吧。

package com.wly.algorithmbase.sort;  
/**
 * 计数排序,适合于小范围数据分布的排序,时间复杂度O(k+n)
 * 注意:这里的排序假设前提所有元素都是大于0的正整数
 * @author wly
 * @pseudocode
 * for i <- 1 to k  //k表示带排序数组的元素上限值
 * 	  do c[i] <- 0  //辅助数组,长度为k
 * for j <- 1 to n  //将元素数组映射到辅助数组
 * 	  do c[A[j]] <- c[A[j]] + 1 
 * for i <- 2 to k  //处理辅助数组,使c[j]表示待排序数组中小于等于j的元素个数
 *    do c[i] <- c[i] + c[i-1]
 * for j <- n downto 1  //从后往前还原排序数组元素到一个新的数组
 *    do B[C[A[j]]] <- A[i]-1
 *       C[A[j]] <- C[A[j]] - 1  //更新辅助数组,因为有一个小于等于j的元素被还原
 *
 */
public class CountingSort {

	public static void main(String[] args) {
		
		//首位加0,同步伪代码
		int[] A = {0,3,5,1,2,7,4,3,2,1,6,7,2};
		System.out.println("排序前:");
		for(int i:A) {
			System.out.print(i + " ");
		}
		System.out.println("\n排序后:");
		CountingSort countingSort = new CountingSort();
		int[] B = countingSort.sort(A);
		for(int i:B) {
			System.out.print(i + " ");
		}
	}
	
	/**
	 * 计数排序实现,注意这里的实现和伪代码不同的是,数组是从0开始的
	 * 
	 * @param A
	 */
	public int[] sort(int[] A) {
		int k = findMax(A);
		int[] C = new int[k+1]; //长度加1,同步伪代码
		int[] B = new int[A.length];
		
		//初始化
		for(int i=0;i<C.length;i++) {
			C[i] = 0;
		}
		//将带排序数组元素重复个数映射到辅助数组中
		for(int i=1;i<A.length;i++) {
			C[A[i]] = C[A[i]] + 1;
		}
		//处理辅助数组,使c[j]表示待排序数组中小于等于j的元素个数
		for(int i=1;i<C.length;i++) {
			C[i] = C[i] + C[i-1];
		}
		//从后往前还原排序数组元素到一个新的数组
		int i = A.length-1;
		for(;i>0;i--) {
			B[C[A[i]]] = A[i];
			C[A[i]] = C[A[i]] - 1;
		}
		return B;
	}
	
	public int findMax(int[] A) {
		int temp = 0;
		for(int i:A) {
			if(i > temp) {
				temp = i;
			}
		}
		return temp;
	}
}

       运行结果:

排序前:
0 3 5 1 2 7 4 3 2 1 6 7 2 
排序后:
0 1 1 2 2 2 3 3 4 5 6 7 7 

        基数排序:一句话,从低位往高位排序,如果相同则保持位置。算法的原理是当对第T位进行排序时,后面的T-1都已经完成排序了,即影响排序结果的之后第T位。或者说第T为的对排序的影响大于后面T-1位数,只有在第T位相同时,采用T-1位的比较结果做补充。

       由于基数排序是从低到高一位一位进行排序的,那么可以使用上文中讲到的计数排序来完成每一位的排序(实际上可以将2位数视为一个比较单元,用计数排序进行排序)。

package com.wly.algorithmbase.sort;

/**
 * 基数排序
 * @author wly
 *
 */
public class RadixSort {

	public static void main(String[] args) {
		
		byte[][] A = {
			{0,0,0,0,0,0,0,0,0},
			{1,2,3,4,5,6,4,8,9},
			{1,5,3,4,5,6,7,8,9},
			{3,2,3,4,5,6,7,8,6},
			{1,2,3,4,5,6,7,8,9},
			{1,2,3,4,5,6,7,9,9},
			{1,2,3,4,5,6,3,8,9},
			{1,2,3,4,5,2,7,8,9},
			{1,2,3,4,6,6,7,8,9},
			{1,2,3,9,5,6,7,8,9},
				
		};
		System.out.println("基数排序前:");
		for(int i=0;i<A.length;i++) {
			for(int j=0;j<A[0].length;j++) {
				System.out.print(A[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println("\n基数排序后:");
		RadixSort sort = new RadixSort();
		sort.sort(A, A[0].length-1);
	}
	public void sort(byte[][] A,int p) {
		byte[][] B = new byte[A.length][A[0].length];
		int[] C = new int[10];

		if(p >= 0) {//根据第i为进行排序
			//初始化
			for(int i=0;i<C.length;i++) {
				C[i] = 0;
			}
			//将带排序数组元素重复个数映射到辅助数组中
			for(int i=1;i<A.length;i++) {
				C[A[i][p]] = C[A[i][p]] + 1;
			}
			//处理辅助数组,使c[j]表示待排序数组中小于等于j的元素个数
			for(int i=1;i<C.length;i++) {
				C[i] = C[i] + C[i-1];
			}
			//从后往前还原排序数组元素到一个新的数组
			int i = A.length-1;
			for(;i>0;i--) {
				B[C[A[i][p]]] = A[i];
				C[A[i][p]] = C[A[i][p]] - 1;
			}
			sort(B,p-1);
		} else {
			for(int i=0;i<A.length;i++) {
				for(int j=0;j<A[i].length;j++) {
					System.out.print(A[i][j] + " ");
				}
				System.out.println();
			}
		}
	}
}

       运行结果:

基数排序前:
0 0 0 0 0 0 0 0 0 
1 2 3 4 5 6 4 8 9 
1 5 3 4 5 6 7 8 9 
3 2 3 4 5 6 7 8 6 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 9 9 
1 2 3 4 5 6 3 8 9 
1 2 3 4 5 2 7 8 9 
1 2 3 4 6 6 7 8 9 
1 2 3 9 5 6 7 8 9 

基数排序后:
0 0 0 0 0 0 0 0 0 
1 2 3 4 5 2 7 8 9 
1 2 3 4 5 6 3 8 9 
1 2 3 4 5 6 4 8 9 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 9 9 
1 2 3 4 6 6 7 8 9 
1 2 3 9 5 6 7 8 9 
1 5 3 4 5 6 7 8 9 
3 2 3 4 5 6 7 8 6 

         O啦~~~

       谢谢!!

计数排序算法之Java实现

计数排序的基本思想是对于给定的输入序列中的每一个元素x,确定该序列中值小于x的元素的个数。一旦有了这个信息,就可以将x直接存放到最终的输出序列的正确位置上。例如,如果输入序列中只有17个元素的值小于x...

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

● 计数排序1、算法思想:       计数排序是直接定址法的变形。通过开辟一定大小的空间,统计相同数据出现的次数,然后回写到原序列中。2、步骤:1)找到序列中的最大和最小数据,确定开辟的空间大小。2...
  • Scenlyf
  • Scenlyf
  • 2016年06月11日 18:53
  • 240

浅谈排序算法实现 (计数排序、基数排序)

1、   计数排序       计数排序是一种高效的线性排序,它通过计算一个集合中元素楚翔的次数来确定集合如何排列,计数排序不需要进行数据的比较,所有他的运行效率前面介绍的都高。       计数...

线性排序算法(计数排序,基数排序,桶排序)分析及实现

写在前面 大家都知道的是,基于比较的排序算法的时间复杂度的下界是 O(n log(n))。这一结论是可以证明的,所以在基于比较的算法中是找不到时间复杂度为 O(n)的算法的。这时候,非基于比较的算法...

基数排序算法 java实现

  • 2012年02月20日 15:54
  • 32KB
  • 下载

常见排序算法汇总与分析(下)(基数排序与计数排序)

本篇汇总的算法将不再是基于比较的排序算法,因此会突破这类算法的时间复杂度下界O(nlog2n)。如果有朋友对前面的内容感兴趣,可以先去看看常见排序算法汇总与分析(中)(选择排序与归并排序) 我们先来...

算法学习之排序学习之基数排序,计数排序及java实现

先介绍一下概念   计数排序和基数排序都是非比较排序,就是不用进行比较就能排序,相对于堆排序,快速排序,插入排序等都是比较排序,比较排序算法的最坏情况下届都要做0(nlgn)次的比较,堆排序和合并排...

排序算法----冒泡排序+插入排序+选择排序+快速排序+希尔排序+堆排序+归并排序+计数排序+基数排序+桶排序(c语言)

c语言实现各种排序算法

三种基于“分配”“收集”的线性排序算法---计数排序、桶排序与基数排序

文中代码见原文链接:http://www.byvoid.com/blog/sort-radix/[非基于比较的排序]在计算机科学中,排序是一门基础的算法技术,许多算法都要以此作为基础,不同的排序算法有...
  • dadoneo
  • dadoneo
  • 2011年07月01日 09:19
  • 673

三种线性排序算法 计数排序、桶排序与基数排序

[非基于比较的排序] 在计算机科学中,排序是一门基础的算法技术,许多算法都要以此作为基础,不同的排序算法有着不同的时间开销和空间开销。排序算法有非常多种,如我们最常用的快速排序和堆排序等算法,这...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:排序算法(三)_计数排序、基数排序的Java实现
举报原因:
原因补充:

(最多只允许输入30个字)