0

我编写了一种方法来合并排序值数组。方法完美无缺，但我试图展示已经发生的比较和交流的数量。我的第一个想法是创建静态变量（int 比较、int 交换）并将它们传递给方法。但是我遇到了从帮助方法返回它们的问题。是否可以在同一方法中返回一个 int[] 和两个 int？如果不是，我如何确定已经发生的比较和交换的数量？

这是我的 mergeSort 和 merge 方法：

    public static int[] mergeSort(int[] A, int comps, int exchs) {
    // Array has only 1 element
    if( A.length <= 1 ) {
        return A;
    }
    int midPoint = A.length / 2;
    // Initialize left and right arrays.
    int[] left = new int[midPoint];
    int[] right = new int[A.length - midPoint];
    System.arraycopy(A, 0, left, 0, midPoint);
    System.arraycopy(A, midPoint, right, 0, A.length - midPoint);
    //recursively sort left and right arrays
    left = mergeSort(left, comps, exchs);
    right = mergeSort(right, comps, exchs);
    System.out.println("Comparisons" + comps);
    System.out.println("Exchanges" + exchs);
    return merge(left, right, comps, exchs);

} 
private static int[] merge(int[] left, int[] right, int comps, int exchs){
    // Initialize the result array.
    int[] res = new int[left.length + right.length];
    // Initialize the array indexes.
    int leftIndex = 0; 
    int rightIndex = 0;
    int resIndex = 0; 
    // compare each element and merge results
    while(leftIndex < left.length && rightIndex < right.length){
        if(left[leftIndex] > right[rightIndex]){
            res[resIndex] = right[rightIndex];
            exchs++;
            rightIndex++;
        } else {
            res[resIndex] = left[leftIndex];
            exchs++;
            leftIndex++; 
        }
        comps++;
        resIndex++;
    }
    comps++;
    // Append remainder of left array into the result array.
    while(leftIndex < left.length){
        res[resIndex] = left[leftIndex];
        exchs++;
        leftIndex++;
        resIndex++;
    }
    comps++;
    // Append whatever is left from the right array into the result array.
    while(rightIndex < right.length) {
        res[resIndex] = right[rightIndex];
        exchs++;
        rightIndex++; 
        resIndex++;
    }
    comps++;
    return res; // want to return comparisons and exchanges to mergeSort method
}
4

4 回答 4

2

创建一个为您进行排序的对象。然后它可以存储compsandexchs并且您可以使用 getter 方法访问它们...

public class MergeSorter {
  private int comps = 0;
  private int exchs = 0;

  public int[] mergeSort(int[] A) {
    comps = 0;
    exchs = 0;
    // your code
  }
  private int[] merge(int[] left, int[] right) {
    // your code
  }

  public int getLastComps() { return comps; }
  public int getLastExchs() { return exchs; }
}
于 2012-12-05T17:26:41.907 回答
1

是否可以在同一方法中返回一个 int[] 和两个 int？

不是直接的。但是，您可以创建一个类来封装您需要从该方法返回的所有内容，并返回该类的一个实例。

于 2012-12-05T17:24:57.827 回答
1

如果您有一个具有多个合并方法的类，我将创建两个静态类变量。调用方法时，比较和交换都将设置为 0。随着代码的进行，这两个值将被更新。因此，您将始终知道在调用其中一种方法后，两个变量都会显示正确的值。例如，

private static int comparisons;
private static int exchanges;

public static int[] mergeSort(int[] A, int comps, int exchs) {
    comparisons = 0;
    exchanges = 0;
    if( A.length <= 1 ) {
        return A;
    }
    int midPoint = A.length / 2;
    int[] left = new int[midPoint];
    int[] right = new int[A.length - midPoint];
    System.arraycopy(A, 0, left, 0, midPoint);
    System.arraycopy(A, midPoint, right, 0, A.length - midPoint);
    //recursively sort left and right arrays
    left = mergeSort(left, comps, exchs);
    right = mergeSort(right, comps, exchs);
    comparisons = comps;
    exchanges = exchs;
    return merge(left, right, comps, exchs);
}

您现在可以在调用方法后访问这些静态变量，并且在再次调用该方法时将刷新。

于 2012-12-05T17:36:26.303 回答
0

您必须将这些值包装在一起。因为您不能从一个方法一次返回多个值。因此，将它们全部放置一个对象并返回该对象。

例子：

class WrapperClass {
 int[] array;
 int valueOne;
 int valueTwo;
 // Setters and Getters to these members.
}

样品方法。

public WrapperClass method() {
  // Set your values to the object;
  WrapperClass wrapObj = new WrapperClass();
  // set array and the two values to this object.
  // return the object.
  return wrapObj;
}
于 2012-12-05T17:38:16.520 回答