Java 基数排序和计数排序

我现在正在研究实现计数排序的基数排序。我想我已经大致理解并遵循了伪代码，但我得到了一个数组越界错误：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 12
    at RunRadixSort.radixSort(RunRadixSort.java:47)
    at RunRadixSort.main(RunRadixSort.java:15)

我的代码

import java.text.DecimalFormat;
    import java.util.Arrays;


   import java.text.DecimalFormat;
import java.util.Arrays;


public class RunRadixSort {


    public static void main(String[] args) {

        int[] sortNumbers = {4,5,6,2,3,7,2,1,23,5,13};
        int[] sorted = new int[sortNumbers.length];
        DecimalFormat df = new DecimalFormat("#.########");
        int max = getMax(sortNumbers);
        long timeStart = System.nanoTime();
        sorted = radixSort(sortNumbers, max);
        long timeEnd = System.nanoTime();
        long elapsedTime = timeEnd - timeStart;
        double time = (double)elapsedTime / 1000000;
        System.out.println(Arrays.toString(sorted));
        System.out.println("\nTotal Execution Time: " + df.format(time)+ " miliseconds");
    }

    public static int getMax(int[] A){
        int max = A[0];
        for(int i = 1; i < A.length; i++){
            if(A[i] > max){
                max = A[i];
            }
        }
        return max;
    }

    public static int[] radixSort(int[] A, int d){
        int[] B = new int[A.length];
        int[] C = new int[d + 1];
        for(int i = 0; i < d; i++){
            for(int k = 0; k < A.length; k++){
                C[A[k]]++;
            }
            int total = 0;
            for(int l = 0; l < d; l++){
                int temp = C[l];
                C[l] = total;
                total += temp;
            }
            for(int m = 0; m < A.length; m++){
                B[C[A[m]]] = A[m];
                C[A[m]]++;
            }
        }
        return B;
    }
}

导入java.text.DecimalFormat；
导入java.util.array；
导入java.text.DecimalFormat；
导入java.util.array；
公共类RunRadixSort{
公共静态void main（字符串[]args）{
int[]sortNumbers={4,5,6,2,3,7,2,1,23,5,13}；
int[]排序=新的int[sortNumbers.length]；
DecimalFormat df=新的DecimalFormat（“#.##########””；
int max=getMax（sortNumbers）；
long timeStart=System.nanoTime（）；
排序=半径排序（排序编号，最大值）；
long-timeEnd=System.nanoTime（）；
long elapsedTime=timeEnd-timeStart；
加倍时间=（加倍）延时时间/1000000；
System.out.println（Arrays.toString（sorted））；
System.out.println（“\n总执行时间：“+df.format（Time）+”毫秒”）；
}
公共静态int getMax（int[]A）{
int max=A[0]；
for（int i=1；imax）{
max=A[i]；
}
}
返回最大值；
}
公共静态int[]radixSort（int[]A，int-d）{
int[]B=新的int[A.长度]；
int[]C=新的int[d+1]；
对于（int i=0；i

您没有增加j。这可能是一个打字错误：

 for(int j = 0; j < d; i++){

for（int j=0；j

试试这个：

for(int j = 0; j < d; j++){

for（int j=0；j

在（int j=0；j

它应该是（intj=0；j

而且， 行

C[A[k]]=C[A[k]]+1；

当k=8和A[k]=23时，您将获得ArrayOutOfBoundsException，因为当声明C[]时，它被声明为长度为23的数组，只能从0到22（包括0到22）进行索引。实际值范围应包括0到最大值

因此，您需要将C[]声明为

int[]C=newint[d+1]；

或将值存储到 <代码> c[a[k] - 1 ]＝c[a[k] - 1 ] + 1；< />代码，这取决于在输入数组排序中是否考虑到0是可接受的值。

但是问题和代码发生了变化。这段代码对值求和，并逐渐将它们添加到数组C中

  for(int l = 0; l < d; l++){
            int temp = C[l];
            C[l] = total;
            total += temp;
        }

for（int l=0；l

然后是下一个街区

 for(int m = 0; m < A.length; m++){
            B[C[A[m]]] = A[m];
            C[A[m]]++;
        }

for（int m=0；m

使用数组C中的条目值作为数组B中的索引，但是B的大小与数组A相同

---

你确定C应该保存值的总数而不是出现的值的总数吗？

好的，那么我回到了我上面发布的越界错误。很抱歉它在这里（int m=0；m