桶排序

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;

/**
 * 桶排序
 * @author 黑妹妹牙膏
 *
 */
public class Bucket extends SortAlgorithms {

	/**
	 * (non-Javadoc)
	 * @see com.victor.sort.algorithms.SortAlgorithms#_sort(java.util.ArrayList)
	 * Bucket-Sort(A)
	 * 	n<-length[A]
	 * 	for i<-1 to n
	 * 		do insert A[i] into list B[[nA[i]]]
	 * 	for i <-0 to n<-1
	 *  do sort list B[i] with insertion sort
	 *  concatenate the list B[0],B[1],...,B[n-1] together in order
	 */
	
	@SuppressWarnings("unchecked")
	@Override
	protected ArrayList<Integer> doSort(ArrayList<Integer> Alist) {
		ArrayList<Integer> a = Alist;
		int n = a.size();
		
		for(int i=(n-1)/2;i>=0;i--)
		{
			a = sink(a,i,n);
		}
		int max = a.get(0);
		int d = (max+"").length();
		int mod = 1;
		
		for(int i=1;i<d;i++)
		{
			mod = mod * 10;
		}
		
		ArrayList<Integer>[] b = new ArrayList[10];
		for(int i=0;i<b.length;i++)
		{
			b[i] = new ArrayList<Integer>();
		}
		
		for(int i=0;i<n;i++)
		{
			b[a.get(i)/mod].add(a.get(i));
		}
		
		ArrayList<Integer> result = new ArrayList<Integer>();
		Insertion is = new Insertion();
		for(int i=0;i<b.length;i++)
		{
			result.addAll(is.doSort(b[i]));
		}
		return result;
	}
	
	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 "Bucket";
	}
	
	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 Bucket();
		SA.sort(seed1,10000);
//		SA.print();
		SA.sort(seed2,10000);
		SA.sort(seed3,10000);
		SA.sort(seed4,10000);
	}

}