Push Using Linked List Node in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given data.

DSA Python

new_node = Node([1])

Drag options to blanks, or click blank then click option'

Adata

Bnext

Chead

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' instead of the data value.

Passing 'head' which is the start of the list, not the new data.

We pass the data value to the Node constructor to create a new node with that data.

2fill in blank

medium

Complete the code to link the new node to the current head of the list.

DSA Python

new_node.[1] = head

Drag options to blanks, or click blank then click option'

Adata

Bprev

Cvalue

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'data' or 'value' instead of 'next'.

Trying to assign to 'prev' which is not used in singly linked list.

The 'next' pointer of the new node should point to the current head to insert it at the front.

3fill in blank

hard

Fix the error in updating the head to point to the new node.

DSA Python

head = [1]

Drag options to blanks, or click blank then click option'

Anew_node.next

BNone

Cnew_node

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head to new_node.next which skips the new node.

Assigning head to None which empties the list.

After linking, the head must be updated to the new node to reflect the new start of the list.

4fill in blank

hard

Fill both blanks to complete the push function that adds a new node at the front.

DSA Python

def push(head, data):
    new_node = Node([1])
    new_node.[2] = head
    head = new_node
    return head

Drag options to blanks, or click blank then click option'

Adata

Bnext

Cprev

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for linking.

Passing wrong variable to Node constructor.

We create a new node with the data, link its next to head, then update head to new_node.

5fill in blank

hard

Fill all three blanks to complete the push function with variable names and pointer updates.

DSA Python

def push([1], [2]):
    new_node = Node([2])
    new_node.[3] = [1]
    [1] = new_node
    return [1]

Drag options to blanks, or click blank then click option'

Ahead

Bdata

Cnext

Dnew_node

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing variable names in parameters and inside function.

Using wrong pointer name instead of 'next'.

The function takes head and data, creates new_node with data, links new_node.next to head, updates head to new_node, and returns 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