简单java程序数组排序功能bug层出不穷

Question

纯刚学java,想写一个用数组对一些东西进行排序的程序,然后错了一个小时才写了这玩意出来.
有几个不明白的地方:
①:为什么给数组分配空间的时候要写上"length + 1",否则告诉我线程“main”java.lang.ArrayIndexOutOfBoundsException中的异常：索引3`超出长度3的界限.
②:我写的东西总是不按我的想法实现,被迫更改,只能实现从大到小排列并输出,想要从小到大输出的话只能反着输出,而且还要将数组的循环起点减一才行, 即for(int i = length - 1;i >= 0;i --),否则输出的是"0 1 2 3".
③:大家看看我的代码吧,看看还能怎么补救,或者有更好的写法,让它变得正常一点.

public class Rank {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int length =sc.nextInt();
        int a[];
        a = new int[length + 1];
        int item = a[0];
        for(int i = 1; i <= length; i ++)
        {
            a[i] = sc.nextInt();
        }
       for(int i = 0; i < length; i ++)
       {
        for(int j = i + 1; j <= length; j ++)//AntiPrintf
        {
            if(a[i] < a[j])
            {
            item = a[j];
            a[j] = a[i];
            a[i] = item;
            }
        }
       }
       System.out.println("上大下小()输出 ");
       for(int i = 0;i < length;i ++)//Antiprintf
        {
        System.out.println(a[i]+" ");
        }
        System.out.println("上小下大()输出 ");
        for(int i = length - 1;i >= 0;i --)//AntiAntiprintf
        {
        System.out.println(a[i]+" ");
        }
    }
}

Answer 1

以下是对你提出的问题的回答：

1.在给数组分配空间时，需要分配的空间大小应该是数组元素的个数，而不是数组的长度。因此，如果要存储 length 个元素，需要分配 length 个空间，而不是 length + 1 个空间。如果你分配了 length + 1 个空间，那么最后一个元素将无法访问，因为它超出了数组的长度。

2.你的代码中使用了冒泡排序算法，这种算法可以实现从大到小或从小到大的排序，具体取决于比较元素的顺序。在你的代码中，如果要实现从小到大的排序，可以将比较元素的顺序反过来，即将 if 语句中的小于号改成大于号。另外，如果要按照从小到大的顺序输出数组元素，可以不用反转数组，而是直接按照正序输出即可。

3.你的代码中的一些变量名和注释可能不够清晰，可以考虑改进。另外，你可以尝试使用更高效的排序算法，例如快速排序或归并排序，以提高程序的效率。最后，建议在编写代码时注意细节，避免出现常见的错误，例如数组下标越界等。

优化后的代码（只是一种参考，可以按自己的想法改进，写代码要避免冗余，在能实现功能的情况下，能写多简单就写多简单，多余的东西没必要）：

import java.util.Scanner;

public class Rank {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int length = sc.nextInt();
        int a[] = new int[length];
        for (int i = 0; i < length; i++) {
            a[i] = sc.nextInt();
        }
        quickSort(a, 0, length - 1);
        System.out.println("升序排序：");
        for (int i = 0; i < length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        System.out.println("降序排序：");
        for (int i = length - 1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
    }

    private static void quickSort(int[] a, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = a[left];
        int i = left + 1;
        int j = right;
        while (i <= j) {
            while (i <= j && a[i] <= pivot) {
                i++;
            }
            while (i <= j && a[j] > pivot) {
                j--;
            }
            if (i < j) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        int temp = a[left];
        a[left] = a[j];
        a[j] = temp;
        quickSort(a, left, j - 1);
        quickSort(a, j + 1, right);
    }
}

在这个优化后的代码中，使用了快速排序算法来对数组进行排序，这种算法的时间复杂度是 O(nlogn)，比冒泡排序更快。同时，为了避免数组下标越界的问题，数组的长度设置为 length，而不是 length + 1。在输出排序结果时，使用了两个循环来分别输出升序和降序的结果，而不需要反转数组。

PS:java太卷了，入行考虑清楚