我不知道是什么让我的基数排序方法搞砸了

Question

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

public class RadixSort {

    public static void main(String[] args) {
        int[] data = { 5, 126, 75, 10, 15, 634, 9 };

        data = radixSort(data);

        for (int nums : data) {
            System.out.println(nums);
        }
    }

    public static int[] radixSort(int[] in) {
        Queue<Integer> zero = new LinkedList<>();
        Queue<Integer> one = new LinkedList<>();
        Queue<Integer> two = new LinkedList<>();
        Queue<Integer> three = new LinkedList<>();
        Queue<Integer> four = new LinkedList<>();
        Queue<Integer> five = new LinkedList<>();
        Queue<Integer> six = new LinkedList<>();
        Queue<Integer> seven = new LinkedList<>();
        Queue<Integer> eight = new LinkedList<>();
        Queue<Integer> nine = new LinkedList<>();

        for (int pass = 3; pass > 0; pass--) {
            for (int nums : in) {
                System.out.println(nums);
            }
            System.out.println("pass " + (3 - pass));
            for (int i = 0; i < in.length; i++) {
                int num = (int) ((in[i] / Math.pow(10, pass)) % 10);
                switch (num) {
                case 0:
                    zero.add(in[i]);
                    break;
                case 1:
                    one.add(in[i]);
                    break;
                case 2:
                    two.add(in[i]);
                    break;
                case 3:
                    three.add(in[i]);
                    break;
                case 4:
                    four.add(in[i]);
                    break;
                case 5:
                    five.add(in[i]);
                    break;
                case 6:
                    six.add(in[i]);
                    break;
                case 7:
                    seven.add(in[i]);
                    break;
                case 8:
                    eight.add(in[i]);
                    break;
                case 9:
                    nine.add(in[i]);
                    break;
                default:
                }
            }
            int[] newArr = new int[in.length];
            int arrSize = 0;
            if (zero.size() > 0) {
                int size = zero.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = zero.poll();
                    arrSize++;
                }
            }
            
            if (one.size() > 0) {
                int size = one.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = one.poll();
                    arrSize++;
                }
            }
            
            if (two.size() > 0) {
                int size = two.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = two.poll();
                    arrSize++;
                }
            }
            
            if (three.size() > 0) {
                int size = three.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = three.poll();
                    arrSize++;
                }
            }

            if (four.size() > 0) {
                int size = four.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = four.poll();
                    arrSize++;
                }
            }

            if (five.size() > 0) {
                int size = five.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = five.poll();
                    arrSize++;
                }
            }

            if (six.size() > 0) {
                int size = six.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = six.poll();
                    arrSize++;
                }
            }

            if (seven.size() > 0) {
                int size = seven.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = seven.poll();
                    arrSize++;
                }
            }

            if (eight.size() > 0) {
                int size = eight.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = eight.poll();
                    arrSize++;
                }
            }

            if (nine.size() > 0) {
                int size = nine.size();
                for (int k = 0; k < size; k++) {
                    newArr[arrSize] = nine.poll();
                    arrSize++;
                }
            }
            in = newArr;
        }
        return in;
    }
}

this prints out:

5 126 75 10 15 634 9 pass 0 5 126 75 10 15 634 9 pass 1 5 75 10 15 9 126 634 pass 2 5 9 10 15 126 634 75

I know that it has to do something with the fact that on the pass where I am checking for the 10s slot that 7 is the largest value. It forgets that 126 and 634 are still bigger, they just have lesser value in the 10s slot. But I do not know how to make it so that it maintains the order of 100s.

Answer 1

Only one small issue in your code with the loop counting the passes:

for (int pass = 3; pass > 0; pass--)

As you can see the variable pass can never reach zero, which means that your sorting never considers the last digit of your numbers. Also, you consider the most-significant digits first but reorder all numbers in the later passes. This means you should also revert the order of digit evaluation. To do this simply change the for loop to this:

for (int pass = 0; pass < 3; pass++)

This results in the following output (last section is sorted):

5
126
75
10
15
634
9
pass 3
10
634
5
75
15
126
9
pass 2
5
9
10
15
126
634
75
pass 1
5
9
10
15
75
126
634

PS: One pass can also be removed as your numbers are all below 1000.