Java 如果数组'；s的长度是100000

我还是一名编程初学者，我正在学习一门在线课程（算法）

练习题之一是在一个包含100000个随机排列的数字的文件中计算倒数

这是我的代码

    package algo_inversion;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Scanner;

public class Algo_inversion {
    public static int splitMerge(int[]A,int start,int mid,int finish){
        int count=0;
        int []L=new int[mid+2-start];
        int []R=new int[finish-mid+1];
        System.arraycopy(A, start, L, 0, L.length-1);
        L[L.length-1]=5000000;//infinity

        for(int i=0;i<R.length-1;i++){
            R[i]=A[mid+1+i];
        }
        R[R.length-1]=5000000;//infinity

        int x=0;
        int y=0;
        for(int k=start;k<finish+1;k++){
            if(L[x]<=R[y]){
                A[k]=L[x];
                x++;
            }
            else{
                A[k]=R[y];
                y++;
                count+=L.length-1-x;
            }
        }
        return count;        
    }
    public static int countMerge(int []A,int start, int finish){
        if(finish<=start){
            return 0;
        }
        else{
            int mid=(finish+start)/2;
                int leftCount=countMerge(A,start,mid);
                int rightCount=countMerge(A,mid+1,finish);
                int splitCount=splitMerge(A,start,mid,finish);
                return(leftCount+rightCount+splitCount);
        }
    }

    public static void main(String[] args) throws FileNotFoundException {
        int []a=new int[100001];
       Scanner in= new Scanner(new FileReader("IntegerArray.txt"));
       int i=0;
        while(in.hasNext()){
            a[i]=in.nextInt();
            i++;
        }
        in.close();
        System.out.println("inversions=: "+countMerge(a, 0, i-1));

    }
}

包算法反演；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.util.Scanner；
公共类算法反演{
公共静态int splitMerge（int[]A，int start，int mid，int finish）{
整数计数=0；
int[]L=新int[mid+2-start]；
int[]R=新int[finish mid+1]；
系统阵列复制（A，开始，L，0，L.length-1）；
L[L.length-1]=5000000；//无穷大
对于（int i=0；i大小
N
的数组中最坏情况下的反转数是
N*（N-1）/2
。适合int的最大值约为20亿，因此大小大于
65000
的数组有可能溢出
int
，使结果看起来是负数

您应该切换到
long
，以扩展计数器可表示的值范围：

public static long splitMerge(int[]A,int start,int mid,int finish) {
    long count = 0;
    ...
}
public static long countMerge(int []A,int start, int finish) {
    ...
}

我在大小从1到200的随机数组上尝试了它，它工作得很好，但是在文件中的数组中，它给了我一个负数

反转数似乎超过了
Integer.MAX_value
的值，因此您会看到溢出为负数；您应该使用
long
来计算反转数

这是Joel Spolsky的一个例子。通过隐藏机器中的真实情况，人们在遇到这样的问题时不知道发生了什么。当你在计算某件事情时，看到负面结果，首先应该出现的是溢出，超出了
Integer.MAX\u VALUE
的界限
 你确定你得到了200个项目的正确数字吗？看起来你有一些重复计数，因此结果错误地超过了32位整数的限制。是的，任何小于100000的数组都给出了正确答案我的问题是长度100000的数组（哪一个是练习所提供的数组）它给出了一个错误的答案当我学习编程时，我发现使用调试器查看我的程序在做什么很有帮助。调试器允许您设置断点并检查代码，以便在程序暂停时查看变量的实际值。您是否使用IDE？它可能内置了调试器。