这段代码如何导致虚拟列表和L3列表的填充？

Question

在这段代码中，我使用虚拟节点的概念。为此，我理解虚拟列表是如何填充的，但是，我似乎无法理解l3列表是如何填充的。我只是认为它是一个虚拟列表的初始化器。

例如，当代码第一次运行时，考虑L1 (1 >2> 4)和L2 (1 >3> 4)。当dummy.next语句运行时，它会同时填充虚拟和L3。为什么会这样呢？

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(0);
        ListNode dummy = l3;
        
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                dummy.next = l1;
                l1 = l1.next;
            }
            else{
                dummy.next = l2;
                l2 = l2.next;
            }
            
            dummy = dummy.next;
        }
        
        return l3.next;   
    }

Answer 1

运行dummy.next语句时，它同时填充虚拟和L3。为什么会这样呢？

当您将一个对象分配给另一个对象时，您将在这两个对象的地址(例如虚拟和l3 )之间建立一个链接。假设-

您有对象A(地址1000)；现在，当您使用它分配另一个对象时，如下所示：

A=B

您实际上是在以B(地址1000)的名义复制对象A。现在，指向RAM中相同位置的两个对象，无论对一个对象做什么更改，它也会对另一个对象进行反映。

我想你知道答案了。

额外：

您的代码中有一些问题，请对其进行调试以使其可接受。

Answer 2

让我们用一个例子来讨论这个问题。假设我们有两份清单如下：

[L1-one | next] --> [L1-two | next] --> [L1-three | next] --> null
[L2-one | next] --> [L2-two | next] --> null

其中，第一个“字段”反映了讨论其余部分的一些唯一标识符，而-->则反映了next-references。

现在，该算法从接收两个列表l1和l2作为参数开始：

  l1
   |
   v
[L1-one | next] --> [L1-two | next] --> [L1-three | next] --> null
[L2-one | next] --> [L2-two | next] --> null
   ^
   |
  l2

它为新列表创建一个虚拟节点，并将其存储为l3和dummy。

  l3, dummy
   |
   v
[L3-dummy | next] --> null

现在取决于l1.val < l2.val，l1还是l2将被设置为dummy.next。让我们假设l1.val < l2.val，因此l1被设置为dummy.next

  l3, dummy
   |
   v
[L3-dummy | next] --.
                    |
  l1  .-------------.
   |  |
   v  v
[L1-one | next] --> [L1-two | next] --> [L2-three | next] --> null




[L2-one | next] --> [L2-two | next] --> null
   ^
   |
  l2

接下来，l1设置为l1.next

  l3, dummy
   |
   v
[L3-dummy | next] --.
                    |
      .-------------. l1
      |                |
      v                v
[L1-one | next] --> [L1-two | next] --> [L1-three | next] --> null




[L2-one | next] --> [L2-two | next] --> null
   ^
   |
  l2

最后，在最后一步中，dummy被设置为dummy.next

  l3
   |
   v
[L3-dummy | next] --.
                    |
dummy .-------------. l1
   |  |                |
   v  v                v
[L1-one | next] --> [L1-two | next] --> [L1-three | next] --> null




[L2-one | next] --> [L2-two | next] --> null
   ^
   |
  l2

迭代再次开始。现在让我们假设l1.val > l2.val。因此，dummy.next设置为l2，l2设置为l2.next，dummy设置为dummy.next，结果如下：

  l3
   |
   v
[L3-dummy | next] --.
                    |
   .----------------. l1
   |                   |
   v                   v
[L1-one | next] --. [L1-two | next] --> [L1-three | next] --> null
                  |
   .--------------.
   |
   v
[L2-one | next] --> [L2-two | next] --> null
   ^                   ^
   |                   |
dummy                 l2

在下一次迭代中，让我们假设l1.value < l2.value。我们将用以下图表完成迭代：

  l3
   |
[L3-dummy | next] --.
                    |
   .----------------. l2                  l1
   |                   |                   |
   v                   v                   v
[L1-one | next] --. [L1-two | next] --> [L1-three | next] --> null
                  |    ^
   .--------------.    |
   |                   .--------------.
   v                                  |
[L2-one | next] --> [L2-two | next] --.
                       ^
                       |                     
                    dummy

其他迭代只会移动l1、l2和dummy，而不会改变objejcts的结构。

现在请注意，l3仍然在引用初始的虚拟头，第一个和第二个列表中的一些引用已经更改。