合并链表中的递归

Question

我开始理解递归了，

我附上了合并两个排序链表的递归代码，

我的问题是，我知道一旦第一个或第二个变为空，'temp' 返回 temp->(first (or) second) 的值，但我无法理解这一事实，

例如，如果我有 5 -> 10 -> 15 -> 20。

最终函数返回 15 ->20，然后将其组合为 root.next-> temp，但是在我返回 temp 的那一步之后，为什么会返回根值。 即 10 -> 15 -> 20，当我希望只返回 temp 时。

请找到代码，

 /**
 * 
 */
 *
 *
 */
public class MergeLinkedLists {

    static class Node {

        int data;
        Node next;

        public Node(int value) {
            this.data = value;
        }

    }

    Node root;

        /**
     * @param args
     */

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MergeLinkedLists s1 = new MergeLinkedLists();
        s1.root = new Node(0);
        Node n1 = new Node(10);
        //n1.next = new Node(20);
        //n1.next.next = new Node(30);

        Node n2 = new Node(5);
        n2.next = new Node(15);
        //n2.next.next = new Node(50);

        Node result = sortedLists(n1, n2, s1.root);

        while (result != null) {
            System.out.print(result.data + "--->");
            result = result.next;
        }
    }

    /**
     * @param n1
     * @param n2
      * @param root2
     */
     private static Node sortedLists(Node n1, Node n2, Node root) {
         // TODO Auto-generated method stub

        Node temp = root;

        Node first = n1; // 10 20 30
        Node second = n2; // 5 15 50

        if (first == null) {
            temp.next = second;
            return temp;
        } else if (second == null) {
            temp.next = first;
            return temp;
        }

        else if (first.data < second.data) {
            temp = new Node(first.data);
            first = first.next;
        } else {
            temp = new Node(second.data);
            second = second.next;
        }

        sortedLists(first, second, temp);
        root.next = temp;
        System.out.println("The Temp Data is ::::"+temp.data);
        return temp;

    }

}

Answer 1

因为temp 在这种情况下是根值。别担心，这是为了理解递归本身需要理解的一件事。

了解代码功能的一个重要功能是使用调试器。为函数调用设置断点，您可以单步执行程序，同时可以观察变量如何变化。

除此之外，让我们看看你的代码。

需要注意的是，每当您调用sortedLists(first, second, temp); 时，指针都会进入其中，直到函数终止（因此当它返回 temp 时）。随着程序的继续，您将多次调用此函数，因此它将更深入地了解自己的函数。 然后它一步一步地传递信息直到sortedLists(first, second, temp); 的第一次调用终止，这是在你的主要方法Node result = sortedLists(n1, n2, s1.root);

我会尽量配合你的例子：

1. Node result = sortedLists(n1, n2, s1.root);在main()方法中调用。所以根是 0，你的节点是 10 和 5,15。

2. 在sortedLists() 的第一次调用中，temp 变为5，second 现在带有15，因为first.data > second.data。

3. 现在您再次调用方法 sortedLists()，但使用了新值：根现在是 5，第一个仍然是 10，第二个是 15。我们进入函数内部并从新值开始：

   1. 由于first.data < second.data，temp 变为10，first 现在为null。
   2. 又一次：我们在sortedLists() 上打了另一个电话。我们将值：first = null second = 15 root = 10 传递给函数并更深入一步。
      1. 因为first 现在为零，temp.next 将是second(15)
      2. temp 现在看起来像这样：10->15 我们返回。 （这是第一次，sortedLists() 终止！）
   3. 我们现在回到这里，可以继续使用root.next = temp; 还记得在这种情况下的 temp 吗？ temp 为 10，但已由上面的函数更新。新的temp 是 10->15，所以我们的root 看起来像：5->10->15。
   4. 然后打印 temp 的头部，即 10。此函数也终止。

4. 现在我们回到第一次调用，看看会发生什么：在 3.3 中，我们更新了它的根。 3.3 的根是 3 的 temp，因为我们调用了 sortedLists(first, second, temp)（temp 充当根，因为此函数的最后一个参数是 Node root）。

5. 总结一下：我们的根还是0，温度是5->10->15

6. root.next 在此分配 0->5->10->15 之后。现在，您在 main 方法上方的类中声明的根有一个值。

7. 我们返回 5->10->15 的温度，我们就完成了。

我们现在可以继续主方法，打印结果。

要去掉--->当没有result.next时，可以这样处理空值：

 while (result != null) {
            if (result.next != null)
            System.out.print(result.data + "--->");
            else System.out.println(result.data);
            result = result.next;
        }

我希望这对递归有所帮助。