java链表中节点的引用传递

Question

private Node<T> copyList(Node<T> cn1) {
    Node<T> temp = cn1;
    Node<T> newHead = null;
    Node<T> end = null;     
    newHead = new Node<T>((T)(temp.x).clone(), null);

    end = newHead;
    temp = temp.next;

    while (temp != null) {
        end.next = new Node<T>((T)(temp.x).clone(), null);

        end = end.next;
        temp = temp.next;
    }

    // Now the entire list is created, just return its head pointer
    return newHead;
}

The method is trying to make deep copies for generic nodes in a LinkedList , the method is correct and I'm just confused about the line end = newHead;. Shouldn't end and newHead reference the same object? Why is the line end = end.next; not updating newHead ?

I'm sorry if the question is too obvious.

Answer 1

When you write something like:

Node x = new Node();

Where Node is NOT a primitive (so not int, long, boolean, etc),

you should mentally model that as:

We create some new treasure ( new Node(); ) - we conjure up a treasure box out of thin air. It has no name; treasures never have names. You bury it in the sand.

Separately, this also declares that you have a treasure map on you, which you've labelled x (maps have names; treasures do not). You draw a map to the site you just buried your newly created treasure on this map.

Then, the . operator is the 'follow the map and dig' operator, whereas eg the = operator is the 'wipe out your map and overwrite it with how to get to some other treasure'.

With 'treasure' = object, and 'map' = variables and expressions.

For example, List<List<String>> is not really a 'list of a list of strings'. It's a list (treasure) that contains treasure maps , not a treasure holding treasures.

For your specific question:

end = newHead; is wiping out whatever the treasure map named end had (it does NOT follow the end map and do anything to the treasure you find there!) - and overwrites the map with the exact same map that newHead is. Now if you were to follow the newHead map, you get to the same treasure as if you followed the end map. To follow maps, you use the . (or, technically, array access, synchronized, throw, and foreach, which also follow maps and operate on the treasure it leads to).

So, you have 2 treasure maps, that currently lead to the same treasure.

Then you do: end = end.next; . This does NOT follow the map to the treasure. This modifies the treasure map itself: end is wiped out and now is a map to the treasure that the end.next map leads to.

end.next is like this: "Take the map named end . Follow the map, and dig down. Open the treasure chest. Inside, you will find another treasure map by looking in the little box labelled 'next' inside the treasure chest. In this code ( end = end.next; ) that treasure map is never followed, it's just copied onto the end map you've got on you, which wipes out what end was pointing at before.

Answer 2

This is the situation after end = newHead;:

newHead and end are 2 different references that point at the same object (the head of the list).

This is the situation after end = end.next; :

end is now pointing to the next node. newHead is unaffected since it is a different reference so it keeps pointing what it was pointing before.