Java 递归中的操作序列是什么？

我试图理解一个合并排序算法java代码，但我真的停留在分裂阶段。完整代码如下：

public class Main {

    public static void main(String[] args) {
        int[] intArray = { 20, 35, -15, 7, 55, 1, -22 };

        mergeSort(intArray, 0, intArray.length);

        for (int i = 0; i < intArray.length; i++) {
            System.out.println(intArray[i]);
        }
    }

    // { 20, 35, -15, 7, 55, 1, -22 }
    public static void mergeSort(int[] input, int start, int end) {

        if (end - start < 2) {
            return;
        }

        int mid = (start + end) / 2;
        mergeSort(input, start, mid);
        mergeSort(input, mid, end);
        merge(input, start, mid, end);
    }

    // { 20, 35, -15, 7, 55, 1, -22 }
    public static void merge(int[] input, int start, int mid, int end) {

        if (input[mid - 1] <= input[mid]) {
            return;
        }

        int i = start;
        int j = mid;
        int tempIndex = 0;

        int[] temp = new int[end - start];
        while (i < mid && j < end) {
            temp[tempIndex++] = input[i] <= input[j] ? input[i++] : input[j++];
        }

        System.arraycopy(input, i, input, start + tempIndex, mid - i);
        System.arraycopy(temp, 0, input, start, tempIndex);
    }
}

---

有两个递归调用

mergeSort

和一个

merge

调用，那么此方法的操作顺序是什么，以及如何在没有任何额外变量的情况下进行拆分以保持被拆分的未排序数据？

使用[]表示拆分，|表示单次运行，{}表示合并运行。命令如下:

                                        level of recursion
[ 20   35  -15    7   55    1  -22]     0
[ 20   35  -15]                         1
| 20|                                   2
     [ 35  -15]                         2
     | 35|                              3
          |-15|                         3
     {-15   35}                         2
{-15   20   35}                         1
               [  7   55    1  -22]     1
               [  7   55]               2
               |  7|                    3
                    | 55|               3
               {  7   55}               2
                         [  1  -22]     2
                         |  1|          3
                              |-22|     3
                         {-22    1}     2
               {-22    1    7   55}     1
{-22  -15    1    7   20   35   55}     0

---

使用[]表示拆分，| |表示单个运行，{}表示合并运行。命令如下:

                                        level of recursion
[ 20   35  -15    7   55    1  -22]     0
[ 20   35  -15]                         1
| 20|                                   2
     [ 35  -15]                         2
     | 35|                              3
          |-15|                         3
     {-15   35}                         2
{-15   20   35}                         1
               [  7   55    1  -22]     1
               [  7   55]               2
               |  7|                    3
                    | 55|               3
               {  7   55}               2
                         [  1  -22]     2
                         |  1|          3
                              |-22|     3
                         {-22    1}     2
               {-22    1    7   55}     1
{-22  -15    1    7   20   35   55}     0

---

总的来说，这些方法将按照它们在代码中写入的顺序执行。然而，不幸的是，我不清楚你在问什么。如果您能定义“保留分割的未排序数据”的结果，将会有所帮助。谢谢您的评论。在代码中，我们必须将数组分成两个未排序的数组。第一个数组是左数组，第二个数组是右数组。然后将左侧和右侧阵列分别拆分为两个阵列。最后继续拆分，直到每个数组只有一个元素（这些数组未排序）。我的意思是最后的单数元素。这似乎是一个课程问题（针对StackOverflow策略），所以我只能提示：1。你认为实际的分拣在哪里进行？2.在哪种情况下，您只剩下一个单一元素？回答这些问题应该能让你找到答案。我只是想理解一段代码，我只是想知道在完成两个mergeSort方法或两个递归调用的每个周期后，它何时会到达merge方法？@rcgldr据我所知，在两个递归之后，mergeSort方法通过堆栈使用不同的起始值、中间值和结束值调用merge方法8次，是否正确？总体而言，这些方法将按照写入代码的顺序执行。然而，不幸的是，我不清楚你在问什么。如果您能定义“保留分割的未排序数据”的结果，将会有所帮助。谢谢您的评论。在代码中，我们必须将数组分成两个未排序的数组。第一个数组是左数组，第二个数组是右数组。然后将左侧和右侧阵列分别拆分为两个阵列。最后继续拆分，直到每个数组只有一个元素（这些数组未排序）。我的意思是最后的单数元素。这似乎是一个课程问题（针对StackOverflow策略），所以我只能提示：1。你认为实际的分拣在哪里进行？2.在哪种情况下，您只剩下一个单一元素？回答这些问题应该能让你找到答案。我只是想理解一段代码，我只是想知道在完成两个mergeSort方法或两个递归调用的每个周期后，它何时会到达merge方法？@rcgldr据我所知，在两个递归之后，mergeSort方法在堆栈中使用不同的开始值、中间值和结束值调用merge方法8次，对吗？通过联机查找算法的一些动画可能有助于说明这一点。@Zabuza-我还没有找到一个显示自顶向下所有步骤顺序的动画。wiki文章并行显示了拆分，这与自上而下或自下而上不对应。@rcgldr感谢您的精彩回复，这非常有帮助。通过在线查找算法的一些动画可能有助于说明这一点。@Zabuza-我还没有找到一个显示自上而下所有步骤顺序的动画。wiki文章并行显示了拆分，这与自上而下或自下而上的方式不同。@rcgldr感谢您的回复，这非常有帮助。