How does this code lead to the populating of dummy and the L3 list as well?

In this code, I am making use of the concept of dummy nodes. For this, I understand how the dummy list gets populated, however, I cannot seem to wrap my head around how the l3 list gets populated as well. I am just thinking of it as a initializer for the dummy list.

For instance, when the code runs for the first time, considering L1 (1 > 2 > 4) and L2 (1 > 3 > 4). When the dummy.next statement runs, it populates both the dummy and the L3. Why is that?

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;   
    }

> When the dummy.next statement runs, it populates both the dummy and the L3. Why is that?

when you are assigning one object to another, you making a link between both of these object's address (dummy and l3 for example). Assume -

You have object A (address 1000); now when you are assigning another object with it, like following :

> A = B

you are actually making a replica of object A, in the name of B (with address 1000). Now both the object pointing to the same location in RAM, whatever changes you will make on one object it will reflect on other as well.

I think you got your answer.

EXTRA:

you have some problem in your code, debug it to make it acceptable.

Let us work through this one with an example. Say we have two lists as follows:

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

Where the first "field" reflects some unique identifier for the rest of the discussion and --> reflects the next-references.

Now the algorithm starts by receiving two lists l1 and l2 as parameters:

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

And it creates a dummy-node for the new list, stores it as l3 and dummy

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

Now depending whether l1.val < l2.val, either l1 or l2 will be set to dummy.next. Let us assume that l1.val < l2.val, thus l1 is set as 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

Next, l1 is set to 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

Finally, in the last step, dummy is set to 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

The iteration starts again. Now let us assume that l1.val > l2.val. Thus, dummy.next is set to l2, l2 is set to l2.next and dummy is set to dummy.next, resulting in the following image:

  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

And for the next iteration, let us assume that l1.value < l2.value. We would finish the iteration with the following diagram:

  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

The other iterations will only move l1, l2 and dummy, but not change the structure of the objejcts.

Now notice that l3 is still referencing the initial dummy head and that some references from the first and second list has changed.