Push Using Linked List Node in DSA Python - Build from Scratch

Push Using Linked List Node

📖 Scenario: You are building a simple stack using a linked list. A stack is like a pile of books where you add new books on top. Each book is a node that points to the book below it.

🎯 Goal: Create a linked list node class and use it to add (push) new nodes to the top of the stack. Then print the stack from top to bottom.

📋 What You'll Learn

Create a Node class with data and next attributes

Create a variable top to represent the top of the stack

Write code to push a new node with data 10 onto the stack

Write code to push a new node with data 20 onto the stack

Print the stack from top to bottom showing node data separated by ' -> ' and ending with 'null'

💡 Why This Matters

🌍 Real World

Stacks are used in undo features, expression evaluation, and backtracking algorithms.

💼 Career

Understanding linked lists and stack operations is essential for software development and technical interviews.

1

Create the Node class and initialize the stack top

Create a class called Node with an __init__ method that takes data and sets self.data to data and self.next to None. Then create a variable called top and set it to None to represent an empty stack.

DSA Python

# Define the Node class and initialize top
# Your code here

Hint

Think of Node as a box holding data and a pointer to the next box. The top starts empty because the stack is empty.

2

Push the first node with data 10 onto the stack

Create a new Node with data 10 and assign it to a variable called new_node. Then set new_node.next to top. Finally, update top to point to new_node.

DSA Python

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

top = None

# Push node with data 10
# Your code here

Hint

Remember, pushing means putting the new node on top and linking it to the old top.

3

Push the second node with data 20 onto the stack

Create a new Node with data 20 and assign it to new_node. Set new_node.next to top. Update top to new_node.

DSA Python

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

top = None

new_node = Node(10)
new_node.next = top
top = new_node

# Push node with data 20
# Your code here

Hint

Push the new node on top just like before, linking it to the current top.

4

Print the stack from top to bottom

Create a variable called current and set it to top. Use a while loop to traverse the linked list. In each loop, print current.data followed by -> without a newline. Move current to current.next. After the loop, print null.

DSA Python

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

top = None

new_node = Node(10)
new_node.next = top
top = new_node

new_node = Node(20)
new_node.next = top
top = new_node

# Print the stack
# Your code here

Hint

Traverse from top to bottom, printing each node's data followed by ' -> ', then print 'null' at the end.

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