Delete a Node from Circular Linked List in DSA Python

Mental Model

A circular linked list loops back to the start, so deleting a node means adjusting pointers without breaking the circle.

Analogy: Imagine people sitting in a circle holding hands. Removing one person means the two neighbors hold hands directly, keeping the circle unbroken.

head -> 1 -> 2 -> 3 -> 1 (back to head)
           ↑               ↑
          tail ←────────────

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> (back to 1), delete node with value 2

Goal: Remove node with value 2 and keep the list circular

Step 1: start at head node with value 1

head -> [1] -> 2 -> 3 -> 1 (back to head)

Why: We begin searching from the head to find the node to delete

Step 2: move to next node with value 2

head -> 1 -> [2] -> 3 -> 1 (back to head)

Why: Check if this node is the one to delete

Step 3: found node 2 to delete; link previous node 1 directly to node 3

head -> 1 -> 3 -> 1 (back to head)

Why: By skipping node 2, we remove it and keep the circle intact

Step 4: node 2 is removed; list remains circular

head -> 1 -> 3 -> 1 (back to head)

Why: The circle is maintained by linking node 1 to node 3 and node 3 back to head

Result:

head -> 1 -> 3 -> 1 (back to head)

Annotated Code

DSA Python

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

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

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node  # points to itself
            return
        curr = self.head
        while curr.next != self.head:
            curr = curr.next
        curr.next = new_node
        new_node.next = self.head

    def delete_node(self, key):
        if not self.head:
            return  # empty list

        curr = self.head
        prev = None

        # If head is to be deleted and it's the only node
        if curr.data == key and curr.next == self.head:
            self.head = None
            return

        # If head is to be deleted and list has multiple nodes
        if curr.data == key:
            # find last node to update its next pointer
            while curr.next != self.head:
                curr = curr.next
            curr.next = self.head.next
            self.head = self.head.next
            return

        # For other nodes
        prev = self.head
        curr = self.head.next
        while curr != self.head:
            if curr.data == key:
                prev.next = curr.next
                return
            prev = curr
            curr = curr.next

    def print_list(self):
        if not self.head:
            print("List is empty")
            return
        curr = self.head
        result = []
        while True:
            result.append(str(curr.data))
            curr = curr.next
            if curr == self.head:
                break
        print(" -> ".join(result) + " -> (back to head)")

# Driver code
cll = CircularLinkedList()
cll.append(1)
cll.append(2)
cll.append(3)
print("Original list:")
cll.print_list()
cll.delete_node(2)
print("After deleting node with value 2:")
cll.print_list()

if curr.data == key and curr.next == self.head:

handle deletion when only one node exists which is the head

if curr.data == key:

handle deletion when head node matches key and list has multiple nodes

while curr.next != self.head:

find last node to update its next pointer when deleting head

prev.next = curr.next

bypass the node to delete by linking previous node to next node

Output

Original list:

1 -> 2 -> 3 -> (back to head)

After deleting node with value 2:

1 -> 3 -> (back to head)

Complexity Analysis

Time: O(n) because in worst case we traverse all nodes once to find the node to delete

Space: O(1) because we only use a few pointers regardless of list size

vs Alternative: Compared to arrays where deletion requires shifting elements O(n), circular linked list deletion is O(n) but does not require shifting, only pointer updates

Edge Cases

empty list

no deletion occurs, list remains empty

DSA Python

if not self.head:
            return  # empty list

single node list where node to delete is head

list becomes empty after deletion

DSA Python

if curr.data == key and curr.next == self.head:
            self.head = None
            return

deleting head node in multi-node list

head pointer moves to next node, last node's next updated

DSA Python

if curr.data == key:
            while curr.next != self.head:
                curr = curr.next
            curr.next = self.head.next
            self.head = self.head.next
            return

deleting node not present

list remains unchanged

DSA Python

while curr != self.head:
            if curr.data == key:
                prev.next = curr.next
                return

When to Use This Pattern

When you see a problem asking to remove an element from a circular structure without breaking the loop, reach for the circular linked list deletion pattern because it carefully updates pointers to maintain the circle.

Common Mistakes

Mistake: Not updating the last node's next pointer when deleting the head node
Fix: Traverse to the last node and update its next pointer to the new head before deleting the old head

Mistake: Not handling the single-node list deletion case
Fix: Check if the node to delete is the only node and set head to None

Mistake: Breaking the loop by setting next pointer to null instead of head
Fix: Always ensure the last node's next points back to head to keep the list circular

Summary

Deletes a node from a circular linked list by adjusting pointers to keep the circle intact.

Use when you need to remove elements from a circular linked list without breaking its circular nature.

The key is to update the previous node's next pointer and, if deleting head, update the last node's next pointer to the new head.