Push Using Linked List Node in DSA Python - Execution Trace

Concept Flow - Push Using Linked List Node

Create new node with data

↓

Set new node's next to current head

↓

Update head to new node

↓

Done

The push operation creates a new node, links it to the current head, then updates the head to this new node.

Execution Sample

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

head = None
# Push 10
new_node = Node(10)
new_node.next = head
head = new_node

This code pushes a new node with value 10 onto an empty linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Start with empty list	None	head = None	null
2	Create new node with data=10	Node(10)	new_node created	10 -> null
3	Set new_node.next to head (None)	Node(10)	new_node.next = None	10 -> null
4	Update head to new_node	Node(10)	head = new_node	10 -> null
5	Push complete	Node(10)	head points to Node(10)	10 -> null

💡 Push operation ends after head points to new node.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
head	None	None	None	Node(10)	Node(10)
new_node	N/A	Node(10)	Node(10)	Node(10)	Node(10)
new_node.next	N/A	None	None	None	None

Key Moments - 3 Insights

Why do we set new_node.next to head before updating head?

Because new_node.next must point to the old list start before head changes. See execution_table step 3 and 4 where new_node.next is set to old head (None) before head updates.

What happens if the list is empty before push?

The head is None initially, so new_node.next becomes None, making the new node the only node. This is shown in execution_table step 1 and 3.

Why does the visual state show '10 -> null' after push?

Because the new node with data 10 points to None (end of list), so the list visually is '10 -> null' as in execution_table step 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does new_node.next point to?

A new_node itself

B null (no pointer)

C head (which is None)

D previous node

💡 Hint

Check the 'Pointer Changes' column at step 3 in execution_table.

At which step does head start pointing to the new node?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Pointer Changes' column for when head is updated.

If the list was not empty and head pointed to Node(5), what would new_node.next point to after step 3?

A Node(5)

B Node(10)

C None

D null

💡 Hint

Recall new_node.next is set to current head before head updates.

Concept Snapshot

Push Using Linked List Node:
- Create new node with data
- Set new_node.next to current head
- Update head to new_node
- New node becomes list start
- List grows at front

Full Transcript

Push operation in a linked list adds a new node at the front. First, a new node is created with the given data. Then, this new node's next pointer is set to the current head of the list. Finally, the head pointer is updated to point to this new node. This makes the new node the first element in the list. If the list was empty, head was None, so new_node.next is None, and the list now contains just the new node. The visual state after push shows the new node pointing to null, indicating the end of the list.

Practice

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

easy

A. Removes the last node from the linked list

B. Searches for a node with a specific value

C. Deletes the first node of the linked list

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

Solution

1. Step 1: Understand push operation meaning

   Push means adding a new element to the start of the linked list.

2. Step 2: Identify push effect on linked list

   The new node becomes the head, pointing to the old head node.

3. Final Answer:

   Adds a new node at the beginning of the linked 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:

• Thinking push adds at the end
• Confusing push with pop (removal)
• Assuming push deletes nodes

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

easy

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

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

C. new_node = Node(data); new_node.next = head; head = new_node

D. new_node = Node(data); head = new_node.next

Solution

1. Step 1: Create new node with data

   Use new_node = Node(data) to create a node.

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

   Set new_node.next = head and then head = new_node.

3. Final Answer:

   new_node = Node(data); new_node.next = head; head = new_node -> Option C

4. Quick Check:

   Correct push syntax = new_node = Node(data); new_node.next = head; head = new_node [OK]

Hint: New node points to head, then head updates to new node [OK]

Common Mistakes:

• Assigning head before linking new_node.next
• Confusing order of assignments
• Using undefined variables

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

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def push(head, data):
    new_node = Node(data)
    new_node.next = head
    head = new_node
    return head

head = None
head = push(head, 10)
head = push(head, 20)
head = push(head, 30)

medium

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

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

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

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

Solution

1. Step 1: Push 10 to empty list

   List becomes 10 -> null.

2. Step 2: Push 20 to front

   New head is 20, pointing to 10: 20 -> 10 -> null.

3. Step 3: Push 30 to front

   New head is 30, pointing to 20: 30 -> 20 -> 10 -> null.

4. Final Answer:

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

5. Quick Check:

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

Hint: Last pushed node is always the head [OK]

Common Mistakes:

• Assuming push adds at end
• Not updating head after push
• Mixing order of nodes

4. Find the error in this push function for a linked list:

def push(head, data):
    new_node = Node(data)
    head = new_node
    new_node.next = head
    return head

medium

A. new_node is not created properly

B. new_node.next is set after head is updated, causing a loop

C. head is not returned

D. Function does not accept head as parameter

Solution

1. Step 1: Analyze assignment order

   head is set to new_node before linking new_node.next.

2. Step 2: Identify pointer mistake

   new_node.next = head sets next to itself, creating a loop.

3. Final Answer:

   new_node.next is set after head is updated, causing a loop -> Option B

4. Quick Check:

   Link new_node.next before updating head [OK]

Hint: Set new_node.next before changing head [OK]

Common Mistakes:

• Assigning head before linking next
• Creating self-referential loops
• Forgetting to return head

5. Given a linked list with nodes 5 -> 15 -> 25 -> null, what will be the list after pushing nodes with values 35 and 45 in order using the push function?

head = Node(5)
head.next = Node(15)
head.next.next = Node(25)
head = push(head, 35)
head = push(head, 45)

hard

A. 45 -> 35 -> 5 -> 15 -> 25 -> null

B. 5 -> 15 -> 25 -> 35 -> 45 -> null

C. 35 -> 45 -> 5 -> 15 -> 25 -> null

D. 45 -> 35 -> 25 -> 15 -> 5 -> null

Solution

1. Step 1: Original list is 5 -> 15 -> 25 -> null

   Head points to 5, which points to 15, then 25.

2. Step 2: Push 35

   New node 35 points to head (5), head updates to 35: 35 -> 5 -> 15 -> 25 -> null.

3. Step 3: Push 45

   New node 45 points to head (35), head updates to 45: 45 -> 35 -> 5 -> 15 -> 25 -> null.

4. Final Answer:

   45 -> 35 -> 5 -> 15 -> 25 -> null -> Option A

5. Quick Check:

   Push adds nodes at front in order [OK]

Hint: New nodes become new head, pushing old nodes back [OK]

Common Mistakes:

• Appending instead of pushing at front
• Mixing node order after pushes
• Not updating head after push