Insert at End of Circular Linked List in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of inserting a node at the end of a circular linked list

What is the printed state of the circular linked list after inserting the value 4 at the end?

DSA Typescript

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

class CircularLinkedList {
  tail: Node | null = null;

  insertAtEnd(value: number) {
    const newNode = new Node(value);
    if (!this.tail) {
      newNode.next = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.tail.next;
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }

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

const cll = new CircularLinkedList();
cll.insertAtEnd(1);
cll.insertAtEnd(2);
cll.insertAtEnd(3);
cll.insertAtEnd(4);
console.log(cll.printList());

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

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

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

D 4 -> (back to head)

💡 Hint

Remember that in a circular linked list, the tail's next points to the head.

The insertAtEnd method adds the new node after the tail and updates the tail to the new node. The list after inserting 4 is 1 -> 2 -> 3 -> 4, and then it loops back to 1.

🧠 Conceptual

intermediate

Understanding tail pointer in circular linked list insertion

Why do we update the tail pointer to the new node when inserting at the end of a circular linked list?

A Because the new node becomes the head of the list.

B Because the tail pointer always points to the node before the head.

C Because the new node becomes the last node, so tail must point to it.

D Because the tail pointer should always point to the node with the smallest value.

💡 Hint

Think about what the tail pointer represents in a circular linked list.

The tail pointer always points to the last node in the list. When inserting at the end, the new node is the last node, so tail must be updated to it.

🔧 Debug

advanced

Identify the error in this circular linked list insertion code

What error will this code produce when inserting a node at the end of a circular linked list?

DSA Typescript

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

class CircularLinkedList {
  tail: Node | null = null;

  insertAtEnd(value: number) {
    const newNode = new Node(value);
    if (!this.tail) {
      newNode.next = null;
      this.tail = newNode;
    } else {
      newNode.next = this.tail.next;
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }
}

const cll = new CircularLinkedList();
cll.insertAtEnd(1);
cll.insertAtEnd(2);

A No error, code runs correctly.

B SyntaxError due to missing semicolon.

C TypeError because newNode.next is assigned null.

D The list will become linear, losing circular property.

💡 Hint

Check how the next pointer is assigned when the list is empty.

When the list is empty, newNode.next should point to itself to maintain circularity. Assigning null breaks the circular property, making the list linear.

❓ Predict Output

advanced

Output after multiple insertions in circular linked list

What is the printed state of the circular linked list after these insertions?

DSA Typescript

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

class CircularLinkedList {
  tail: Node | null = null;

  insertAtEnd(value: number) {
    const newNode = new Node(value);
    if (!this.tail) {
      newNode.next = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.tail.next;
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }

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

const cll = new CircularLinkedList();
cll.insertAtEnd(10);
cll.insertAtEnd(20);
cll.insertAtEnd(30);
cll.insertAtEnd(40);
cll.insertAtEnd(50);
console.log(cll.printList());

A 10 -> 20 -> 30 -> 40 -> (back to head)

B 10 -> 20 -> 30 -> 40 -> 50 -> (back to head)

C 50 -> 10 -> 20 -> 30 -> 40 -> (back to head)

D 50 -> (back to head)

💡 Hint

Remember the tail points to the last inserted node, and tail.next is the head.

The list after inserting 10, 20, 30, 40, 50 at the end is 10 -> 20 -> 30 -> 40 -> 50, then loops back to 10.

🧠 Conceptual

expert

Why is a circular linked list useful compared to a singly linked list?

Which of the following is the main advantage of using a circular linked list over a 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 elements in ascending order.

D It prevents duplicate values in the list.

💡 Hint

Think about what happens when you reach the end of a singly linked list.

A circular linked list connects the last node back to the first, allowing continuous traversal without encountering null, unlike singly linked lists.

Practice

1. What happens when you insert a new node at the end of an empty circular linked list?

easy

A. The new node points to null, ending the list.

B. The new node points to itself, becoming the only node in the list.

C. The list remains empty because insertion is not possible.

D. The new node points to the head, but the list has multiple nodes.

Solution

1. Step 1: Understand empty circular linked list

   An empty circular linked list has no nodes, so inserting the first node means it must point to itself to maintain circularity.

2. Step 2: Insert new node and set its next pointer

   The new node's next pointer is set to itself, making it the only node and the head of the list.

3. Final Answer:

   The new node points to itself, becoming the only node in the list. -> Option B

4. Quick Check:

   Empty list insertion = node points to itself [OK]

Hint: First node in circular list points to itself [OK]

Common Mistakes:

• Setting next pointer to null instead of itself
• Assuming list remains empty after insertion
• Not updating head pointer to new node

2. Which of the following TypeScript code snippets correctly inserts a new node at the end of a circular linked list?

easy

A. newNode.next = head; head.next = newNode; tail = newNode;

B. newNode.next = null; tail.next = newNode; tail = newNode;

C. newNode.next = head; tail.next = newNode; tail = newNode;

D. newNode.next = tail; head.next = newNode; tail = newNode;

Solution

1. Step 1: Set new node's next to head

   In a circular linked list, the last node points to the head, so newNode.next must point to head.

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

   Tail's next is updated to newNode, and tail pointer moves to newNode to mark new end.

3. Final Answer:

   newNode.next = head; tail.next = newNode; tail = newNode; -> Option C

4. Quick Check:

   New node points to head, tail updated [OK]

Hint: New node's next always points to head in circular list [OK]

Common Mistakes:

• Setting newNode.next to null breaks circularity
• Updating head.next instead of tail.next
• Not moving tail pointer to new node

3. Given the circular linked list: 10 -> 20 -> 30 -> (back to 10), what is the list after inserting 40 at the end?

medium

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

B. 40 -> 10 -> 20 -> 30 -> 40

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

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

Solution

1. Step 1: Understand circular list structure

   Original list loops from 30 back to 10, so last node 30 points to head 10.

2. Step 2: Insert 40 at end and update pointers

   New node 40 points to head 10, old tail 30 points to 40, maintaining circularity.

3. Final Answer:

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

4. Quick Check:

   New node added before head, tail points to new node [OK]

Hint: New tail points to head, list stays circular [OK]

Common Mistakes:

• Adding null at end breaks circularity
• Inserting new node at head instead of tail
• Incorrect pointer updates causing loops

4. Identify the error in this TypeScript code snippet for inserting at the end of a circular linked list:

function insertEnd(tail: Node | null, data: number): Node {
  const newNode = new Node(data);
  if (!tail) {
    newNode.next = null;
    return newNode;
  }
  newNode.next = tail.next;
  tail.next = newNode;
  return newNode;
}

medium

A. newNode.next should point to itself when list is empty

B. Returning newNode instead of tail breaks list reference

C. newNode.next should point to tail.next, not null when list is empty

D. tail.next should not be updated in insertion

Solution

1. Step 1: Check empty list insertion

   When tail is null (empty list), newNode.next should point to itself to maintain circularity, not null.

2. Step 2: Verify pointer updates for non-empty list

   For non-empty list, newNode.next = tail.next (head), tail.next = newNode is correct.

3. Final Answer:

   newNode.next should point to itself when list is empty -> Option A

4. Quick Check:

   Empty list node points to itself [OK]

Hint: Empty circular list node points to itself, not null [OK]

Common Mistakes:

• Setting newNode.next to null breaks circularity
• Returning newNode instead of updating tail reference
• Not updating tail.next pointer

5. You have a circular linked list with nodes 5 -> 15 -> 25 -> (back to 5). You want to insert 35 at the end and then insert 2 at the beginning. What is the correct final circular linked list?

hard

A. 35 -> 2 -> 5 -> 15 -> 25 -> 35

B. 5 -> 15 -> 25 -> 35 -> 2 -> 5

C. 2 -> 5 -> 15 -> 25 -> 35 -> 5

D. 2 -> 5 -> 15 -> 25 -> 35 -> 2

Solution

1. Step 1: Insert 35 at end

   After inserting 35, list is 5 -> 15 -> 25 -> 35 -> back to 5.

2. Step 2: Insert 2 at beginning

   Insert at beginning means new node 2 points to current head 5, tail's next updated to 2, making 2 the new head.

3. Step 3: Final circular list

   The list is 2 -> 5 -> 15 -> 25 -> 35 -> back to 2, maintaining circularity.

4. Final Answer:

   2 -> 5 -> 15 -> 25 -> 35 -> 2 -> Option D

5. Quick Check:

   New head inserted, tail points to new head [OK]

Hint: Tail's next always points to head in circular list [OK]

Common Mistakes:

• Not updating tail.next after inserting at beginning
• Inserting new node at end but not updating tail
• Breaking circular link by pointing to wrong node