Java实现基数排序

文章采用Java实现了基数排序

基数排序的基本思想：首先对数组的所有数字按照数字的最后一位进行排序，（在十进制下，因为每个数字都是0-9,所以我们可以申请一个长度为10的桶）,根据每个数字末尾数的数字放入相应的桶中，例如 125的末尾数是5，我们放入bucket[5] 中，1的末尾是1 ，我们放入buckets[1] 中，这样排序放完之后，所有的数字都按照其末尾数字的大小排序好了。

第一遍排序玩之后，开始按照倒数第二位数来对桶中的元素进行排序，例如125 原来是在bucket[5] 中 ，现在按照倒数第二位来排序，应该放到bucket[2] 中，而 1 只有一位，所以应该往前补齐数位为001，此时其倒数第二个数是0，所以移动到bucket[0]中间。

基数排序是稳定的，因为我们在从前往后遍历每个数的时候，如果有两个相同的数字，第一个数字总是在第二个数字之前放入桶中，此时两个数字的相对顺序是保持不变的。所以基数排序是稳定的算法。

package com.neway.sort;

import java.util.ArrayList;

/**
 * Created by Neway on 2015/10/21.
 */
public class BucketSort implements Sort{
    public static void main(String[] s) {
        Sort sort = new BucketSort();
        int arr [] = {12,5,6,98,23,569,125,58,9,36};
        sort.sort(arr);
    }

    @Override
    public void sort(int[] arr) {
        ArrayList<Integer> buckets [] = new ArrayList[10];
        for(int i = 0; i < 10 ;i++) {
            buckets[i] = new ArrayList<>();
        }

        int LSDTimes = String.valueOf(getMax(arr)).length();
        for(int lsdTime = LSDTimes - 1; lsdTime > -1; lsdTime-- ) {
            for(int i = 0; i < arr.length ; i++){
                    //将数位补齐
                    String numStr = String.format("%0"+LSDTimes + "d",arr[i]);
                    int num = numStr.charAt(lsdTime) - 48; //0 和 '0' 的ASCII码值相差 48。
                    // 将数字放入相应的桶中
                    buckets[num % 10].add(Integer.valueOf(arr[i]));

                    // 将数字从上一个桶中移除掉。
                    if(lsdTime != LSDTimes - 1) {
                        int preNum = numStr.charAt(lsdTime + 1) - 48;
                        if(buckets[preNum % 10].contains(Integer.valueOf(arr[i]))) {
                            buckets[preNum % 10].remove(Integer.valueOf(arr[i]));
                        }
                    }
            }

            int index = 0;
            /**
             * 将桶中现在的数字赋值给数组，每次排序都是基于上个数位
             * 已经排好的顺序来进行的。
             */
            for(ArrayList<Integer> arrayList : buckets) {
                for(int i : arrayList) {
                    System.out.print(i + "  ");
                    arr[index] = i;
                    index++;
                }
            }
            System.out.println();
        }
    }

    /**
     * 获取最大的数字，主要是为了获取LSD(Least Significant Digit)
     * 需要遍历的次数，说白了就是最大的数位是多长。
     * @param arr
     * @return
     */
    public int getMax(int arr[]) {
        int max = 0;
        for(int i : arr) {
            if(i > max) {
                max = i;
            }
        }
        return max;
    }
}

上面的例子当然中，只考虑了数组中数字为整数的情况，在处理负数的时候，可以先确定一个数字，数组中所有的数字都加上了这个数字之后全部为正数，然后排序，排序了之后再把这个数字剪掉。
下面是一个简单的例子，把数组里面的数字都加上 100，然后排序，排序了之后再减掉。

package com.neway.sort;

import java.util.ArrayList;

/**
 * Created by Neway on 2015/10/21.
 */
public class BucketSort implements Sort{
    public static void main(String[] s) {
        Sort sort = new BucketSort();
        int arr [] = {-12,5,6,98,-5,569,125,-58,9,36};
        sort.sort(arr);
    }

    @Override
    public void sort(int[] array) {
        ArrayList<Integer> buckets [] = new ArrayList[10];
        for(int i = 0; i < 10 ;i++) {
            buckets[i] = new ArrayList<>();
        }

        int LSDTimes = String.valueOf(getMax(array)).length();
        for(int lsdTime = LSDTimes - 1; lsdTime > -1; lsdTime-- ) {
            for(int i = 0; i < array.length ; i++){
                    array[i] += 100;
                    //将数位补齐
                    String numStr = String.format("%0"+LSDTimes + "d",array[i]);
                    int num = numStr.charAt(lsdTime) - 48; //0 和 '0' 的ASCII码值相差 48。
                    // 将数字放入相应的桶中
                    buckets[num % 10].add(Integer.valueOf(array[i]));

                    // 将数字从上一个桶中移除掉。
                    if(lsdTime != LSDTimes - 1) {
                        int preNum = numStr.charAt(lsdTime + 1) - 48;
                        if(buckets[preNum % 10].contains(Integer.valueOf(array[i]))) {
                            buckets[preNum % 10].remove(Integer.valueOf(array[i]));
                        }
                    }
            }

            int index = 0;
            /**
             * 将桶中现在的数字赋值给数组，每次排序都是基于上个数位
             * 已经排好的顺序来进行的。
             */
            for(ArrayList<Integer> arrayList : buckets) {
                for(int i : arrayList) {
                    System.out.print((i - 100) + "  ");
                    array[index] = (i - 100);
                    index++;
                }
            }
            System.out.println();
        }
    }

    /**
     * 获取最大的数字，主要是为了获取LSD(Least Significant Digit)
     * 需要遍历的次数，说白了就是最大的数位是多长。
     * @param arr
     * @return
     */
    public int getMax(int arr[]) {
        int max = 0;
        for(int i : arr) {
            if(i > max) {
                max = i;
            }
        }
        return max;
    }
}