Delete Node at End in DSA Python

Mental Model

To remove the last item, find the one before it and make it the new end by cutting off the last.

Analogy: Imagine a line of people holding hands. To remove the last person, the second last person lets go of their hand, so the last person leaves the line.

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

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, delete node at end

Goal: Remove the last node so the list ends at node 2

Step 1: start at head node 1

head -> [curr->1] -> 2 -> 3 -> null

Why: We begin from the start to find the node before the last

Step 2: move curr to node 2

head -> 1 -> [curr->2] -> 3 -> null

Why: We move forward to find the node before the last node

Step 3: curr.next points to last node 3, so set curr.next to null to remove last node

head -> 1 -> 2 -> null

Why: Disconnect last node by making second last node the new end

Result:

head -> 1 -> 2 -> null

Annotated Code

DSA Python

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

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

    def append(self, val):
        new_node = Node(val)
        if not self.head:
            self.head = new_node
            return
        curr = self.head
        while curr.next:
            curr = curr.next
        curr.next = new_node

    def delete_at_end(self):
        if not self.head:
            return  # empty list, nothing to delete
        if not self.head.next:
            self.head = None  # only one node, delete it
            return
        curr = self.head
        while curr.next.next:
            curr = curr.next  # move to second last node
        curr.next = None  # remove last node

    def __str__(self):
        vals = []
        curr = self.head
        while curr:
            vals.append(str(curr.val))
            curr = curr.next
        return ' -> '.join(vals) + ' -> null'

# Driver code
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
print("Before deletion:", ll)
ll.delete_at_end()
print("After deletion:", ll)

if not self.head:

check if list is empty to avoid errors

if not self.head.next:

handle single node list by setting head to None

while curr.next.next:

move curr to second last node by checking next's next

curr.next = None

remove last node by disconnecting it

Output

Before deletion: 1 -> 2 -> 3 -> null

After deletion: 1 -> 2 -> null

Complexity Analysis

Time: O(n) because we must traverse the list to find the second last node

Space: O(1) because we only use a few pointers, no extra space grows with input

vs Alternative: Compared to deleting from start which is O(1), deleting at end requires traversal making it O(n)

Edge Cases

empty list

no deletion occurs, list remains empty

DSA Python

if not self.head:

single node list

head is set to None, list becomes empty

DSA Python

if not self.head.next:

When to Use This Pattern

When asked to remove the last item in a singly linked list, use traversal to find the second last node and disconnect the last.

Common Mistakes

Mistake: Trying to delete last node without checking if list is empty or has one node
Fix: Add checks for empty list and single node list before traversal

Mistake: Stopping traversal at last node instead of second last node
Fix: Traverse until curr.next.next is None to reach second last node

Summary

Deletes the last node from a singly linked list by disconnecting it.

Use when you need to remove the end element of a linked list.

Remember to find the second last node to safely remove the last node.

Practice

1. What is the main purpose of the Delete Node at End operation in a singly linked list?

easy

A. Remove the first node from the linked list

B. Add a new node at the end of the linked list

C. Remove the last node from the linked list

D. Reverse the linked list

Solution

1. Step 1: Understand the operation

   The operation aims to remove a node from the end of the singly linked list.

2. Step 2: Identify the correct description

   Removing the last node means deleting the tail node, not adding or reversing nodes.

3. Final Answer:

   Remove the last node from the linked list -> Option C

4. Quick Check:

   Delete Node at End = Remove last node [OK]

Hint: Deleting at end means removing the last node [OK]

Common Mistakes:

• Confusing delete at end with delete at beginning
• Thinking it adds a node instead of removing
• Mixing up with reversing the list

2. Which of the following is the correct syntax to delete the last node in a singly linked list in Python?

easy

A. Set last node's next to head

B. Set head = null directly

C. Create a new node and assign it to head

D. Traverse to second last node and set its next to null

Solution

1. Step 1: Understand deletion at end

   To delete the last node, we must find the second last node and make its next pointer null.

2. Step 2: Check each option

   Setting head = null deletes the whole list, not just last node. Setting last node's next to head creates a cycle. Creating a new node and assigning to head adds a node, not deletes.

3. Final Answer:

   Traverse to second last node and set its next to null -> Option D

4. Quick Check:

   Delete last node = second last node next = null [OK]

Hint: Set second last node's next to null to delete last node [OK]

Common Mistakes:

• Setting head to null deletes entire list
• Creating cycles by wrong pointer assignments
• Adding nodes instead of deleting

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

medium

A. 1 -> 2 -> 3 -> null

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

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

D. 1 -> 2 -> null

Solution

1. Step 1: Identify the last node

   The last node in the list is the node with value 4.

2. Step 2: Delete the last node

   Removing node 4 means the new last node is 3, so the list ends at 3 with next as null.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option A

4. Quick Check:

   Last node 4 removed = 1 -> 2 -> 3 [OK]

Hint: Last node removed means list ends one node earlier [OK]

Common Mistakes:

• Not updating second last node's next to null
• Removing wrong node (like first node)
• Confusing output with original list

4. Consider this code snippet to delete the last node of a singly linked list:

def delete_end(head):
    if head is None:
        return None
    if head.next is None:
        return None
    temp = head
    while temp.next is not None:
        temp = temp.next
    temp.next = None
    return head

What is the error in this code?

medium

A. The loop never stops because condition is wrong

B. temp.next is null check misses second last node

C. It deletes the first node instead of last

D. No error, code works correctly

Solution

1. Step 1: Analyze the loop condition

   The loop runs while temp.next is not null, so temp moves to the last node.

2. Step 2: Identify pointer update mistake

   After loop, temp points to last node, but to delete last node, we need second last node to set its next to null. Here, temp.next = null sets last node's next to null, which is already null, so no deletion happens.

3. Final Answer:

   temp.next is null check misses second last node -> Option B

4. Quick Check:

   Must stop at second last node to delete last [OK]

Hint: Stop at second last node, not last, to delete end node [OK]

Common Mistakes:

• Stopping loop at last node instead of second last
• Not handling single node list correctly
• Setting wrong pointers causing no deletion

5. Given a singly linked list with nodes 10 -> 20 -> 30 -> 40 -> 50 -> null, write the steps to delete the last node and then add a new node with value 60 at the end. What will be the final list?

hard

A. 10 -> 20 -> 30 -> 40 -> 60 -> null

B. 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> null

C. 10 -> 20 -> 30 -> 40 -> null

D. 10 -> 20 -> 30 -> 40 -> 50 -> null

Solution

1. Step 1: Delete the last node (50)

   Traverse to second last node (40) and set its next to null, removing 50.

2. Step 2: Add new node with value 60 at end

   Traverse to last node (40) and set its next to new node with value 60, new node's next is null.

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> 60 -> null -> Option A

4. Quick Check:

   Delete last 50, add 60 at end = 10->20->30->40->60 [OK]

Hint: Delete last node, then link new node at end [OK]

Common Mistakes:

• Not updating second last node's next to null before adding
• Appending new node without deleting last node
• Confusing node values or order