LinkedList 临时头更新原始头

Question

I'm trying to implement a LinkedList in java . Currently, LinkedList contains only 2 methods insertAtFront and insertAtBack which is working fine. But I want to clear my concept about when we assign a new Node to the temporary head it is updating the original head at the following line.

headTemp.reference = new Node(data);

How it is happening? Because by default an object is a reference type. Please explain this concept in plain English.

Node class:

public class Node {

    public int data;
    public Node reference;

    public Node(int data) {
        // Calling the second constructor
        this(data, null);
    }

    public Node(int data, Node reference) {
        this.data = data;
        this.reference = reference;
    }

    public int getData() {
        return this.data;
    }

    public Node getNextNode() {
        return this.reference;
    }

}

LinkedList class:

public class LinkedList {

    // Head
    protected Node head;

    // Default head would be null
    public LinkedList() {
        this.head = null;
    }

    // insertAtFront first check if head is empty
    public void insertAtFront(int data) {
        if (isEmpty()) {
            head = new Node(data);
        } else {
            head = new Node(data, head);
        }

    }

    // insertAtBack
    public void insertAtBack(int data) {
        if (isEmpty()) {
            head = new Node(data);
        }
        // If List has second node
        else if (head.reference == null) {
            head.reference = new Node(data);
        } else {
            Node headTemp = head;

            while (headTemp.reference != null) {
                headTemp = headTemp.reference;
            }
            headTemp.reference = new Node(data);
        }
    }

    public boolean isEmpty() {
        return this.head == null;
    }

    public void printList() {
        System.out.printf("Linked list is : ");

        Node headTemp = head;

        while (headTemp != null) {

            System.out.printf(" %s ", headTemp.data);

            headTemp = headTemp.reference;
        }

        System.out.printf("\n");
    }

}

Main class:

public class Main {

    public static void main(String[] args) {

        LinkedList l = new LinkedList();

        l.insertAtBack(23);
        l.insertAtBack(24);
        l.insertAtBack(25);

        l.printList();

    }

}

Answer 1

Java variables hold as value (a reference to) the object, the Node instance. Assignment will share the object.

Hence changes to the object can be reflected in several variables/fields.

Comments on the code, which is very fine on the inserts:

public void insertAtFront(int data) {
    head = new Node(data, head);
}

//public LinkedList() {
//    this.head = null;
//}

Fields are automatically null, 0, 0.0, false.

The class Node probably need not be public.

Answer 2

From what i understood you do not understand the Logic of

else {
       Node headTemp = head;
       while (headTemp.reference != null) {
            headTemp = headTemp.reference;
       }
       headTemp.reference = new Node(data);
     }

First of all the headTemp is a confusing name for the variable , it should be something like tempPointer because what we are doing here is saying i have a pointer which is pointing to the address of a specific node of linked list.

Here the tempPointer is refering to the same variable as head

This is the same logic as

String s= new String("ABC");
String s1=s;

so both s and s1 as an address of variable new String("ABC");

So our position now is [Head/tempPointer]-> []-> []-> []-> []-> []

Then because we have address of head we can find address of its next node using tempPointer.reference(the next node address) and say ok i now have the next node address so i dont need the current node address so i will replace.

tempPointer = tempPointer.reference;

Now it will look like [Head]-> [tempPointer]-> []-> []-> []-> []

we do this in a loop until there is no more next node "tempPointer.reference = null" , which is the end of the list.

[Head]-> []-> []-> []-> []-> [tempPointer]

At this point my tempPointer has address of last node so if i add the Node to the end of this address , i will add the node to the linked list

tempPointer.reference = new Node(data);

[Head]-> []-> []-> []-> []-> [tempPointer]=> [Added Node(new Node())]