Why Delete a Node from Circular Linked List in DSA Typescript?

The Big Idea

What if removing one friend breaks the whole circle? Learn how to keep the circle unbroken!

The Scenario

Imagine you have a group of friends sitting in a circle playing a game. If one friend leaves, you need to carefully ask the person before them to link directly to the person after them, so the circle stays unbroken.

The Problem

Trying to remove a friend manually from the circle is tricky. If you lose track of who is before or after, the circle breaks and the game stops. It's easy to make mistakes and lose friends from the circle unintentionally.

The Solution

Using a circular linked list, we can easily find the friend to remove and update the links so the circle stays connected without breaking. This keeps the game going smoothly without losing track.

Before vs After

✗ Before

let friends = ['Alice', 'Bob', 'Charlie', 'Diana'];
// To remove Bob, manually shift elements or rebuild array
friends = friends.filter(name => name !== 'Bob');

✓ After

class Node {
  data: string;
  next: Node | null;
  constructor(data: string) {
    this.data = data;
    this.next = null;
  }
}
// Remove node with data 'Bob' by updating links in circular list

What It Enables

This lets us remove any friend from the circle quickly and safely, keeping the circle unbroken and the game running.

Real Life Example

In music playlists that loop songs endlessly, deleting a song from the circular list of tracks without stopping the music is like removing a node from a circular linked list.

Key Takeaways

Manual removal from a circle is error-prone and breaks the chain.

Circular linked lists keep the circle connected by updating links.

Deleting a node updates pointers to maintain the loop smoothly.

Practice

1. What happens when you delete the only node in a circular linked list?

easy

A. The list becomes empty (null).

B. The list still contains the deleted node.

C. The list points to itself indefinitely.

D. The list throws an error.

Solution

1. Step 1: Understand the single node case

   When there is only one node, it points to itself forming a circle.

2. Step 2: Delete the only node

   Removing this node leaves no nodes, so the list becomes empty (null).

3. Final Answer:

   The list becomes empty (null). -> Option A

4. Quick Check:

   Single node deleted = empty list [OK]

Hint: Deleting last node empties the list [OK]

Common Mistakes:

• Assuming list still has nodes after deleting the only node
• Not setting head to null after deletion

2. Which of the following is the correct way to update the previous node's next pointer when deleting a node in a circular linked list?

easy

A. prev.next = node.next;

B. node.next = prev.next;

C. prev = node.next;

D. node = prev.next;

Solution

1. Step 1: Identify the pointer to update

   To remove a node, the previous node's next pointer must skip the node to delete.

2. Step 2: Update the previous node's next pointer

   Set prev.next to node.next to bypass the node being deleted.

3. Final Answer:

   prev.next = node.next; -> Option A

4. Quick Check:

   prev.next points to node.next [OK]

Hint: Prev node's next skips deleted node [OK]

Common Mistakes:

• Assigning node.next to prev.next instead of the other way
• Changing the node variable instead of prev.next

3. Consider the circular linked list: 10 -> 20 -> 30 -> (back to 10). If we delete the node with value 20, what will be the new list?

medium

A. 10 -> 20 -> 30 -> (back to 10)

B. 10 -> 30 -> (back to 10)

C. 20 -> 30 -> (back to 20)

D. 30 -> 10 -> (back to 30)

Solution

1. Step 1: Identify node to delete and its previous node

   Node with value 20 is between 10 and 30. Previous node is 10.

2. Step 2: Update previous node's next pointer

   Set 10's next pointer to 30, skipping 20.

3. Final Answer:

   10 -> 30 -> (back to 10) -> Option B

4. Quick Check:

   Deleted 20, list links 10 to 30 [OK]

Hint: Link previous node to next of deleted node [OK]

Common Mistakes:

• Not updating the previous node's next pointer
• Deleting wrong node or not updating links

4. Given this TypeScript code snippet to delete a node from a circular linked list, what is the error?

function deleteNode(head: Node | null, key: number): Node | null {
  if (!head) return null;
  let curr = head, prev = null;
  do {
    if (curr.data === key) {
      if (prev) prev.next = curr.next;
      else head = curr.next;
      return head;
    }
    prev = curr;
    curr = curr.next;
  } while (curr !== head);
  return head;
}

medium

A. Does not handle the empty list case.

B. Uses 'do-while' incorrectly causing infinite loop.

C. Returns null even if node is not found.

D. Does not update the tail node's next pointer when deleting head.

Solution

1. Step 1: Analyze deletion of head node

   If deleting head, code sets head to curr.next but does not update tail's next pointer.

2. Step 2: Identify missing tail update

   In circular list, tail's next must point to new head to maintain circularity.

3. Final Answer:

   Does not update the tail node's next pointer when deleting head. -> Option D

4. Quick Check:

   Tail.next must update on head deletion [OK]

Hint: Update tail's next when head is deleted [OK]

Common Mistakes:

• Ignoring tail pointer update after head deletion
• Assuming head change auto-updates tail's next

5. You have a circular linked list with nodes: 5 -> 10 -> 15 -> 20 -> (back to 5). You want to delete the node with value 5 (head node). Which steps correctly delete the head and maintain the circular list?

hard

A. Delete head node and set head to null.

B. Set head to head.next only, no other changes.

C. Find tail node, set tail.next to head.next, update head to head.next.

D. Find tail node, set tail.next to null, update head to head.next.

Solution

1. Step 1: Find the tail node

   Traverse list to find node whose next points to head (value 20).

2. Step 2: Update tail's next pointer and head

   Set tail.next to head.next (node with value 10), then update head to head.next.

3. Final Answer:

   Find tail node, set tail.next to head.next, update head to head.next. -> Option C

4. Quick Check:

   Tail.next points to new head after deletion [OK]

Hint: Update tail.next before changing head [OK]

Common Mistakes:

• Not updating tail.next causing broken circular link
• Setting tail.next to null breaks circular list