Push Using Linked List Node in DSA Python

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, and the new person holds the old first person's hand.

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

Dry Run Walkthrough

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

Goal: Add the value 0 at the start of the list so it becomes the new head

Step 1: Create new node with value 0

new_node(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)

new_node(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: Make new node the first node in the list

Result:

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

Annotated Code

DSA Python

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

class LinkedList:
    def __init__(self):
        self.head = None

    def push(self, new_data):
        new_node = Node(new_data)  # create new node with data
        new_node.next = self.head  # link new node to current head
        self.head = new_node       # update head to new node

    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('null')

# Driver code
llist = LinkedList()
llist.push(3)
llist.push(2)
llist.push(1)
llist.push(0)  # push 0 at front
llist.print_list()

new_node = Node(new_data) # create new node with data

create a new node to add at the front

new_node.next = self.head # link new node to current head

point new node's next to current head to keep list connected

self.head = new_node # 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 create only one new node regardless of list size

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

Edge Cases

empty list

new node becomes the head and points to null

DSA Python

new_node.next = self.head  # link new node to current head

single element list

new node points to the single existing node and becomes new head

DSA Python

self.head = new_node       # update head to new node

When to Use This Pattern

When you need to add an element quickly at the start of a list, use the push pattern to insert at head in constant time.

Common Mistakes

Mistake: Forgetting to update the head pointer to the new node
Fix: Always assign the new node to head after linking it to the old head

Mistake: Not linking the new node's next to the old head, breaking the list
Fix: Set new_node.next = head before updating head

Summary

Adds a new node at the start of a linked list by updating pointers.

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

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 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