Question

我试图计算按mergesort排序的数组中的最小交换（仅连续交换）。它适用于某些情况，但这种情况不起作用，例如：http://puu.sh/kC9mg/65e055807f.png。第一个数字是应该排序的数字，然后输入数字。在这种情况下，它应该打印1，因为在这种情况下，最小连续交换次数为1，将交换4和3。

这是我的代码：

public class MergeSort {

private int[] numbers;
private int[] helper; 
private int number;
private long swapCounter = 0;

public MergeSort(int[] inputNumbers)
{
    numbers = inputNumbers;
    number = inputNumbers.length;
    helper = new int[number];
    mergesort(0, number-1);

}

private void mergesort(int low, int high) { 
     // check if low is smaller then high, if not then the array is sorted
    if (low < high) {
      // Get the index of the element which is in the middle
      int middle = low + (high - low) / 2;
      // Sort the left side of the array
      mergesort(low, middle);
      // Sort the right side of the array
      mergesort(middle + 1, high);
      // Combine them both
      merge(low, middle, high);
    }
  }

private void merge(int low, int middle, int high) { // Merge it

    long internCounter = 0;

    for (int i = low; i <= high; i++) { // Copy both parts into the helper array
      helper[i] = numbers[i];
    }

    int i = low;
    int j = middle + 1;
    int k = low;

    while (i <= middle && j <= high) { // Copy the smallest values from either the left or the right side back to the original array

      if (helper[i] < helper[j]) {
        numbers[k] = helper[i];
        i++;
        internCounter++;
      } else {
        numbers[k] = helper[j];
        j++;
        swapCounter += internCounter;
      } 
      k++;
    }

    while (i <= middle) { // Copy the rest of the left side of the array into the target array
      numbers[k] = helper[i];
      k++;
      i++;
      swapCounter += internCounter;
    }

  }

public long getCounter() // Get the counter
{
    return this.swapCounter;
}

}

这是我的主要课程： import java.util.Scanner;

public class Fr {   

public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    int numberOfStudents;
    int[] inputNumbers2;

    numberOfStudents = input.nextInt();
    inputNumbers2 = new int[numberOfStudents];

    for(int i = 0; i < numberOfStudents; i++)
    {               
        inputNumbers2[i] = input.nextInt();
    }

    MergeSort ms = new MergeSort(inputNumbers2);    

    System.out.println(ms.getCounter());

    input.close();
}


}

有人有任何想法可能出错吗？

Answer 1

我认为你根本不需要实习生柜台。只计算从高半部分中取出元素时交换元素的位置数：

public class MergeSort {

private int[] numbers;
private int[] helper; 
private int number;
private long swapCounter = 0;

public MergeSort(int[] inputNumbers)
{
    numbers = inputNumbers;
    number = inputNumbers.length;
    helper = new int[number];
    mergesort(0, number-1);

}

private void mergesort(int low, int high) { 
     // check if low is smaller then high, if not then the array is sorted
    if (low < high) {
      // Get the index of the element which is in the middle
      int middle = low + (high - low) / 2;
      // Sort the left side of the array
      mergesort(low, middle);
      // Sort the right side of the array
      mergesort(middle + 1, high);
      // Combine them both
      merge(low, middle, high);
    }
  }

private void merge(int low, int middle, int high) { // Merge it

    for (int i = low; i <= high; i++) { // Copy both parts into the helper array
      helper[i] = numbers[i];
    }

    int i = low;
    int j = middle + 1;
    int k = low;

    while (i <= middle && j <= high) { // Copy the smallest values from either the left or the right side back to the original array

      if (helper[i] < helper[j]) {
        numbers[k] = helper[i];
        i++;
      } else {
        numbers[k] = helper[j];
        swapCounter += (j-k);
        j++;
      } 
      k++;
    }

    while (i <= middle) { // Copy the rest of the left side of the array into the target array
      numbers[k] = helper[i];
      k++;
      i++;
    }

  }

    public long getCounter() // Get the counter
    {
        return this.swapCounter;
    }
}

在mergesort中计算交换

1 个答案: