排序算法7-基数排序

描述

找出序列中值最大的元素,循环它的位数(个、十、百、千……),循环过程中依次对序列中的元素按位数排序,结束后得到有序序列

代码实现

/**
 * 基数排序(经典空间换时间)
 */
public class RadixSort {


    public static void main(String[] args) {
        //以下为推导过程
        int[] arr = {46, 1, 8, 9, 15, 233, 566};
        //桶数组
        int[][] bucket = new int[10][arr.length];
        //各桶数量记录数组(用来记录每个桶放置了多少个元素,bucketElementCount[2] = 第三个桶放置元素的数量)
        int[] bucketElementCount = new int[10];

        sort(arr);

//         /**
//         * 根据个位数放置
//         */
//        for (int i = 0; i < arr.length; i++) {
//            //拿到个位数
//            int digitOfElement = arr[i] % 10;
//            //与桶数组比较,确定放置位置
//            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
//            //放置元素的桶数量+1
//            bucketElementCount[digitOfElement]++;
//        }
//        int count = 0;
//        //按顺序从桶中取出元素,替换原数组
//        for (int i = 0; i < bucket.length; i++) {
//            if (bucketElementCount[i] != 0) {
//                for (int j = 0; j < bucketElementCount[i]; j++) {
//                    arr[count] = bucket[i][j];
//                    count++;
//                }
//                //清空各桶数量记录数组,用于下次放置
//                bucketElementCount[i] = 0;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
//
//        /**
//         * 根据十位数放置
//         */
//        for (int i = 0; i < arr.length; i++) {
//            //拿到十位数
//            int digitOfElement = arr[i] / 10 % 10;
//            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
//            bucketElementCount[digitOfElement]++;
//        }
//        count = 0;
//        for (int i = 0; i < bucket.length; i++) {
//            if (bucketElementCount[i] != 0) {
//                for (int j = 0; j < bucketElementCount[i]; j++) {
//                    arr[count] = bucket[i][j];
//                    count++;
//                }
//                bucketElementCount[i] = 0;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
//
//        /**
//         * 根据百位数放置
//         */
//        for (int i = 0; i < arr.length; i++) {
//            //拿到百位数
//            int digitOfElement = arr[i] / 100 % 10;
//            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
//            bucketElementCount[digitOfElement]++;
//        }
//        count = 0;
//        for (int i = 0; i < bucket.length; i++) {
//            if (bucketElementCount[i] != 0) {
//                for (int j = 0; j < bucketElementCount[i]; j++) {
//                    arr[count] = bucket[i][j];
//                    count++;
//                }
//                bucketElementCount[i] = 0;
//            }
//        }
//        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr) {
        int[][] bucket = new int[10][arr.length];
        int[] bucketElementCount = new int[10];

        //得到最大的数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        //得到数组中最大的数有几位
        int digitsNum = ("" + max).length();

        for (int z = 0, x = 1; z < digitsNum; z++, x *= 10) {
            for (int i = 0; i < arr.length; i++) {
                //拿到个位数
                int digitOfElement = arr[i] / x % 10;
                //与桶数组比较,确定放置位置
                bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
                //放置元素的桶数量+1
                bucketElementCount[digitOfElement]++;
            }
            int count = 0;
            //按顺序从桶中取出元素,替换原数组
            for (int i = 0; i < bucket.length; i++) {
                if (bucketElementCount[i] != 0) {
                    for (int j = 0; j < bucketElementCount[i]; j++) {
                        arr[count] = bucket[i][j];
                        count++;
                    }
                    //清空各桶数量记录数组,用于下次放置
                    bucketElementCount[i] = 0;
                }
            }
            System.out.println(Arrays.toString(arr));
        }

    }
}

性能

该算法属于非比较型排序算法,性能受序列大小n和序列中最大值位数m影响

所以最坏、最好、平均时间复杂度都是O(n*m)空间复杂度O(m)

属于稳定排序算法

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页