基数排序/桶排序

算法思想

1.基数排序又称桶排序，具体思想就是将数值当成数组的下标保存。
2.将所有数值拿出个位来比较，例如值为m的就存入下标为m的数组中。
3.将比较后的数组拿出即为按个位排序好的数组，再将这个排序好的数组按十位排序。
4.比较完个十百千所有位数以后即排序完成。

图示排序过程

两种代码实现思路都是一样的，实现方式1可直接改写为C或C++。

代码实现1

private int[] array = {
    
    23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36};

/**
 * 基数排序，先按个位将所有数字按照个位的值放入0-9的二维数组中，依次取出之后再按十位
 * 如此循环直至个十百千等等所有位数遍历完为止
 */
private void radixSort() {
    
    

    // 定义二位数组用来存储每个基数以及基数下的数值
    int[][] temp;

    // 定义一维数组记录基数下保存了几位
    int[] position;

    int radix = 1;

    while (true) {
    
    
        position = new int[10];
        temp = new int[10][array.length];

        for (int i = 0; i < array.length; i++) {
    
    
            int value = (array[i] / radix) % 10;
            temp[value][position[value]] = array[i];
            position[value]++;
        }

        // 判断是否所有的数值都在0位上，都在0位上则表示排序完成
        if (position[0] == array.length) {
    
    
            break;
        }

        int index = 0;
        for (int i = 0; i < 10; i++) {
    
    
            for (int j = 0; j < position[i]; j++) {
    
    
                array[index] = temp[i][j];
                index++;
            }
        }

        radix = radix * 10;
    }
}

代码实现2

/**
 * 基数排序/桶排序
 */
public class BucktSort {
    
    

    /**
     * 待排序数组
     */
    private int[] originalArray;
    /**
     * 桶
     */
    private Map<String, List<Integer>> bucket;
    /**
     * 数组中，最长数字位数
     */
    private int maxLenght = 0;

    public BucktSort(int[] array) {
    
    
        originalArray = array;
        initBucket();
        getMaxLength();
    }

    private void initBucket() {
    
    
        if (null == bucket) {
    
    
            bucket = new HashMap<>(10);
        } else {
    
    
            bucket.clear();
        }
        for (int index = 0; index < 10; index++) {
    
    
            bucket.put(String.valueOf(index), new ArrayList<>());
        }
    }

    /**
     * 获取最长数字位数
     */
    private void getMaxLength() {
    
    
        for (int i = 0; i < originalArray.length; i++) {
    
    
            int temp = String.valueOf(originalArray[i]).length();
            if (temp > maxLenght) {
    
    
                maxLenght = temp;
            }
            continue;
        }
    }

    public int[] sort() {
    
    
        if (maxLenght == 0) {
    
    
            return originalArray;
        }

        int radix = 1;
        for (int index = 0; index < maxLenght; index++) {
    
    

            for (int i = 0; i < originalArray.length; i++) {
    
    
                String position = String.valueOf((originalArray[i] / radix) % 10);
                bucket.get(position).add(originalArray[i]);
            }

            int originalPosition = 0;
            for (int key = 0; key < 10; key++) {
    
    
                int j = 0;
                while (j < bucket.get(String.valueOf(key)).size()) {
    
    
                    originalArray[originalPosition] = bucket.get(String.valueOf(key)).get(j).intValue();
                    originalPosition++;
                    j++;
                }
            }

            initBucket();
            radix *= 10;
        }

        return originalArray;
    }

}