Create a Circular Singly Linked List in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Singly Linked List after Insertions

What is the printed state of the circular singly linked list after inserting nodes with values 10, 20, and 30 in that order?

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class CircularSinglyLinkedList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      newNode.next = this.head;
    } else {
      let temp = this.head;
      while (temp.next !== this.head) {
        temp = temp.next!;
      }
      temp.next = newNode;
      newNode.next = this.head;
    }
  }

  printList(): string {
    if (!this.head) return "null";
    let result = "";
    let temp = this.head;
    do {
      result += temp.value + " -> ";
      temp = temp.next!;
    } while (temp !== this.head);
    result += "(head)";
    return result;
  }
}

const list = new CircularSinglyLinkedList();
list.insert(10);
list.insert(20);
list.insert(30);
console.log(list.printList());

A 10 -> 20 -> 30 -> null

B 10 -> 20 -> 30 -> (head)

C 30 -> 20 -> 10 -> (head)

D 10 -> 20 -> (head)

💡 Hint

Remember that in a circular singly linked list, the last node points back to the head node.

The insert method adds nodes at the end. After inserting 10, 20, and 30, the list is 10 -> 20 -> 30 and the last node points back to the head (10). So the printed output ends with (head).

❓ Predict Output

intermediate

Output after Deleting Head Node in Circular Singly Linked List

Given a circular singly linked list with nodes 5 -> 15 -> 25 -> (head), what is the printed state after deleting the head node (value 5)?

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class CircularSinglyLinkedList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      newNode.next = this.head;
    } else {
      let temp = this.head;
      while (temp.next !== this.head) {
        temp = temp.next!;
      }
      temp.next = newNode;
      newNode.next = this.head;
    }
  }

  deleteHead() {
    if (!this.head) return;
    if (this.head.next === this.head) {
      this.head = null;
      return;
    }
    let temp = this.head;
    while (temp.next !== this.head) {
      temp = temp.next!;
    }
    temp.next = this.head.next;
    this.head = this.head.next;
  }

  printList(): string {
    if (!this.head) return "null";
    let result = "";
    let temp = this.head;
    do {
      result += temp.value + " -> ";
      temp = temp.next!;
    } while (temp !== this.head);
    result += "(head)";
    return result;
  }
}

const list = new CircularSinglyLinkedList();
list.insert(5);
list.insert(15);
list.insert(25);
list.deleteHead();
console.log(list.printList());

A null

B 5 -> 15 -> 25 -> (head)

C 25 -> 15 -> (head)

D 15 -> 25 -> (head)

💡 Hint

Deleting the head means the second node becomes the new head and the last node points to it.

After deleting the head (5), the new head is 15. The last node (25) points to 15, so the list is 15 -> 25 -> (head).

🔧 Debug

advanced

Identify the Bug in Circular Singly Linked List Insertion

What error will occur when running this insertion method in a circular singly linked list?

DSA Typescript

insert(value: number) {
  const newNode = new Node(value);
  if (!this.head) {
    this.head = newNode;
    newNode.next = this.head;
  } else {
    let temp = this.head;
    while (temp.next !== this.head) {
      temp = temp.next!;
    }
    temp.next = newNode;
    newNode.next = this.head;
  }
}

A No error, code runs correctly

B TypeError because newNode.next is undefined

C Infinite loop because temp.next never becomes null in circular list

D SyntaxError due to missing colon

💡 Hint

In a circular list, the last node's next points to head, never null.

The while loop condition checks for temp.next !== null, but in a circular list temp.next never becomes null, causing an infinite loop.

🚀 Application

advanced

Find Length of Circular Singly Linked List

Which code snippet correctly calculates the number of nodes in a circular singly linked list?

A

let count = 0;
if (!this.head) return count;
let temp = this.head;
do {
  count++;
  temp = temp.next!;
} while (temp !== this.head);
return count;

B

let count = 0;
let temp = this.head;
while (temp !== null) {
  count++;
  temp = temp.next!;
}
return count;

C

let count = 0;
let temp = this.head;
while (temp.next !== this.head) {
  count++;
  temp = temp.next!;
}
return count;

D

let count = 1;
let temp = this.head;
while (temp.next !== null) {
  count++;
  temp = temp.next!;
}
return count;

💡 Hint

Use a do-while loop to ensure the head node is counted and stop when you reach head again.

Option A correctly uses a do-while loop to count nodes until it loops back to head. Other options either check for null (which never occurs) or miss counting the last node.

🧠 Conceptual

expert

Why Use Circular Singly Linked List Over Singly Linked List?

Which is the main advantage of using a circular singly linked list instead of a regular singly linked list?

A It allows traversal from any node back to itself without null checks

B It uses less memory than a singly linked list

C It automatically sorts the nodes in ascending order

D It prevents duplicate values in the list

💡 Hint

Think about what happens when you reach the end of the list in a circular structure.

In a circular singly linked list, the last node points back to the head, allowing continuous traversal without encountering null, unlike a regular singly linked list.

Practice

1. What is a key characteristic of a circular singly linked list compared to a regular singly linked list?

easy

A. The last node points back to the first node, forming a circle.

B. Each node has two pointers, one to the next and one to the previous node.

C. It uses an array internally to store nodes.

D. The list always has a fixed size.

Solution

1. Step 1: Understand the structure of a circular singly linked list

   In a circular singly linked list, the last node's next pointer points back to the first node, creating a loop.

2. Step 2: Compare with other list types

   Regular singly linked lists end with a null pointer, doubly linked lists have two pointers per node, and arrays are not linked lists.

