Push Using Linked List Node in DSA Java

Mental Model

Adding a new item at the start of a linked list means making it the new head and linking it to the old head.

Analogy: Imagine a line of people holding hands. To add a new person at the front, they hold the new person's hand first, then the rest follow.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, push value 0

Goal: Add 0 at the start so the list becomes 0 -> 1 -> 2 -> 3 -> null

Step 1: Create new node with value 0

newNode(0) -> null
head -> 1 -> 2 -> 3 -> null

Why: We need a new node to add to the list

Step 2: Set new node's next to current head (node 1)

newNode(0) -> 1 -> 2 -> 3 -> null
head -> 1 -> 2 -> 3 -> null

Why: Link new node to the existing list so it points to the old first node

Step 3: Update head to new node

head -> 0 -> 1 -> 2 -> 3 -> null

Why: New node becomes the first node in the list

Result:

head -> 0 -> 1 -> 2 -> 3 -> null

Annotated Code

DSA Java

public class LinkedList {
    static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head;

    // Push new node at the front
    public void push(int newData) {
        Node newNode = new Node(newData); // create new node
        newNode.next = head; // link new node to current head
        head = newNode; // update head to new node
    }

    // Print list
    public void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // Create initial list 1->2->3->null
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);

        list.push(0); // push 0 at front
        list.printList();
    }
}

Node newNode = new Node(newData); // create new node

create a new node with the given data

newNode.next = head; // link new node to current head

point new node's next to current head to link it to the list

head = newNode; // update head to new node

make new node the new head of the list

Output

0 -> 1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change a few pointers without traversing the list

Space: O(1) because we only create one new node regardless of list size

vs Alternative: Compared to adding at the end which requires O(n) traversal, pushing at front is faster and simpler

Edge Cases

empty list (head is null)

new node becomes the head and points to null

DSA Java

newNode.next = head; // link new node to current head

When to Use This Pattern

When you need to add an element quickly at the start of a list, use push to update the head pointer.

Common Mistakes

Mistake: Forgetting to update the head to the new node after linking
Fix: Always assign head = newNode after setting newNode.next

Mistake: Setting newNode.next to null instead of current head
Fix: Set newNode.next = head to keep the existing list connected

Summary

Adds a new node at the beginning of a linked list.

Use when you want to insert elements quickly at the front.

The new node points to the old head, then becomes the new head.

Practice

1. What does the push operation do in a linked list when using nodes?

easy

A. Deletes the first node of the list

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Adds a new node at the beginning of the list

Solution

1. Step 1: Understand push operation in linked list

   The push operation adds a new element to the start of the linked list by creating a new node and linking it before the current head.

2. Step 2: Compare with other operations

   Removing or searching nodes are different operations; push specifically adds at the front.

3. Final Answer:

   Adds a new node at the beginning of the list -> Option D

4. Quick Check:

   Push = Add at start [OK]

Hint: Push always adds node at the start of the list [OK]

Common Mistakes:

• Confusing push with pop (removal)
• Thinking push adds at the end
• Mixing push with search or delete

2. Which of the following is the correct syntax to create a new node and push it onto the linked list in Java?

easy

A. Node newNode = new Node(data); newNode.next = head; head = newNode;

B. Node newNode = Node(data); newNode.next = head; head = newNode;

C. Node newNode = new Node(); newNode.data = data; head = newNode.next;

D. Node newNode = new Node(data); head = newNode.next; newNode = head;

Solution

1. Step 1: Create new node with data

   Use new Node(data) to create a node with the given data.

2. Step 2: Link new node to current head and update head

   Set newNode.next = head and then head = newNode to push at front.

3. Final Answer:

   Node newNode = new Node(data); newNode.next = head; head = newNode; -> Option A

4. Quick Check:

   Correct syntax for push = Node newNode = new Node(data); newNode.next = head; head = newNode; [OK]

Hint: Use 'new Node(data)' and update next and head correctly [OK]

Common Mistakes:

• Forgetting 'new' keyword
• Assigning head before setting newNode.next
• Incorrect order of assignments

3. What will be the output linked list after executing the following code?

class Node {
  int data;
  Node next;
  Node(int d) { data = d; next = null; }
}

Node head = null;

// Push 10
Node newNode = new Node(10);
newNode.next = head;
head = newNode;

// Push 20
newNode = new Node(20);
newNode.next = head;
head = newNode;

// Push 30
newNode = new Node(30);
newNode.next = head;
head = newNode;

// Print list
Node temp = head;
while(temp != null) {
  System.out.print(temp.data + " -> ");
  temp = temp.next;
}
System.out.print("null");

medium

A. 30 -> 20 -> 10 -> null

B. 10 -> 20 -> 30 -> null

C. null -> 10 -> 20 -> 30

D. 20 -> 30 -> 10 -> null

Solution

1. Step 1: Trace push operations

   First push 10: list is 10 -> null.
   Second push 20: new node 20 points to 10, list is 20 -> 10 -> null.
   Third push 30: new node 30 points to 20, list is 30 -> 20 -> 10 -> null.

2. Step 2: Print list

   Printing from head prints 30, then 20, then 10, then null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option A

4. Quick Check:

   Push adds at front, last pushed is first [OK]

Hint: Last pushed node appears first in the list [OK]

Common Mistakes:

• Assuming push adds at end
• Confusing order of nodes after pushes
• Printing null at start instead of end

4. Identify the error in the following push method for a linked list and select the correct fix.

void push(int data) {
  Node newNode = new Node(data);
  newNode.next = null;
  head = newNode;
}

medium

A. Assign head = null before creating newNode

B. Set newNode.next = head before updating head

C. Remove newNode.next assignment completely

D. Use newNode.data = data instead of constructor

Solution

1. Step 1: Analyze current push method

   Currently, newNode.next is set to null, then head is set to newNode. This breaks the link to existing list.

2. Step 2: Correct linking for push

   To push correctly, newNode.next should point to current head before head is updated to newNode.

3. Final Answer:

   Set newNode.next = head before updating head -> Option B

4. Quick Check:

   Link newNode to old head before updating head [OK]

Hint: Always link new node to old head before changing head [OK]

Common Mistakes:

• Setting newNode.next to null breaks list
• Updating head before linking newNode.next
• Not linking new node to existing list

5. You have a linked list with nodes containing values 5 -> 15 -> 25 -> null. You want to push a new node with value 10 such that the list remains sorted in ascending order. Which code snippet correctly pushes the node to maintain sorted order?

hard

A. Node newNode = new Node(10);
newNode.next = head;
head = newNode;

B. Node newNode = new Node(10);
newNode.next = null;
head.next = newNode;

C. Node newNode = new Node(10);
Node current = head;
while(current.next != null && current.next.data < 10) {
current = current.next;
}
newNode.next = current.next;
current.next = newNode;

D. Node newNode = new Node(10);
newNode.next = head.next;
head = newNode;

Solution

1. Step 1: Understand sorted push requirement

   To keep list sorted, find the correct position where new node's data fits between nodes.

2. Step 2: Traverse and insert node

   Traverse list until next node's data is greater or null, then insert newNode between current and current.next.

3. Final Answer:

   Node newNode = new Node(10); Node current = head; while(current.next != null && current.next.data < 10) { current = current.next; } newNode.next = current.next; current.next = newNode; -> Option C

4. Quick Check:

   Traverse to insert in sorted order [OK]

Hint: Traverse to find correct spot, then insert new node [OK]

Common Mistakes:

• Always pushing at head ignores sorting
• Not updating next pointers correctly
• Inserting at wrong position breaks order