从链表中删除重复项

Question

I have the following code but I don't understand where head is modified:

static void removeDuplicates(Node head) {
    HashSet<Integer> set = new HashSet<>();
    Node previous = null;

    while (head != null) {
        if (set.contains(head.data)) {
            previous.next = head.next;
        } else {
            set.add(head.data);
            previous = head;
        }
        head = head.next;
    }
}

What confuses me is that head is set to null every time the function ends. Why is the method still correct?

Answer 1

head is a variable (by way of being a local parameter). Given that it is a variable of a non-primitive type, the thing it holds is a reference . It's like a treasure map. Not like treasure. You can use it to get to treasure, but it is not, itself, treasure.

Java is strictly pass-by-value, ie, everything is a copy . Whatever code called removeDuplicates had a treasure map, and made a copy of this map, and handed that copy to the removeDuplicates method.

head = head.next is java-ese for:

• ( head.next - the . specifically): Dot is 'dereference': Take the head treasuremap, follow it to the X, dig down, and open the treasure. Inside, find a little tab named 'next'. On it, you will find a treasure map (that's a treasure map, in a treasure chest).
• Now the head =... part: Now take the head treasure map and erase what is there . Then copy over the next map from the chest. When you're done, put the next map back in the chest, close it up, and cover it back up.

At the end of the method, head , which is just a local treasure map, just poofs out of existence immediately, as do all local variables.

Yeah, on the last run, head = head.next means that head is blank ( null ) - the last treasure chest you open does have a piece of paper named next that can contain a treasure map, but it is blank ( null ), and you copy this over, thus, head itself will be blank.

This is irrelevant. head poofs out of existence entirely (the treasure map, not the treasure it leads to), given that it is a local variable and the method that created it ends, and this has absolutely no effect whatsoever on the caller, because its treasure map wasn't changed or destroyed at all - the copy it made was, so this doesn't matter.

Make a very slight change and this becomes a different story: If instead of head being a local var, it was a field (so, replace removeDuplicates(Node head) with removeDuplicates() , and let's posit that there is a field private Node head; in whatever class this method is in), then head = head.next is wiping out the treasure map that is the field itself which obviously survives the method's execution, and will be visible by other code. Then your idea that 'hey wait a second this destroys head .' carries water.