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.