Delete Node at Beginning in DSA Python - Execution Trace

Concept Flow - Delete Node at Beginning

Start

↓

Check if list is empty

↓

Move head to next node

↓

Old head is removed

↓

New head is first node

↓

End

This flow shows checking if the list is empty, then moving the head pointer to the next node to delete the first node.

Execution Sample

DSA Python

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

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

    def delete_at_beginning(self):
        if self.head is None:
            return
        self.head = self.head.next

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

ll = LinkedList()
ll.head = Node(10)
ll.head.next = Node(20)
ll.head.next.next = Node(30)

ll.print_list()
ll.delete_at_beginning()
ll.print_list()

This code creates a linked list with nodes 10 -> 20 -> 30, prints it, deletes the first node, then prints the updated list.

Execution Table

Step	Action	Head Node Data	List State	Output
1	Initialize list with nodes 10 -> 20 -> 30	10	10 -> 20 -> 30 -> None	10 -> 20 -> 30 -> None
2	Call delete_at_beginning()	10	10 -> 20 -> 30 -> None	No output
3	Check if head is None	10	10 -> 20 -> 30 -> None	No, head is not None
4	Move head to next node	20	20 -> 30 -> None	No output
5	Print list after deletion	20	20 -> 30 -> None	20 -> 30 -> None
6	End	20	20 -> 30 -> None	Final list printed

💡 Deletion stops after moving head to next node; old head node is removed from list.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
head	Node(10)	Node(10)	Node(20)	Node(20)
list state	10 -> 20 -> 30 -> None	10 -> 20 -> 30 -> None	20 -> 30 -> None	20 -> 30 -> None

Key Moments - 3 Insights

Why do we check if head is None before deleting?

Because if the list is empty (head is None), there is no node to delete. This prevents errors. See execution_table row 3 where this check happens.

What happens to the old head node after deletion?

The old head node is no longer referenced by the list and is effectively removed. The head pointer moves to the next node. See execution_table row 4.

Does deleting the first node affect the rest of the list?

No, the rest of the list remains intact starting from the new head. Only the first node is removed. See execution_table rows 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the head node data after step 4?

A 20

B 30

C 10

D None

💡 Hint

Check the 'Head Node Data' column at step 4 in the execution_table.

At which step does the list state change from '10 -> 20 -> 30 -> None' to '20 -> 30 -> None'?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'List State' column in the execution_table to find when the list changes.

If the list was empty initially, which step would cause the deletion to stop?

A Step 4

B Step 3

C Step 5

D Step 2

💡 Hint

Refer to the check for head being None in execution_table row 3.

Concept Snapshot

Delete Node at Beginning in Linked List:
- Check if list is empty (head is None).
- If not empty, move head pointer to next node.
- Old first node is removed automatically.
- List now starts from new head.
- Time complexity: O(1).

Full Transcript

This concept shows how to delete the first node in a linked list. We first check if the list is empty by seeing if the head pointer is None. If it is not empty, we move the head pointer to the next node. This effectively removes the first node from the list. The rest of the list remains unchanged. The code example creates a list with nodes 10, 20, and 30, prints it, deletes the first node, then prints the updated list. The execution table traces each step, showing the head node data and list state before and after deletion. Key moments clarify why the empty check is needed, what happens to the old head, and how the rest of the list is unaffected. The visual quiz tests understanding of these steps. This operation runs in constant time because it only changes the head pointer.

Practice

1. What happens to the head pointer when you delete a node at the beginning of a singly linked list?

easy

A. It points to the last node

B. It becomes null immediately

C. It remains unchanged

D. It moves to the next node in the list

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Effect of deleting the first node

   Deleting the first node means the head must now point to the second node, which becomes the new first node.

3. Final Answer:

   It moves to the next node in the list -> Option D

4. Quick Check:

   Head points to next node after deletion [OK]

Hint: Head always moves to next node when deleting at start [OK]

Common Mistakes:

• Thinking head becomes null even if list has more nodes
• Assuming head points to last node after deletion
• Not updating head pointer at all

2. Which of the following is the correct Python syntax to delete the first node in a singly linked list with head pointer head?

easy

A. head = head.next

B. head.next = head

C. head = null

D. delete head

Solution

1. Step 1: Understand Python linked list node deletion

   To delete the first node, we move the head pointer to the next node.

2. Step 2: Check syntax correctness

   Assigning head = head.next correctly moves head to the next node. Other options are invalid Python or incorrect logic.

3. Final Answer:

   head = head.next -> Option A

4. Quick Check:

   Assign head to head.next to delete first node [OK]

Hint: Use head = head.next to delete first node [OK]

Common Mistakes:

• Using 'null' instead of 'None' in Python
• Trying to delete node with 'delete' keyword (not valid in Python)
• Assigning head.next = head which breaks list

3. What will be the output linked list after deleting the first node from the list: 1 -> 2 -> 3 -> 4 -> null?

medium

A. 3 -> 4 -> null

B. 1 -> 3 -> 4 -> null

C. 2 -> 3 -> 4 -> null

D. 1 -> 2 -> 3 -> 4 -> null

Solution

1. Step 1: Identify the first node to delete

   The first node has value 1.

2. Step 2: Delete first node and update head

   After deletion, head points to node with value 2, so list becomes 2 -> 3 -> 4 -> null.

3. Final Answer:

   2 -> 3 -> 4 -> null -> Option C

4. Quick Check:

   First node removed, list starts at 2 [OK]

Hint: Remove first node value, start list from second node [OK]

Common Mistakes:

• Removing wrong node (like second node)
• Not updating head pointer
• Assuming list becomes empty

4. Given the code below, what is the error when deleting the first node?

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

head = Node(10)
head.next = Node(20)
head = head.next.next  # Delete first node

medium

A. head becomes None causing loss of list

B. SyntaxError due to invalid assignment

C. No error, list updates correctly

D. RuntimeError due to NoneType access

Solution

1. Step 1: Trace the assignment head = head.next.next

   head.next is node with data 20, head.next.next is None (end of list).

2. Step 2: Effect of assignment

   Assigning head to None loses the entire list, effectively emptying it.

3. Final Answer:

   head becomes None causing loss of list -> Option A

4. Quick Check:

   head = head.next.next sets head to None [OK]

Hint: Assign head = head.next to delete first node, not head.next.next [OK]

Common Mistakes:

• Assigning head to head.next.next instead of head.next
• Expecting list to remain intact after wrong assignment
• Ignoring None assignment effect

5. You have a singly linked list with nodes: 5 -> 10 -> 15 -> 20 -> null. Write the steps to delete the first node and then insert a new node with value 25 at the beginning. What will be the final list?

hard

A. 10 -> 15 -> 20 -> 25 -> null

B. 25 -> 10 -> 15 -> 20 -> null

C. 5 -> 10 -> 15 -> 20 -> 25 -> null

D. 25 -> 5 -> 10 -> 15 -> 20 -> null

Solution

1. Step 1: Delete the first node

   Move head pointer from node 5 to node 10, so list becomes 10 -> 15 -> 20 -> null.

2. Step 2: Insert new node with value 25 at beginning

   Create new node with data 25, set its next to current head (node 10), then update head to new node.

3. Step 3: Final list after insertion

   List becomes 25 -> 10 -> 15 -> 20 -> null.

4. Final Answer:

   25 -> 10 -> 15 -> 20 -> null -> Option B

5. Quick Check:

   Delete first, then add new node at head [OK]

Hint: Delete head by moving to next, then add new node before head [OK]

Common Mistakes:

• Not updating head after deletion
• Appending new node at end instead of beginning
• Forgetting to link new node to old head