算法导论第八章__实现计数排序

计数排序:不须要比較就能得出排序的顺序__比如。本章的计数排序、基数排序、桶排序

比較排序:须要进行比較才干得出排序的顺序__比如,本章的堆排序、高速排序(本质是插入排序)、插入排序

代码清单:计数排序__完美演绎下标的作用

public class Count_Sort {
	//接收须要排序的数组
	private int[] A;
	//排序后的数组
	private int[] B;
	//用于计数的数组
	private int[] C;

	// 初始化
	public Count_Sort(int[] A) {
		this.A = A;
		B = new int[A.length];
		C = new int[innitTemp()];
	}

	// 初始化暂时数组的大小
	public int innitTemp() {
		int bigest = A[0];
		for (int i = 1; i < A.length; i++) {
			if (A[i] > bigest) {
				bigest = A[i];
			}
		}
		return bigest+1;
	}

	// 计数排序
	public void sort() {
		// 把i中相应的元素映射到C中
		for (int i = 0; i < A.length; i++) {
			int value = A[i];
			C[value] = C[value] + 1;// 用C统计value有多少个
		}
		show(C);
		// 对C的值含义进行更换。换为有多少个小于当前下标的个数
		for (int i = 1; i < C.length; i++) {
			C[i] += C[i - 1];
		}
		show(C);
		// 最后得出来A[i]元素正确的插入位置
		for (int i = A.length - 1; i >= 0; i--) {
			int value = A[i];
			// 为什么要-1呢?想想,假设比5小的数是2个,那5就应该查到数组的2个位置,那么第2个位置,相应就是A[C[value]-1]
			B[C[value] - 1] = value;
			// 这个非常重要!比如,A[5]==A[2]这样的情况,A[5]插入了正确的位置,那么A[2]插入的顺序怎么算呢?就让它紧跟在A[5]后面!

C[value] -= 1;
		}
		show(B);
	}

	public void show(int[] X) {
		for (int i = 0; i < X.length; i++) {
			int j = X[i];
			System.out.print(j + "  ");
		}
		System.out.println();
		System.out.println("--------------------------------------------------------------");
	}

	public static void main(String[] args) {
		int []A={1,2,3,3,2,1,1,5,1,3,4,5};
		Count_Sort sort=new Count_Sort(A);
		sort.sort();
	}
}

输出的结果:

0  4  2  3  1  2

--------------------------------------------------------------

0  4  6  9  10  12

--------------------------------------------------------------

1  1  1  1  2  2  3  3  3  4  5  5

--------------------------------------------------------------

时间: 2024-08-08 05:46:20

算法导论第八章__实现计数排序的相关文章

算法导论 第8章 线性时间排序

合并排序和堆排序的时间复杂度为O(nlgn),插入排序和冒泡排序的时间复杂度为O(n^2),快速排序的时间复杂度在平均情况下是O(nlgn),这些排序算法都是通过对元素进行相互比较从而确定顺序的,因此都叫比较排序. 比较排序可以看做是决策树(一个满二叉树),因为每一次比较都是一个分支.n个元素的序列,其排序的结果有 n! 种可能(n个元素的全排),所以这个决策树有 n! 个叶子结点,假设树的高度为h,则有:n! <= 2^h,所以h >= lg(n!) = Ω(nlgn).一次比较排序就是从决

算法导论--第八章、计数排序

一.计数排序的基本思想是:对每一个输入元素x,确定小于x的元素个数.利用这一信息,就可以直接把x放到它在输出数组中的位置上了.例如,如果有17个元素小于x,则将x放在第18个位置即可.但是当存在几个元素相同时,会稍许不同,否则中间会漏掉元素. 二.假设输入是一个数组A[1..n],A.length = n.另外数组B[1...n]存放排序的输出,C[0...k]提供临时的存储空间: 伪代码如下: 1 Counting-Sort(A, B, k) 2 for i <- 1 to k 3 do C[

算法导论 第八章 线性时间排序(python)

比较排序:各元素的次序依赖于它们之间的比较{插入排序O(n**2) 归并排序O(nlgn) 堆排序O(nlgn)快速排序O(n**2)平均O(nlgn)} 本章主要介绍几个线性时间排序:(运算排序非比较排序)计数排序O(k+n)基数排序O() 第一节:用决策树分析比较排序的下界 决策树:倒数第二层满,第一层可能满的二叉树,它用来表示所有元素的比较操作{于此来分析下界},忽略控制,移动操作 1:2 #A[1]和A[2]比 <= 走左边 >走右边 <3,1,2> 最后的结果 下标对应排

算法导论第八章线性时间排序

一.线性时间排序算法历史概览 计数排序首先是由 Harold H. Seward 于1954年提出,而且他还提出将计数排序和基数排序进行结合的思想:基数排序是L.J.Comrie于1929年首次在一篇描述卡片穿孔机文档中提出的一种方法,它是从最低有效位开始,对一个有多位数组成的数进行排序的方法:而桶排序的基本思想则由E.J.Isaac和R.C.Singleton于1956年提出的,之后很多研究人员在这三种算法的基础上针对不同的应用场景又进一步改进,到了今天一个很成熟.很通用的地步. 二.O(nl

算法导论学习之快排+各种排序算法时间复杂度总结

快排是一种最常用的排序算法,因为其平均的时间复杂度是nlgn,并且其中的常数因子比较小. 一.快速排序 快排和合并排序一样都是基于分治的排序算法;快排的分治如下: 分解:对区间A[p,r]进行分解,返回q,使得A[p–q-1]都不大于A[q] A[q+1,r]都大于A[q]; 求解:对上面得到的区间继续递归进行快排 合并:因为快排是原地排序,所以不需要特别的合并 从上可以看出最重要的就是分解函数,其按关键值将数组划分成3部分,其具体实现的过程见代码注释. 我们一般取数组的最后一个元素作为划分比较

【算法导论 in lambda】并归排序

并归排序的过程就是一个先拆再合并的过程,先拆到全是不能再拆的最小数组,然后组与组之间合并,排序的过程在合并的过程中执行. 所以整个算法分两部分,split和merge 先说merge吧,将两个数组合并为新数组,符合从大到小. public int[] merge(int[] c1, int[] c2) { int[] ret = new int[c1.length + c2.length]; for (int i = 0, j = 0, index = 0; i < c1.length || j

《算法导论》习题2.2-2 选择排序

伪代码: SELECTION-SORT1 for i=2 to A.length-1 2  max = A[i] 3  mark = i 4 for j=i+1 to A.length 5 if A[j]>max 6  max=A[j] 7 mark = j 8 A[mark]=A[i] 9 A[i] = max Java 实现: public class SelectionSort { public static double [] sort(double [] A) { for(int i

Java实现计数排序

详细讲解见<算法导论>8.2节--计数排序. Java代码如下: package linetimesort; /** * 计数排序假设n个输入元素中的每一个都是介于0到k之间的某个整数,k为某个整数:它 * 通过确定小于等于一个数的数的个数来确定这个数应该放在哪个位置 * @author yuncong * */ public class CountSort { /** * * @param a 排序前的数组 * @param b 排序后的数组 * @param k 排序数组中最大元素的值 *

算法——计数排序与快速排序

计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序.比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序.我们如何设计一个 最高效的排序算法.本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优. 先看看计数排序的定义 Counting sort (sometimes referred to as ultra sort or math sort[1]) is a sorting algorith