Question

我正在尝试编写Count反转算法。它适用于大小为10的数组。但是，当我尝试测试大小为100000的数组时，事情发生了极其错误。我仍然可以对数组进行排序，但反转的数量是负数，这是错误的。我不明白我的逻辑哪个部分出了问题。

我的主要逻辑：我创建了一个名为myArray的数组对象，它有一个CountSplitInv实例方法，可以对子数组进行排序并返回所涉及的反转次数。

请帮帮我。我已经被困在这里很长一段时间了，我仍然无法弄清楚出了什么问题。

我有一种感觉，我完全不理解递归概念。

import java.io.*;
import java.util.*;
import java.math.*;

class myArray{
    private int[] input_array;
    private int nElems;

    public myArray(int max){
        input_array = new int[max];
        nElems = 0;
    }

    public void insert(int value){
        input_array[nElems++] = value;
    }

    public void display(){
        for(int j = 0; j < nElems; j++){
            System.out.print(input_array[j] + " ");
        }
        System.out.println("");
    }

     public void SortAndCount(){
        int[] output_array = new int[nElems];
        int ans = SortNInversionCounts(output_array,0, nElems -1);
        System.out.println("number of inversions IS: " + ans);
     }

    public int SortNInversionCounts(int[] output_array, int lowerBound, int upperBound){
        if(lowerBound == upperBound){
            return 0;
        } else{
            int mid = (lowerBound + upperBound)/2;
            int x, y , z;
            x = SortNInversionCounts(output_array, lowerBound, mid);
            y = SortNInversionCounts(output_array, mid+1, upperBound);
            z = CountSplitInv(output_array, lowerBound, mid+1, upperBound);
            return x + y + z;
        }
    }

    public int CountSplitInv(int[] output_array, int lowPtr, int highPtr, int upperBound){
        int j = 0;
        int lowerBound = lowPtr;
        int mid = highPtr - 1;
        int n = upperBound - lowerBound + 1;

        int numOfInversions = 0;


        while(lowPtr <= mid && highPtr <= upperBound){
            if( input_array[lowPtr] < input_array[highPtr]){
                output_array[j++] = input_array[lowPtr++];
            } else{
                output_array[j++] = input_array[highPtr++];
                // WHERE I count number of inversions 
                numOfInversions = numOfInversions + (mid - lowPtr + 1);
            }
        }

        while(lowPtr <= mid){
            output_array[j++] = input_array[lowPtr++];
        }

        while(highPtr <= upperBound){
            output_array[j++] = input_array[highPtr++];
        }

        for(j = 0; j < n; j++){
            input_array[lowerBound+j] = output_array[j];
        }

        return numOfInversions;
    }
}

class NumOfInversionsApp{

    public static void main(String[] args) throws IOException{

        // Read input file
        FileInputStream fil = new FileInputStream("IntegerArray.txt");
        BufferedReader br = new BufferedReader( new InputStreamReader(fil));

        myArray in_array = new myArray(100000);
        String element = null;
        while( ( element = br.readLine()) != null){
            in_array.insert( Integer.parseInt(element) );
        }



        // input_array.display();
        in_array.SortAndCount();

        // input_array.display();
    }
}

Java：Count Inversions算法逻辑出错了

0 个答案: