排序算法-基数排序

算法思想

基数排序是采用多关键字排序思想（即基于关键字各位的大小进行排序地），借助“分配”、“收集”两种操作对单逻辑关键字进行排序。基数排序又分为最高位优先(MSD)排序和最低位优先(LSD)排序。

以r为基数的最低位优先基数排序过程：假设线性表是由节点序列$a_0,a_1...a_{n-1}$构成，每个节点$a_j$的关键字由$d$元组$(k_j^{d-1},k_j^{d-2},...,k_j^1,k_j^0)$组成，其中$0<=k_j^i<=r-1$(0<=j<n,0<=i<=d-1)。

这段话要如何理解呢？以十进制数排序为例。其基数就为$0$~$9$，r=10，假设线性表中一个元素的数值为384，该关键字就由3元组$(3,8,4)$组成，即由百位、十位、个位组成，其d值就为3。

在排序的过程中，需要使用r个队列$Q_0,Q_1,...,Q_{r-1}$。排序过程如下：

分配：开始时，把$Q_0,Q_1,...,Q_{r-1}$各个队列置为空队列，然后依次考察线性表中的每一个结点$a_j$，如果$a_j$的关键字$k_j^i=k$，就把$a_j$放入$Q_k$队列中。

收集：把$Q_0,Q_1,...,Q_{r-1}$各个队列中的结点首尾相接，得到新的结点序列，从而组成新的线性表。

基数排序的过程

基数从最低位开始从小到大收集

基数从最低位开始从大到小收集。

基数排序完整代码实现（输出结果升序）：

package com.sort;

import java.util.LinkedList;
import java.util.Queue;

public class BaseSort {
    public static void main(String[] args) {
        int[] nums = {3,89,4,53,6,825,900,0,1000,53};
        basesort(nums,nums.length);
        System.out.println("最终输出结果:");
        for(int num:nums){
            System.out.print(num+" ");
        }


    }
    public static void basesort(int[] nums,int len){
        int max = 0; //寻找待排序数组中的最大值，以确定位数d
        for(int num:nums)
            max = Math.max(max,num);
        int d = GetNum_d(max);
        //建立分配和收集队列,十进制数总共需要0~9，十个队列
        Queue<Integer>[] queues = new Queue[10];
        //初始化这10个队列
        for(int i=0;i<10;++i){
            queues[i] = new LinkedList<>();
        }
        //根据位数d来确定 分配和收集 的趟数
        for(int i=0;i<d;++i){
            //分配
            for(int num:nums){
                int temp = num;
                num /= (int)Math.pow(10,i);
                queues[num%10].offer(temp);
            }
            //收集,降序排列所以从最低位开始收集
            int k = 0;
            for(int j=0;j<10;++j){
                while(!queues[j].isEmpty() && k<len){
                    nums[k++] = queues[j].poll();
                }
            }
            System.out.printf("第 %d 趟收集之后的结果:\n",i);
            for(int num:nums){
                System.out.print(num+" ");
            }
            System.out.println();
        }
    }
    public static int GetNum_d(int num){
        int d = 1;
        while(num/10!=0){
            num /=10;
            d++;
        }
        return d;
    }

}

输出结果：

复杂度分析

主要针对上述代码实现，不同语言分析会有所不同。

时间复杂度
一趟分配的时间复杂度为$O(n)$，一趟收集的时间复杂度为$O(r+n)$，总共需要d趟分配收集，时间复杂度为$O(d(2n+r))$，即$O(d(n+r))$.

空间复杂度
需要r个辅助队列，r个辅助队列每趟最多需要入队n次。所以空间复杂度为$O(r+n)$。

稳定性：稳定。