我的合并排序算法的输出未排序

Question

以下是我在 java 中的合并排序算法代码。它需要一个字符串和一个 int 数组，因为我需要使用 int 数组对字符串数组进行排序。此实现还计算反转。我的问题是它可以很好地计算反转，但是当我自己打印出数组时，它根本没有改变。

主要方法是我测试一个 6 长数组并打印出反转和数组。当我运行这个测试时，我会打印出以下内容。

4
1、3、4、6、2、5
1、3、4、6、2、5

public class Test {

private static int[] intSorted;
private static String[] stringSorted;

public static void main(String[] args) {

    //Creates new string to sort

    String[] string3 = {"1","3","4","6","2","5"};

    //Creates new int to sort

    int[] intt3 = {1,3,4,6,2,5};

    //Calls sortAndCount on int and prints the number of inversions

    System.out.println(sortAndCount(intt3, string3));

    //Turns the int array into a string to print

    StringBuilder intBuild = new StringBuilder();
    for(int i = 0; i < intSorted.length; i++){
        if(i+1 == intSorted.length){
            intBuild.append(intSorted[i]);
        }
        else{
        intBuild.append(intSorted[i] + ", ");
        }
    }

    //Turns the string array into a string to print

    StringBuilder stringBuild = new StringBuilder();
    for(int i = 0; i < stringSorted.length; i++){
        if(i+1 == stringSorted.length){
            stringBuild.append(stringSorted[i]);
        }
        else{
        stringBuild.append(stringSorted[i] + ", ");
        }
    }

    System.out.println(intBuild);
    System.out.println(stringBuild);


}

private static int sortAndCount(int intToSort[], String stringToSort[]){

    int inversionsLeft;
    int inversionsRight;
    int inversionsMerged;

    if(intToSort.length == 1){
        return 0;
    }

    int m = intToSort.length/2;

    int[] intLeft = new int[m];
    String[] stringLeft = new String[m];

    int[] intRight = new int[intToSort.length-m];
    String[] stringRight = new String[intToSort.length-m];


    for (int i=0; i < m; i++){
        intLeft[i] = intToSort[i];
        stringLeft[i] = stringToSort[i];
    }

    for (int i = 0;i < intRight.length; i++){
            intRight[i] = intToSort[m+i];
            stringRight[i] = stringToSort[m+i];
    }

    inversionsLeft = sortAndCount(intLeft, stringLeft);
    inversionsRight = sortAndCount(intRight, stringRight);

    intSorted = new int[intToSort.length];
    stringSorted = new String[stringToSort.length];

    inversionsMerged = mergeAndCount(intLeft, intRight, stringLeft, stringRight);

    return(inversionsLeft + inversionsRight + inversionsMerged);

}

private static int mergeAndCount(int[] intLeft, int[] intRight, String[] stringLeft, String[] stringRight){

    int count = 0;
    int i = 0;
    int j = 0;
    int k = 0;

    while(i < intLeft.length && j < intRight.length){

        if(intLeft[i] < intRight[j]){
            intSorted[k] = intLeft[i];
            stringSorted[k] = stringLeft[i];
            i++;
        }

        else{
            intSorted[k] = intRight[j];
            stringSorted[k] = stringRight[j];
            count += intLeft.length - i + 1;
            j++;
        }

        k++;

    }

     while (i < intLeft.length)
        {
            intSorted[k] = intLeft[i];
            stringSorted[k] = stringLeft[i];
            k++;
            i++;

        }

     while (j < intRight.length)
        {
            intSorted[k] = intRight[j];
            stringSorted[k] = stringRight[j];
            j++;
            k++;

        }

     return count;

}

Answer 1

我认为问题出在这里（我添加的cmets）：

    // Create some arrays into which we write the result of merging the 
    // arrays intLeft, intRight, stringLeft, stringRight.
    intSorted = new int[intToSort.length];
    stringSorted = new String[stringToSort.length];

    // Do the merging into intSorted and stringSorted.
    inversionsMerged = mergeAndCount(intLeft, intRight, stringLeft, stringRight);

    // Oops... we haven't updated intToSort and stringToSort!
    // We need to copy the sorted values from intSorted and stringSorted
    // back into intToSort and stringToSort before we return.

    return(inversionsLeft + inversionsRight + inversionsMerged);

我会留给你来填补空白。

我拿走了你的代码，自己填补了空白，然后运行了它。它似乎奏效了；这是我得到的输出：

7
1, 2, 3, 4, 5, 6
1, 2, 3, 4, 5, 6

祝你好运！

Answer 2

您的数组未排序的原因是您的递归算法在每次调用时不断重新创建 intSorted [] 和 stringSorted []。 此外，您的递归方法只返回一个 int （执行的反转次数）。为了使递归方法工作，每个 sortAndCount 必须返回它是排序数组的一部分。这使得尝试在同一算法中对两个不同的数组进行排序变得困难。

我对您的代码做了一些小的调整，现在它可以正确地对 int[] 进行排序。

如果您想在排序的同时计算倒数，我建议将 passByReference 添加到 Counter 对象，该对象只计算倒数（如访问者模式）。

这是我的代码：

公共类测试{

private static int[] intSorted;

public static void main(String[] args) {

    //Creates new string to sort
    //Creates new int to sort

    int[] intt3 = {1,3,4,6,2,5};

    //Calls sortAndCount on int and prints the number of inversions

    System.out.println(sortAndCount(intt3));

    //Turns the int array into a string to print

    StringBuilder intBuild = new StringBuilder();
    for(int i = 0; i < intSorted.length; i++){
        if(i+1 == intSorted.length){
            intBuild.append(intSorted[i]);
        }
        else{
            intBuild.append(intSorted[i] + ", ");
        }
    }

    //Turns the string array into a string to print


    System.out.println(intBuild);


}

private static int[] sortAndCount(int intToSort[]){

    int inversionsLeft;
    int inversionsRight;
    int inversionsMerged;

    if(intToSort.length == 1){
        return intToSort;
    }

    int m = intToSort.length/2;

    int[] intLeft = new int[m];
    String[] stringLeft = new String[m];

    int[] intRight = new int[intToSort.length-m];
    String[] stringRight = new String[intToSort.length-m];


    for (int i=0; i < m; i++){
        intLeft[i] = intToSort[i];
    }

    for (int i = 0;i < intRight.length; i++){
        intRight[i] = intToSort[m+i];
    }

    intLeft  = sortAndCount(intLeft);
    intRight = sortAndCount(intRight);

    intSorted = new int[intToSort.length];

    intSorted  = mergeAndCount(intLeft, intRight);

    return intSorted;

}

private static int[] mergeAndCount(int[] intLeft, int[] intRight){

    int count = 0;
    int i = 0;
    int j = 0;
    int k = 0;

    while(i < intLeft.length && j < intRight.length){

        if(intLeft[i] < intRight[j]){
            intSorted[k] = intLeft[i];
            i++;
        }

        else{
            intSorted[k] = intRight[j];
            count += intLeft.length - i + 1;
            j++;
        }

        k++;

    }

    while (i < intLeft.length)
    {
        intSorted[k] = intLeft[i];
        k++;
        i++;

    }

    while (j < intRight.length)
    {
        intSorted[k] = intRight[j];
        j++;
        k++;

    }

    return intSorted;

}

}