Java 计数排序程序

我编写了这段代码，用于使用计数排序对数组的元素进行排序。程序编译并运行，但没有给出正确的输出。我希望元素按非降序排序。我得到的输出按非降序排序，但值与我输入的值不同。我已经检查了代码很多次，但我无法发现错误。请帮忙

import java.io.*;

public class Main {
public static void main(String aa[]) {

    try {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

        int t = Integer.parseInt(input.readLine());
        int a [] = new int[t];
        int c [] = new int[t];
        int max = 0;

        if(t<=1000000) {

            for(int i = 0; i<t; i++) {
                int n = Integer.parseInt(input.readLine());
                if(n>=0 && n<=1000000) {
                    a[i] = n;
                    if(n>max) max = n;
                }
            }

            int b[] = new int[max+1];

            for(int i = 0; i<max+1; i++)
                b[i] = 0;

            for(int i = 0; i<t; i++)
                b[a[i]] += 1;

            for(int i = 1; i<max+1; i++)
                b[i] += b[i-1];

            for (int i = t-1; i>=0; i--) {
                c[b[a[i]]] = a[i];
                b[a[i]]--;
            }

            for (int i = 0; i<t; i++) 
                System.out.println(c[i]);

        }
        else 
            System.exit(0);
    } catch (Exception e) {System.out.println(e);}
  }
}

import java.io.*；
公共班机{
公共静态void main（字符串aa[]{
试一试{
BufferedReader输入=新的BufferedReader（新的InputStreamReader（System.in））；
int t=Integer.parseInt（input.readLine（））；
int a[]=新的int[t]；
int c[]=新的int[t]；
int max=0；
如果（t关于你错的地方你是对的。改变：

for (int i = t-1; i>=0; i--) {
     c[b[a[i]]] = a[i];
     b[a[i]]--;
}

进入：

for（int i=0；i您几乎答对了。更改以下行（关闭一个错误）

for（int i=0；i
请使用此选项进行计数排序：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Counting sort.
 */
public class CountingSort {

    static int[] countingSort(int[] arr) {
        int arrMax = Arrays.stream(arr).max().getAsInt();
        int[] occurances = new int[arrMax + 1];
        Arrays.stream(arr).forEach(n -> {
            occurances[n]++;
        });
        int[] result = new int[arr.length];
        int counter = 0;
        for (int a = 0; a < occurances.length; a++) {
            if (occurances[a] > 0) {
                for (int b = 1; b <= occurances[a]; b++) {
                    result[counter] = a;
                    counter++;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) throws IOException {
        try (BufferedWriter bufferedWriter =
                     new BufferedWriter(new FileWriter(new File("iofiles/cs.out")));
             Scanner scanner = new Scanner(System.in)) {
            int n = scanner.nextInt();
            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
            int[] arr = new int[n];
            String[] arrItems = scanner.nextLine().split(" ");
            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
            for (int i = 0; i < n; i++) {
                int arrItem = Integer.parseInt(arrItems[i]);
                arr[i] = arrItem;
            }
            int[] result = countingSort(arr);
            for (int i = 0; i < result.length; i++) {
                bufferedWriter.write(String.valueOf(result[i]));
                if (i != result.length - 1) {
                    bufferedWriter.write(" ");
                }
            }
            bufferedWriter.newLine();
        }
    }
}

static int[] countingSort(int[] arr) {
        int arrMax = Arrays.stream(arr).max().getAsInt();
        int[] occurances = new int[arrMax + 1];
        Arrays.stream(arr).forEach(n -> {
            occurances[n]++;
        });
        int[] result = new int[arr.length];
        int counter = 0;
        for (int a = 0; a < occurances.length; a++) {
            if (occurances[a] > 0) {
                for (int b = 1; b <= occurances[a]; b++) {
                    result[counter] = a;
                    counter++;
                }
            }
        }
        return result;
    }

导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.array；
导入java.util.Scanner；
/**
*计数排序。
*/
公共类计数排序{
静态int[]计数排序（int[]arr）{
int arrMax=Arrays.stream（arr.max（）.getAsInt（）；
int[]发生率=新int[arrMax+1]；
Arrays.stream（arr.forEach）（n->{
发生率[n]++；
});
int[]结果=新int[arr.length]；
int计数器=0；
对于（int a=0；a0）{
对于（int b=1；b{
发生率[n]++；
});
int[]结果=新int[arr.length]；
int计数器=0；
对于（int a=0；a0）{
对于（int b=1；b）您期望得到什么？它到底给了您什么？您好。要求人们发现代码中的错误并不是特别有效。您应该使用调试器（或添加打印语句）通过跟踪程序的进度，并将其与预期发生的情况进行比较，来隔离问题。一旦两者出现分歧，您就发现了问题。（如果必要，您应该构建一个解决方案。）@Jeroenningelbrecht我希望元素按非降序排序。我得到的输出按非降序排序，但值与我输入的值不一样。这与psudoCode一点也不相似：你能给出一些你测试过的输入和程序打印出来的内容吗？它工作了！非常感谢！我是很高兴至少有人愿意回答这个问题。谢谢你的帮助。
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Counting sort.
 */
public class CountingSort {

    static int[] countingSort(int[] arr) {
        int arrMax = Arrays.stream(arr).max().getAsInt();
        int[] occurances = new int[arrMax + 1];
        Arrays.stream(arr).forEach(n -> {
            occurances[n]++;
        });
        int[] result = new int[arr.length];
        int counter = 0;
        for (int a = 0; a < occurances.length; a++) {
            if (occurances[a] > 0) {
                for (int b = 1; b <= occurances[a]; b++) {
                    result[counter] = a;
                    counter++;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) throws IOException {
        try (BufferedWriter bufferedWriter =
                     new BufferedWriter(new FileWriter(new File("iofiles/cs.out")));
             Scanner scanner = new Scanner(System.in)) {
            int n = scanner.nextInt();
            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
            int[] arr = new int[n];
            String[] arrItems = scanner.nextLine().split(" ");
            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
            for (int i = 0; i < n; i++) {
                int arrItem = Integer.parseInt(arrItems[i]);
                arr[i] = arrItem;
            }
            int[] result = countingSort(arr);
            for (int i = 0; i < result.length; i++) {
                bufferedWriter.write(String.valueOf(result[i]));
                if (i != result.length - 1) {
                    bufferedWriter.write(" ");
                }
            }
            bufferedWriter.newLine();
        }
    }
}

static int[] countingSort(int[] arr) {
        int arrMax = Arrays.stream(arr).max().getAsInt();
        int[] occurances = new int[arrMax + 1];
        Arrays.stream(arr).forEach(n -> {
            occurances[n]++;
        });
        int[] result = new int[arr.length];
        int counter = 0;
        for (int a = 0; a < occurances.length; a++) {
            if (occurances[a] > 0) {
                for (int b = 1; b <= occurances[a]; b++) {
                    result[counter] = a;
                    counter++;
                }
            }
        }
        return result;
    }