基数排序

目录

• 基础版本
• 进阶版本

基础版本

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class RadixSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }

        List<LinkedList<Integer>> buckets = new ArrayList<>(10);
        for (int i = 0; i < 10; ++i) {
            buckets.add(new LinkedList<>());
        }

        // 10
        int maxLength = 0;

        for (int i = 0; i < arr.length; ++i) {
            maxLength = Math.max(maxLength, (int) Math.log10(arr[i]) + 1);
        }

        int base = 1;
        while (maxLength-- > 0) {
            for (int i = 0; i < arr.length; ++i) {
                int bucket = arr[i] / base % 10;
                buckets.get(bucket).addLast(arr[i]);
            }

            int count = 0;

            for (int i = 0; i < 10; ++i) {
                LinkedList<Integer> bucket = buckets.get(i);
                while (!bucket.isEmpty()) {
                    arr[count++] = bucket.pollFirst();
                }
            }
            base *= 10;
        }
    }

    public static void main(String[] args) {
        int maxValue = 1000;
        for (int i = 0; i < 100000; i++) {
            int len = Standard.generateRandomLen(100);
            int[] arr = Standard.generateRandomArray(len, maxValue);
            int[] copy = Arrays.copyOf(arr, arr.length);
            Arrays.sort(arr);
            RadixSort.sort(copy);
            if (!Standard.isRight(arr, copy)) {
                System.out.println("失败了");
            }
        }
        System.out.println("test finish");
    }

}

class Standard {

    public static boolean isRight(int[] a, int[] b) {
        if (a == null) {
            return b == null;
        }
        if (b == null) {
            return false;
        }
        if (a.length != b.length) {
            return false;
        }
        for (int i = 0; i < a.length; ++i) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
    }

    public static int[] generateRandomArray(int len, int maxValue) {
        int[] res = new int[len];
        for (int i = 0; i != res.length; i++) {
            res[i] = (int) (Math.random() * maxValue);
        }
        return res;
    }

    public static int generateRandomLen(int limit) {
        return (int) (Math.random() * limit + 1);
    }
}

进阶版本

import java.util.Arrays;

public class RadixSort {

    public static int getDigit(int data, int x) {
        int res = 0;
        while (x-- > 0) {
            res = data % 10;
            data /= 10;
        }
        return res;
    }

    public static int getMaxBits(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int max = arr[0];
        for (int i = 1; i < arr.length; ++i) {
            max = Math.max(max, arr[i]);
        }

        int res = 0;
        while (max > 0) {
            res++;
            max /= 10;
        }
        return res;
    }

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int radix = 10;
        int[] helper = new int[arr.length];
        int maxDigits = getMaxBits(arr);
        for (int d = 1; d <= maxDigits; ++d) {

            int[] count = new int[radix];

            for (int i = 0; i < arr.length; ++i) {
                count[getDigit(arr[i], d)]++;
            }

            for (int i = 1; i < radix; ++i) {
                count[i] += count[i - 1];
            }

            for (int i = arr.length - 1; i >= 0; --i) {
                helper[--count[getDigit(arr[i], d)]] = arr[i];
            }

            System.arraycopy(helper, 0, arr, 0, arr.length);
        }
    }

    public static void main(String[] args) {
        int maxValue = 1000;
        for (int i = 0; i < 100000; i++) {
            int len = Standard.generateRandomLen(100);
            int[] arr = Standard.generateRandomArray(len, maxValue);
            int[] copy = Arrays.copyOf(arr, arr.length);
            Arrays.sort(arr);
            RadixSort.sort(copy);
            if (!Standard.isRight(arr, copy)) {
                System.out.println("失败了");
            }
        }
        System.out.println("test finish");
    }

}

class Standard {

    public static boolean isRight(int[] a, int[] b) {
        if (a == null) {
            return b == null;
        }
        if (b == null) {
            return false;
        }
        if (a.length != b.length) {
            return false;
        }
        for (int i = 0; i < a.length; ++i) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
    }

    public static int[] generateRandomArray(int len, int maxValue) {
        int[] res = new int[len];
        for (int i = 0; i != res.length; i++) {
            res[i] = (int) (Math.random() * maxValue);
        }
        return res;
    }

    public static int generateRandomLen(int limit) {
        return (int) (Math.random() * limit + 1);
    }
}