3. Final Answer:

   The last node points back to the first node, forming a circle. -> Option A

4. Quick Check:

   Circular list last node points to head = A [OK]

Hint: Remember: circular means last node links back to first [OK]

Common Mistakes:

• Thinking circular means doubly linked
• Assuming last node points to null
• Confusing arrays with linked lists

2. Which of the following TypeScript code snippets correctly initializes an empty circular singly linked list?

easy

A. let head: Node = null; head.next = head;

B. let head: Node | null = null;

C. let head: Node | null = new Node(null); head.next = null;

D. let head: Node = new Node(null); head.next = head;

Solution

1. Step 1: Understand initialization of circular singly linked list

   For an empty circular singly linked list with one node, the node's next pointer should point to itself.

2. Step 2: Analyze each option

   let head: Node = new Node(null); head.next = head; creates a node and sets its next to itself, correctly forming a circular list with one node. let head: Node | null = null; sets head to null (empty list, but not circular). let head: Node | null = new Node(null); head.next = null; sets next to null (not circular). let head: Node = null; head.next = head; tries to assign next on null (error).

3. Final Answer:

   let head: Node = new Node(null); head.next = head; -> Option D

4. Quick Check:

   One node points to itself = A [OK]

Hint: One node circular list points next to itself [OK]

Common Mistakes:

• Setting next to null instead of self
• Assigning next on null variable
• Not creating a node before linking

3. Given the following TypeScript code for a circular singly linked list, what will be the output after inserting nodes with values 1, 2, and 3 in order?

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class CircularList {
  head: Node | null = null;

  insert(value: number) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      newNode.next = this.head;
    } else {
      let temp = this.head;
      while (temp.next !== this.head) {
        temp = temp.next!;
      }
      temp.next = newNode;
      newNode.next = this.head;
    }
  }

  print() {
    if (!this.head) return '';
    let result = '';
    let temp = this.head;
    do {
      result += temp.value + ' -> ';
      temp = temp.next!;
    } while (temp !== this.head);
    result += 'null';
    return result;
  }
}

const list = new CircularList();
list.insert(1);
list.insert(2);
list.insert(3);
console.log(list.print());

medium

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

B. 1 -> 2 -> 3 -> 1

C. 1 -> 2 -> 3 -> null

D. 1 -> 2 -> 3

Solution

1. Step 1: Trace insertions and list structure

   Insert 1: head points to node 1, node 1 next points to itself.
   Insert 2: find last node (1), set last node's next to new node 2, new node 2 next points to head (1).
   Insert 3: find last node (2), set last node's next to new node 3, new node 3 next points to head (1).

2. Step 2: Trace print method output

   Print starts at head (1), prints 1 -> 2 -> 3 -> then stops when it reaches head again, appends 'null'.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option C

4. Quick Check:

   Print stops at head, adds null = B [OK]

Hint: Print stops when node loops back to head [OK]

Common Mistakes:

• Printing extra head node again
• Missing 'null' at end
• Infinite loop without stopping condition

4. Identify the bug in this TypeScript method for inserting a node into a circular singly linked list:

insert(value: number) {
  const newNode = new Node(value);
  if (!this.head) {
    this.head = newNode;
    newNode.next = null;
  } else {
    let temp = this.head;
    while (temp.next !== this.head) {
      temp = temp.next!;
    }
    temp.next = newNode;
    newNode.next = this.head;
  }
}

medium

A. The method does not create a new node correctly.

B. newNode.next should point to head, not null, when list is empty.

C. The while loop condition should be temp.next === null.

D. The head should be set to null after insertion.

Solution

1. Step 1: Analyze insertion when list is empty

   When the list is empty, newNode.next is set to null, breaking circular property. It should point to head to form a circle.

2. Step 2: Check loop condition and other logic

   The while loop correctly finds the last node by checking temp.next !== head. Other parts are correct.

3. Final Answer:

   newNode.next should point to head, not null, when list is empty. -> Option B

4. Quick Check:

   Empty list node next must point to itself = C [OK]

Hint: Empty list node next must point to itself, not null [OK]

Common Mistakes:

• Setting next to null breaks circular link
• Wrong loop condition causes infinite loop
• Resetting head incorrectly

5. You want to implement a method delete(value: number) to remove a node with a given value from a circular singly linked list. Which approach correctly handles deleting the head node while maintaining the circular structure?

hard

A. Find the last node, set its next to head.next, then update head to head.next.

B. Set head to null directly without updating any other node.

C. Set head.next to null and keep head unchanged.

D. Remove the node by setting head to head.next without updating last node's next.

Solution

1. Step 1: Understand deleting head in circular list

   To delete the head, we must update the last node's next pointer to the new head (head.next) to maintain the circle.

2. Step 2: Analyze each option

   Find the last node, set its next to head.next, then update head to head.next. correctly finds last node, updates its next to head.next, then moves head to head.next.
   Set head to null directly without updating any other node. breaks the list by setting head to null without fixing last node.
   Set head.next to null and keep head unchanged. breaks the circle by setting head.next to null.
   Remove the node by setting head to head.next without updating last node's next. moves head but leaves last node pointing to old head, breaking the circle.

3. Final Answer:

   Find the last node, set its next to head.next, then update head to head.next. -> Option A

4. Quick Check:

   Last node next updated to new head = D [OK]

Hint: Update last node's next when deleting head [OK]

Common Mistakes:

• Not updating last node's next pointer
• Setting head to null without cleanup
• Breaking circular link by null assignments