基数排序（桶排序） 经典空间换时间算法

基数排序（桶排序）

经典空间换时间算法

package sort;

import java.util.Arrays;
import java.util.Date;
import java.math.*;
import java.text.SimpleDateFormat;

/**
 * 基数排序（桶排序）
 * @author Administrator
 *
 */
public class RadixSort {

    public static void main(String[] args) {
        int arr[]=new int[8000000];

        Date date1=new Date();
        SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:sss");
        String date1str=s1.format(date1);
        System.out.println("排序前的时间"+date1str);
        System.out.println(date1);
        for(int i=0;i<8000000;i++) {
            arr[i]=(int) (Math.random()*80000000);
        }
        radixsort(arr);

        Date date2=new Date();
        SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:sss");
        String date1str1=s2.format(date2);
        System.out.println("排序后的时间"+date1str1);
        System.out.println(date2);
//		System.out.println(Arrays.toString(arr));
    }

    /**
     * 基数排序实现
     * @param arr
     */
    public static void radixsort(int arr[]) {

        //第一轮排序（针对每个元素的个位进行处理）


        //定义一个二维数组，表示十个桶，每个通就是一个一维数组
        //1.二维数组包含10个一维数组
        //2.为了防止数据溢出，每一个一维数组的长度必须设为arr.length
        int[][] bucket=new int[10][arr.length];

        //为了记录每个桶中实际存放了多少数据，我们定义一个一维数组来记录各个桶的有效数据
        int[] bucketEmlmentCounts = new int[10];

        int max=0;

        for(int j=0 ;j < arr.length;j++) {
            //取出每个元素的个数
//			int digiOfElement = arr[j] % 10;
//			//放入到对应的桶中
//			bucket[digiOfElement][bucketEmlmentCounts[digiOfElement]] =arr[j];
//			bucketEmlmentCounts[digiOfElement]++;

            //找出最大值
            if(arr[j] > max) {
                max=arr[j];
            }
        }
        int count=1;
        while(max/10!=0) {
            count++;
            max/=10;
        }
        for(int l=0,n=1;l<count;l++,n*=10) {
            for(int j=0 ;j < arr.length;j++) {
                //取出每个元素的个数
                int digiOfElement = (int) (arr[j] / Math.pow(10, l) % 10);

                //放入到对应的桶中
                bucket[digiOfElement][bucketEmlmentCounts[digiOfElement]] =arr[j];
                bucketEmlmentCounts[digiOfElement]++;

                //找出最大值
                if(arr[j] > max) {
                    max=arr[j];
                }
            }

            //按照这个桶的书序，取出数据，放入原来的数组
            //遍历每一个桶，并将桶中的数据放入到原数组
            int index=0;
            for(int k=0;k < bucketEmlmentCounts.length;k++) {
                //如果桶中有数据，我们才放入到原数组
                if(bucketEmlmentCounts[k] != 0) {
                    //表示当前桶有数据，则将数据放入
                    for(int i=0 ; i<bucketEmlmentCounts[k] ;i++) {
                        arr[index] = bucket[k][i];
                        index++;
                    }
                }
                //第一轮处理后需要将每个桶中的数据置零
                bucketEmlmentCounts[k]=0;
            }

//		System.out.println("第"+(l+1)+"轮处理的结果"+Arrays.toString(arr));
        }

    }

}