Push Using Linked List Node in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the 'push' operation do in a linked list?

It adds a new node at the beginning (head) of the linked list, making it the new first element.

beginner

In the push operation, why do we set the new node's next pointer to the current head?

Because the new node should point to the old first node, preserving the rest of the list after insertion.

beginner

What is the time complexity of the push operation in a singly linked list?

O(1) because it only involves changing a few pointers without traversing the list.

beginner

Show the Java code snippet to push a new node with value 10 to the head of a linked list.

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

beginner

Why is it important to update the head pointer after pushing a new node?

Because the head must always point to the first node; after push, the new node becomes the first node.

What happens to the linked list when you push a new node?

A A new node is added at the end of the list

B The list is sorted

C The list is reversed

D A new node is added at the start of the list

Push adds a new node at the beginning (head) of the linked list.

Which pointer is updated to point to the new node after a push?

A Tail pointer

B Head pointer

C Next pointer of the last node

D Previous pointer

The head pointer is updated to point to the new node after push.

What is the time complexity of the push operation in a singly linked list?

A O(1)

B O(log n)

C O(n)

D O(n^2)

Push operation takes constant time O(1) because it only changes pointers.

In Java, which of these lines correctly sets the new node's next pointer during push?

A newNode.next = null;

B head.next = newNode;

C newNode.next = head;

D newNode = head;

The new node's next pointer must point to the current head to link the list.

If the linked list is empty, what will be the head after push?

A The new node

B Undefined

C The old head

D null

If the list is empty, the new node becomes the head.

Explain step-by-step how the push operation works in a singly linked list.

Think about how the new node connects to the existing list and how the head changes.

Why is push operation efficient in linked lists compared to arrays?

Consider what happens when you add an element at the start in arrays vs linked lists.

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