基數排序 和桶排序

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class RadixSort{

	public static void radixSort(int arr[], int maxDigits){
		int exp = 1;//10^0;
		for(int i =0; i < maxDigits; i++){
			ArrayList bucketList[] = new ArrayList[10];
			for(int k=0; k < 10; k++){
				bucketList[k] = new ArrayList();
			}
			for(int j =0; j < arr.length; j++){
				int number = (arr[j]/exp)%10;
				bucketList[number].add(arr[j]);
			}
			exp *= 10;
			int index =0;
			for(int k=0; k < 10; k++){
				for(int num: (ArrayList<Integer>)bucketList[k]){
					arr[index] = num;
					index++;
				}
			}
		}

		System.out.println("Sorted numbers");
		for(int i =0; i < arr.length; i++){
			System.out.print(arr[i] +", ");
		}
	}
	
	public static void radixSort1( int[] a)
    {
        int i, m = a[0], exp = 1, n = a.length;
        int[] b = new int[10];
        for (i = 1; i < n; i++)
            if (a[i] > m)
                m = a[i];
        while (m / exp > 0)
        {
            int[] bucket = new int[10];
 
            for (i = 0; i < n; i++)
                bucket[(a[i] / exp) % 10]++;
            for (i = 1; i < 10; i++)
                bucket[i] += bucket[i - 1];
            for (i = n - 1; i >= 0; i--)
                b[--bucket[(a[i] / exp) % 10]] = a[i];
            for (i = 0; i < n; i++)
                a[i] = b[i];
            exp *= 10;        
        }
    }    
	
    public static void radixSort(int[] arr){
        if(arr.length == 0)
            return;
        int[][] np = new int[arr.length][2];
        int[] q = new int[0x100];
        int i,j,k,l,f = 0;
        for(k=0;k<4;k++){
            for(i=0;i<(np.length-1);i++)
                np[i][1] = i+1;
            np[i][1] = -1;
            for(i=0;i<q.length;i++)
                q[i] = -1;
            for(f=i=0;i<arr.length;i++){
                j = ((0xFF<<(k<<3))&arr[i])>>(k<<3);
                if(q[j] == -1)
                    l = q[j] = f;
                else{
                    l = q[j];
                    while(np[l][1] != -1)
                        l = np[l][1];
                    np[l][1] = f;
                    l = np[l][1];
                }
                f = np[f][1];
                np[l][0] = arr[i];
                np[l][1] = -1;
            }
            for(l=q[i=j=0];i<0x100;i++)
                for(l=q[i];l!=-1;l=np[l][1])
                        arr[j++] = np[l][0];
        }
    }

    public static void radixSort4(int A[], int B[], int n, int b, int r, int C[]){
    	int j ; 
    	int m = b/r;
    	int radix2 = 1;
    	for(int i = 0; i <r; i++){
    		radix2 *= 2;
    	}
    	for(int i = 0, t = 1; i < m; i++, t*=radix2){
    		for(j = 0; j < radix2; j++){
    			C[j] = 0;
    		}
    		
    		for(j = 0; j < n; j++){
    			C[(A[j]/t)%radix2]++;
    		}
    		
    		for(j = 1; j < radix2; j++){
    			C[j] = C[j - 1] + C[j];
    		}
    		
    		for(j = n -1 ; j >= 0; j--){
    			B[--C[(A[j]/t)%radix2]] = A[j];
    		}
    		
    		for(j = 0; j < n; j++){
    			A[j] = B[j];
    		}
    	}
    }
    /**
	 * place elements in data into order
	 *
	 * @param data array of positive integer values
	 */
	public static void radixSort2(int [ ] data) {
		boolean flag = true;
		int divisor = 1;
		Queue [ ] buckets = new Queue[10];
		for (int i = 0; i < 10; i++)
			buckets[i] = new LinkedList<Integer>();

		while (flag) {
			flag = false;
				// first copy the values into buckets
			for (int i = 0; i < data.length; i++) {
				int hashIndex = (data[i] / divisor) % 10;
				if (hashIndex > 0) flag = true;
				((LinkedList<Integer>)buckets[hashIndex]).addLast(new Integer(data[i]));
			}
				// then copy the values back into vector
			divisor *= 10;
			int i = 0;
			for (int j = 0; j < 10; j++) {
				while (! buckets[j].isEmpty()) {
					Integer ival = (Integer) ((LinkedList<Integer>)buckets[j]).getFirst();
					((LinkedList<Integer>)buckets[j]).removeFirst();
					data[i++] = ival.intValue();
				}
			}
		}
	}
	
	 // Sort the numbers beginning with least-significant digit
    public static int[] radixSort3(int[] input){
 
        // Largest place for a 32-bit int is the 1 billion's place
        for(int place=1; place <= 1000000000; place *= 10){
            // Use counting sort at each digit's place
            input = countingSort(input, place);
        }
 
        return input;
    }
 
    private static int[] countingSort(int[] input, int place){
        int[] out = new int[input.length];
 
        int[] count = new int[10];
 
        for(int i=0; i < input.length; i++){
            int digit = getDigit(input[i], place);
            count[digit] += 1;
        }
 
        for(int i=1; i < count.length; i++){
            count[i] += count[i-1];
        }
 
        for(int i = input.length-1; i >= 0; i--){
            int digit = getDigit(input[i], place);
 
            out[count[digit]-1] = input[i];
            count[digit]--;
        }
 
        return out;
 
    }
 
    private static int getDigit(int value, int digitPlace){
        return ((value/digitPlace ) % 10);
    }
	
    public static void main(String[] args){
        int i;
        int[] arr = new int[10];
        int[] arr1 = new int[10];
        int[] arr2 = new int[256];
        System.out.print("original: ");
        for(i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random() * 1024);
            System.out.print(arr[i] + " ");
        }
        //radixSort(arr);
        //radixSort(arr, 4);
        //radixSort2(arr);
        radixSort4(arr, arr1, 10, 32, 8, arr2);
        System.out.print("\nsorted: ");
        for(i=0;i<arr.length;i++)
            System.out.print(arr[i] + " ");
        System.out.println("\nDone ;-)");
    }
}