算法->链式基数排序

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第25天，点击查看活动详情

链式基数排序

所谓链式基数排序,就是实现基数排序时，为减少所需的辅助存储空间，应采用链表作存储结构，即链式基数排序。而基数排序也叫做多关键字排序，基数排序是一种借助“多关键字排序”的思想来实现“单关键字排序”的内部排序算法

算法思路

1、以静态链表存储待排记录，并令表头指针指向第一个记录；
2、“分配” 时，按当前“关键字位”所取值，将记录分配到不同的 “链队列” 中，每个队列中记录的 “关键字位” 相同；
3、“收集”时，按当前关键字位取值从小到大将各队列首尾相链成一个链表；
4、对每个关键字位均重复 2 和 3 两步。

实例分析

代码实现

package DataStructures.Sort;

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = new int[]{0, -44, 56, 0, 0, 89, -456, -12, 46, 9, 13, 45, -545, 0};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * @param arr
     * @author ZJ
     * Description 基数排序
     * date 2022-05-11 22:01:50 22:01
     */
    public static void radixSort(int[] arr) {
        int length = 0;

        //定义一个二维数组，表示10个桶，每个桶就是一个一维数组
        int[][] bucketGreaterZero = new int[10][arr.length];//很明显，基数排序使用了空间换时间
        int[][] bucketLessZero = new int[10][arr.length];//负数部分的数组

        //为了记录每个桶中实际存放了多少个数据，定义一个一维数组来记录每次放入数据的个数
        //比如bucketElementCounts[0]=3，意思是bucket[0]存放了3个数据
        int[] bucketGreaterZeroElementCounts = new int[10];
        int[] bucketLessZeroElementCounts = new int[10];

        int digitOfGreaterElement = 0;//每次取出的元素的位数
        int digitOfLessElement = 0;
        int i = 0;

        int index1 = 0;
        int index2 = 0;
        for (i = 0; i < arr.length; i++) {//先计算出arr数组里负数和正数分别有几个，再创建正数数组和负数数组（不然合并数组时容易数组越界）
            if (arr[i] >= 0) {
                index1++;//正数个数（包含0）
            } else {
                index2++;//负数个数
            }
        }

        int[] arrLessZero = new int[index2];
        int[] arrGreaterZero = new int[arr.length - index2];

        index1 = 0;
        index2 = 0;

        //分别往正数数组和负数数组里添加数据
        for (i = 0; i < arr.length; i++) {
            if (arr[i] >= 0) {
                arrGreaterZero[index1] = arr[i];
                index1++;
            } else {
                arrLessZero[index2] = arr[i];
                index2++;
            }
        }

        //让负数数组里的数据变成正数
        for (i = 0; i < arrLessZero.length; i++) {
            if (arrLessZero[i] != 0) {
                arrLessZero[i] *= (-1);
            }
        }

        //找到正数数组中最大数的位数
        int maxGreaterZero = 0;
        for (i = 0; i < arrGreaterZero.length; i++) {
            if (maxGreaterZero < String.valueOf(arrGreaterZero[i]).length()) {
                maxGreaterZero = String.valueOf(arrGreaterZero[i]).length();
            }
        }

        //找到负数数组中最大数的位数
        int maxLessZero = 0;
        for (i = 0; i < arrLessZero.length; i++) {
            if (maxLessZero < String.valueOf(arrLessZero[i]).length()) {
                maxLessZero = String.valueOf(arrLessZero[i]).length();
            }
        }

        int index = 0;
        int n1 = 1;
        for (i = 0, n1 = 1; i < maxLessZero; i++, n1 *= 10) {
            //第i+1轮排序（针对每个元素的位进行排序处理）
            for (int j = 0; j < arrLessZero.length; j++) {
                digitOfLessElement = arrLessZero[j] / n1 % 10;//取出每个元素的位
                bucketLessZero[digitOfLessElement][bucketLessZeroElementCounts[digitOfLessElement]] = arrLessZero[j];//放入对应的桶
                bucketLessZeroElementCounts[digitOfLessElement]++;
            }
            //按照这个桶的顺序（一维数组的下标取出数据），放入原来的数组
            index = 0;
            //遍历每一个桶，并将桶中数据放入原数组
            for (int k = 0; k < bucketLessZeroElementCounts.length; k++) {
                //如果桶中有数据，我们才放到原数组
                if (bucketLessZeroElementCounts[k] != 0) {
                    //循环第k个桶，放入
                    for (int l = 0; l < bucketLessZeroElementCounts[k]; l++) {
                        arrLessZero[index] = bucketLessZero[k][l];
                        index++;
                    }
                }
                bucketLessZeroElementCounts[k] = 0;//置零!!!!!
            }
        }


        //临时数组，从后往前遍历负数数组元素再乘上-1，保存到temp数组里，这样负数部分就排序好了
        int[] temp = new int[arrLessZero.length];
        int index3 = 0;
        for (i = arrLessZero.length - 1; i >= 0; i--) {
            temp[index3] = arrLessZero[i] * (-1);
            index3++;
        }


        int n2 = 1;
        for (i = 0, n2 = 1; i < maxGreaterZero; i++, n2 *= 10) {
            //第i+1轮排序（针对每个元素的位进行排序处理）
            for (int j = 0; j < arrGreaterZero.length; j++) {
                digitOfGreaterElement = arrGreaterZero[j] / n2 % 10;//取出每个元素的位
                bucketGreaterZero[digitOfGreaterElement][bucketGreaterZeroElementCounts[digitOfGreaterElement]] = arrGreaterZero[j];//放入对应的桶
                bucketGreaterZeroElementCounts[digitOfGreaterElement]++;
            }
            //按照这个桶的顺序（一维数组的下标取出数据），放入原来的数组
            index = 0;
            //遍历每一个桶，并将桶中数据放入原数组
            for (int k = 0; k < bucketGreaterZeroElementCounts.length; k++) {
                //如果桶中有数据，我们才放到原数组
                if (bucketGreaterZeroElementCounts[k] != 0) {
                    //循环第k个桶，放入
                    for (int l = 0; l < bucketGreaterZeroElementCounts[k]; l++) {
                        arrGreaterZero[index] = bucketGreaterZero[k][l];
                        index++;
                    }
                }
                bucketGreaterZeroElementCounts[k] = 0;//置零!!!!!
            }
        }
        //合并数组
        System.arraycopy(temp, 0, arr, 0, temp.length);//把temp数组里的元素复制到arr数组里
        System.arraycopy(arrGreaterZero, 0, arr, temp.length, arrGreaterZero.length);//把arrGreaterZero数组里的元素合并到arr数组里
    }
}