Question

在许多递归调用之后，low变为等于high并且递归中断。之后会发生什么？任何人都可以解释。合并程序对我很清楚：当mergesort(0,5)被调用时，它会再次调用自己：mergesort(0,2)然后mergesort(0,1)。最后mergesort(0,0)然后递归中断。

之后会发生什么？控件在代码中的位置在哪里？堆栈在哪里使用？请帮帮我。

public class MergeSort {
private int[] numbers;
private int[] helper;

private int number;

public void sort(int[] values) {
    this.numbers = values;
    number = values.length;
    this.helper = new int[number];
    mergesort(0, number - 1);
}

private void mergesort(int low, int high) {
    // check if low is smaller than 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) {

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

    int i = low;
    int j = middle + 1;
    int k = low;
    // Copy the smallest values from either the left or the right side back
    // to the original array
    while (i <= middle && j <= high) {
        if (helper[i] <= helper[j]) {
            numbers[k] = helper[i];
            i++;
        } else {
            numbers[k] = helper[j];
            j++;
        }
        k++;
    }
    // Copy the rest of the left side of the array into the target array
    while (i <= middle) {
        numbers[k] = helper[i];
        k++;
        i++;
    }

}

 public static void main(String[] args){
     int arr[] = {78,9,45,7,2,90};
     new MergeSort().sort(arr);
        for(int i = 0; i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
 }

}

Answer 1

您可以使用else语句并观察执行仍然在低＆gt; =高之后完成。在这里，只是跳过这些调用。

        private void mergesort(int low, int high) { 
    // check if low is smaller than 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); }

    else 
    System.out.prinln("low is higher than high. Low is " +low+ "high is" +high);
     }

Answer 2

对于自上而下的合并排序，在从数组的递归拆分生成两次大小为1的运行之前，不会发生合并。这将是mergesort（）调用merge（）的第一个实例。然后mergesort（）的实例返回到mergesort（）的先前实例，最终到达它对merge（）的调用，依此类推。合并顺序是深度优先/左首先。

相比之下，自下而上的合并排序（大多数库使用自下而上合并排序的一些变体，如timsort），跳过递归并将n个元素的数组视为大小为1的n次运行，并立即开始合并运行。运行的索引是迭代生成的（通过循环）。

这是自上而下合并排序的操作顺序的示例，其首先是深度，左边是第一个。垂直条表示当前数组的左半部分和右半部分之间的分割。

|4 2 8 6 0 5 1 7 3 9|
|4 2 8 6 0|5 1 7 3 9|
|4 2|8 6 0|
|4|2|
|2 4|
    |8|6 0|
      |6|0|
      |0 6|
    |0 6 8|
|0 2 4 6 8|
          |5 1|7 3 9|
          |5|1|
          |1 5|
              |7|3 9|
                |3|9|
                |3 9|
              |3 7 9|
          |1 3 5 7 9|
|0 1 2 3 4 5 6 7 8 9|

Answer 3

执行的是每个堆栈方法调用都会执行。如果您以图形方式表示堆栈，则每个步骤都包含以下内容：

1.- bottom/top --> mergeSort(0, 5)

2.- top    --> mergeSort(0, 2)
    bottom --> mergeSort(0, 5)

3.- top    --> mergeSort(0, 1)
               mergeSort(0, 2)
    bottom --> mergeSort(0, 5)

4.- top    --> mergeSort(0, 0) --> breaks and go back
               mergeSort(0, 1)
               mergeSort(0, 2)
    bottom --> mergeSort(0, 5)

5.- top    --> mergeSort(0, 1) --> finish and continue with next line
               mergeSort(0, 2)
    bottom --> mergeSort(0, 5)

6.- top    --> mergeSort(2, 2) --> next line after mergeSort(0, 1)
               mergeSort(0, 2)
    bottom --> mergeSort(0, 5)

7.- etc.

以图形方式表示的第一步，您可以弄清楚其余部分。希望有所帮助

MergeSort - 实施

3 个答案: