为什么对象的值会改变，即使它有不同的引用？

Question

I am confused about objects references here. It is LC problem to merge 2 sorted linked lists.

I understand that at first iteration current.next and result have reference the same object so when i assign new value to current.next the result value changes as well.

At the second iteration both r1 and r2 are false so result, current and current.next point to diffrent objects.

What i don't understand is why assigning new value to current ( current = current.next ) doesn't modify result object but current.next = l1/l2 does?

Could someone explain it to me please?

public static ListNode MergeTwoLists(ListNode l1, ListNode l2)
        {
            if (l1 == null) return l2;
            if (l2 == null) return l1;
            if (l2 == null && l1 == null) return null;

            ListNode result = new ListNode(0);
            ListNode current = result;

            while (l1 != null && l2 != null)
            {
                var r1 = Object.ReferenceEquals(result, current);
                var r2 = Object.ReferenceEquals(result, current.next);
                
                if (l1.val < l2.val)
                {
                    current.next = l1;
                    l1 = l1.next;
                }
                else
                {
                    current.next = l2;
                    l2 = l2.next;
                }

                current = current.next;
            }

            // l1 is lognger than l2 
            if(l1 != null)
            {
                current.next = l1;
                l1 = l1.next;
            }

            // l2 is lognger than l1 
            if (l2 != null)
            {
                current.next = l2;
                l2 = l2.next;
            }

            return result.next;
        }

public class ListNode
    {
        public int val;
        public ListNode next;
        public ListNode(int x = 0, ListNode next = null)
        {
            val = x;
            next = null;
        }
    }

EDIT

Let's say we have these:

Input: l1 = [1,2,4], l2 = [1,3,4]    Output: [1,1,2,3,4,4] 

1st iteration :

r1 = true , both result and current point to the same object.

r2 = false

l1.val == l2.val so we execute

else
{
  current.next = l2;
  l2 = l2.next;
}

At this moment we have: result = [0,1,3,4] , current = [0,1,3,4], l2 = [3,4]

Next we execute current = current.next , so current = [1,3,4] and it doesn't point to result anymore.

2nd iteration

r1 = false , both result and current point to the different object.

r2 = false ,

l1.val < l2.val so we execute

if (l1.val < l2.val)
{
    current.next = l1;
    l1 = l1.next;
}

At this moment we have:

result = [0,1,1,2,4], current = [1,1,2,4], l2 = [3,4], l1 = [2,4]

Here is the part i don't understand : Result and current point to diffrent objects, still when current changes result does as well. How result keeps reference to current??

Next we execute current = current.next , so current = [1,2,4] , so we modify current but this time result doesn't change.

Answer 1

Result and current point to diffrent objects, still when current changes result does as well. How result keeps reference to current?

Look at this part of your question:

so current = [1,3,4] and it doesn't point to result anymore.

Importantly, the 1 in that list is the same element as the 1 in result = [0,1,3,4] . If you modify the next field of that 1 node, you will modify any list that node is a member of. Including the list that result is referencing.

Later when you write:

At this moment we have:

result = [0,1,1,2,4], current = [1,1,2,4], l2 = [3,4], l1 = [2,4]

Note that the list result points to is not the same as the list current points to. But after that first node, it is the same.

After the first iteration, result.next references the same object that current does. This is because result and current started at referencing the same object, and then as the last step of the first iteration, current was changed to reference current.next . Since current and result were at that point the same, current.next and result.next are also the same. So after changing current to current.next , that's the same as setting it to result.next .

So on the second iteration, result.next and current are the same. This means that when you modify current.next , that's the same as modifying result.next.next , which has the effect of replacing the contents of the result list beyond the first two elements, with the new chain of elements that l2 referenced.

Again: the key here is that each variable simply points to a single node. It's fine to conceptualize that as pointing to a list of nodes, but only if you remember that if you modify the next field of any node in that list, you are modifying the entire list, even if the variable is not referencing the variable that references the root of the list.

Answer 2

You should never assign current.next to nodes from l1 or l2 . Instead you must create a new ListNode that has the same value as l1 or l2 and make current.next point to your new ListNode . Otherwise you're trying to straighten a bowl of spaghetti, which is an impossible task. You need to build your own new strand of spaghetti.