计数排序

package com.victor.sort.algorithms;

import java.util.ArrayList;

import com.victor.sort.seeds.FewUniqueKeys;
import com.victor.sort.seeds.NearSorted;
import com.victor.sort.seeds.Random;
import com.victor.sort.seeds.Reversed;
import com.victor.sort.seeds.Seeds;

/**
 * 计数排序的JAVA实现
 * @author 黑妹妹牙膏
 *
 */
public class Count extends SortAlgorithms {

	/**
	 * (non-Javadoc)
	 * @see com.victor.sort.algorithms.SortAlgorithms#_sort(java.util.ArrayList)
	 	A: 输入的数组
	 	B: 排序完输出的数组
	 	k: 假设输入的元素中的每一个都是介于 0 ~ k的整数
	 	
	 	Counting-sort(A,B,k)
	 	for i<- 0 to k
	 		do C[i] <- 0
	 	for j<- 1 to length[A]
	 		do C[A[j]] <- C[A[j]]+1
	 	# C[j] 包含等于i的元素个数
	 	for i <- 1 to k
	 		do C[i] <- C[i] + C[i-1]
	 	# C[i] 包含小于或等于i的元素个数
	 	for j <- length[A] downto 1
	 		do B[C[A[j]]] <- A[j]
	 			C[A[j]] <- C[A[j]] - 1
	 */
	@SuppressWarnings("unchecked")
	@Override
	protected ArrayList<Integer> doSort(ArrayList<Integer> Alist) {
		ArrayList<Integer> a = (ArrayList<Integer>)Alist.clone();
		ArrayList<Integer> b = (ArrayList<Integer>)a.clone();
		
		for(int i=(a.size()-1)/2;i>=0;i--)
		{
			a = sink(a,i,a.size());
		}
		int[] c = new int[a.get(0)+1];
		//for j<- 1 to length[A]
 		//	do C[A[j]] <- C[A[j]]+1
		print(a);
		for(int j=0;j<a.size();j++)
		{
			c[a.get(j)] = c[a.get(j)] + 1;
		}
		
		//for i <- 1 to k
 		//do C[i] <- C[i] + C[i-1]
		for(int i=1;i<c.length;i++)
		{
			c[i] = c[i]+c[i-1];
		}
		//for j <- length[A] downto 1
 		//	do B[C[A[j]]] <- A[j]
 		// 		C[A[j]] <- C[A[j]] - 1
		
		for(int j=a.size()-1;j>=0;j--)
		{
			b.set(c[a.get(j)]-1, a.get(j));
			c[a.get(j)] = c[a.get(j)] - 1;
		}
		return b;
	}
	
	private ArrayList<Integer> sink(ArrayList<Integer> a,int i,int n)
	{
		//get left child
		int lc = 2 * i + 1;
		if(lc >= n) return a;
		//get right child
		int rc = lc + 1;
		//get max of left and right child
		int mc = (rc >= n) ? lc : (a.get(lc) > a.get(rc) ? lc : rc);
		// if parent > max of child then return
		if(a.get(i) >= a.get(mc)) return a;
		//swap max and parent
		int temp = a.get(i);
		a.set(i, a.get(mc));
		a.set(mc, temp);
		moveMentIncrease();
		return sink(a,mc,n);
	}
	
	

	@Override
	public String getName() {
		return "Count";
	}
	
	public static void main(String[] args)
	{
		Seeds seed1 = new Random();
		Seeds seed2 = new NearSorted();
		Seeds seed3 = new Reversed();
		Seeds seed4 = new FewUniqueKeys();
		SortAlgorithms SA = new Count();
		SA.sort(seed1,10000);
		//SA.print();
		SA.sort(seed2,10000);
		SA.sort(seed3,10000);
		SA.sort(seed4,10000);
	}

}