• 后面会解答自己在写时的问题

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @description:       为什么要开10个结点空间？
 *                     为什么后面data数组迭代时需要用链表一直往后迭代
 *                     解答在后面
 * @author: HaHa
 * @time: 2022/4/20 10:19
 */

public class 基数排序 {
    public static void main(String[] args) {
        long t1=System.currentTimeMillis();
        Scanner scanner = new Scanner(new BufferedInputStream(System.in));
        int[] a={13,444,789,24,11};
        int[] sort = radixSort(a);
        System.out.println(Arrays.toString(sort));
        System.out.println(System.currentTimeMillis()-t1);
    }

    private static int[] radixSort(int[] data) {
        RadixNode[] head=new RadixNode[10];
        RadixNode current,nextNode;
        int max=0,length=0;
        for (int temp : data) {
            max=Math.max(temp,max);
        }
        length=String.valueOf(max).length();
        int power=0;
        for (int i = 0; i < length; i++) {
            if (i==0){
                power=1;
            }else {
                power*=10;
            }
            for (int j = 0; j < 10; j++) {
                head[j]=new RadixNode();
            }
            for (int j = 0; j < data.length; j++) {
                int radix=data[j]/power-(data[j]/(power*10))*10;
                current=new RadixNode();
                current.data=data[j];
                current.next=null;
                nextNode=head[radix].next;
                if (nextNode==null){
                    head[radix].next=current;
                }else {
                    while (nextNode.next!=null){
                        nextNode=nextNode.next;
                    }
                    nextNode.next=current;
                }
                int l=0;
                for (int k = 0; k < 10; k++) {
                    nextNode=head[k].next;
                    while (nextNode!=null){
                        data[l]=nextNode.data;
//                        System.out.print(data[l]+" ");
                        l++;
                        nextNode=nextNode.next;
                    }
                }
//                System.out.println();
            }
        }
        return data;
    }


    public static class RadixNode{
        int data;
        RadixNode next;
    }
}

基数排序的思路

• 他是根据个位数到最高位进行排序，然后看最大数是几位，就迭代几次
  123 87 956 57 312
  1.个位 321 123 956 87 57
  2.十位 312 123 956 57 87

1. 因为他是基数排序，从个位到后面进行排序，一个数只有0-9，所有开10个空间即可
   2.先看一张图解吧
   

因为一个head[i]结点会存在多个数，所以需要用链表遍历，他会存在多个1或者其他数

标签：10,int,nextNode,System,next,基数排序,data
来源： https://www.cnblogs.com/rain-me/p/16169092.html