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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting at beginning in circular linked list

What is the printed state of the circular linked list after inserting 10 at the beginning?

DSA Typescript

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

class CircularLinkedList {
  tail: Node | null = null;

  insertAtBeginning(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;
    }
  }

  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 start)";
    return result;
  }
}

const cll = new CircularLinkedList();
cll.insertAtBeginning(20);
cll.insertAtBeginning(30);
cll.insertAtBeginning(10);
console.log(cll.printList());

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

B 10 -> 30 -> 20 -> (back to start)

C 30 -> 20 -> 10 -> (back to start)

D 10 -> 20 -> 30 -> (back to start)

💡 Hint

Remember, the tail's next points to the head. Inserting at beginning means new node becomes head.

Inserting 10 at beginning adds it after tail and before current head (20). So order is 10 -> 30 -> 20.

🧠 Conceptual

intermediate

Understanding tail pointer in circular linked list insertion

When inserting a new node at the beginning of a circular linked list, which pointer should be updated to maintain the circular structure?

A The tail's next pointer to point to the new node

B The head pointer to point to the tail

C The new node's next pointer to point to the tail

D The tail pointer itself to point to the new node

💡 Hint

Think about which node points to the head in a circular linked list.

The tail's next pointer must point to the new node to keep the circular link intact when inserting at beginning.

🔧 Debug

advanced

Identify the bug in circular linked list insertion at beginning

What error will occur when running this code snippet for inserting at beginning in a circular linked list?

DSA Typescript

insertAtBeginning(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;
  }
}

A The list will break because newNode.next is set to null instead of pointing to itself when list is empty

B The tail pointer will become null causing runtime error

C The new node will not link to the next node causing infinite loop

D No error, code works fine

💡 Hint

Check what happens when the list is empty and a new node is inserted.

When list is empty, newNode.next must point to itself to maintain circular structure. Setting it to null breaks the list.

❓ Predict Output

advanced

Output after multiple insertions at beginning

What is the printed state of the circular linked list after inserting 5, 15, and 25 at the beginning in this order?

DSA Typescript

const cll = new CircularLinkedList();
cll.insertAtBeginning(5);
cll.insertAtBeginning(15);
cll.insertAtBeginning(25);
console.log(cll.printList());

A 5 -> 15 -> 25 -> (back to start)

B 25 -> 5 -> 15 -> (back to start)

C 15 -> 25 -> 5 -> (back to start)

D 25 -> 15 -> 5 -> (back to start)

💡 Hint

Each new insertion at beginning becomes the new head.

Inserting 25 last at beginning makes it the head, followed by 15 and 5.

🚀 Application

expert

Calculate length after insertions at beginning

After inserting 3 nodes at the beginning of an empty circular linked list, what is the length of the list?

A Depends on tail pointer

B 0

C 3

D 1

💡 Hint

Each insertion adds one node to the list.

Inserting 3 nodes adds 3 elements, so length is 3.

Practice

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

easy

A. The new node replaces the last node in the list.

B. The new node is added at the end of the list, breaking the circular link.

C. The list becomes linear instead of circular.

D. The new node becomes the head and points to the old head, maintaining the circular link.

Solution

1. Step 1: Understand the circular linked list structure

   A circular linked list has its last node pointing back to the head node, forming a circle.

2. Step 2: Insert new node at beginning

   The new node is linked to the current head, and the last node's next pointer is updated to this new node, making it the new head.

3. Final Answer:

   The new node becomes the head and points to the old head, maintaining the circular link. -> Option D

4. Quick Check:

   New head points to old head, circle intact [OK]

Hint: New head points to old head; last node points to new head [OK]

Common Mistakes:

• Forgetting to update last node's next pointer
• Breaking the circular link by not connecting last node
• Replacing the last node instead of adding new head

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

easy

A. newNode.next = head; last.next = newNode; head = newNode;

B. head.next = newNode; newNode.next = last; last = newNode;

C. newNode.next = null; head = newNode; last.next = head;

D. last.next = head; head = newNode; newNode.next = last;

Solution

1. Step 1: Link new node to current head

   newNode.next = head sets the new node's next pointer to the current head.

2. Step 2: Update last node's next pointer and head

   last.next = newNode updates the last node to point to the new node, and head = newNode sets the new node as the head.

3. Final Answer:

   newNode.next = head; last.next = newNode; head = newNode; -> Option A

4. Quick Check:

   Correct pointer updates maintain circular list [OK]

Hint: Set newNode.next to head, update last.next, then head [OK]

Common Mistakes:

• Setting newNode.next to null breaks circularity
• Not updating last.next to newNode
• Assigning head incorrectly before linking nodes

3. Given the following TypeScript code for inserting at the beginning of a circular linked list, what will be the printed list after insertion?

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

let head = new Node(10);
let second = new Node(20);
let third = new Node(30);
head.next = second;
second.next = third;
third.next = head; // circular link

let newNode = new Node(5);
// Insert at beginning
newNode.next = head;
third.next = newNode;
head = newNode;

// Print list
let temp = head;
do {
  console.log(temp.data);
  temp = temp.next!;
} while (temp !== head);

medium

A. 5 -> 10 -> 20 -> 30 (circular)

B. 5 -> 20 -> 30 -> 10 (circular)

C. 10 -> 20 -> 30 -> 5 (circular)

D. 5 -> 10 -> 20 -> 30 -> null

Solution

1. Step 1: Understand the initial circular list

   Initial list is 10 -> 20 -> 30 -> back to 10 (circular).

2. Step 2: Insert new node with data 5 at beginning

   newNode.next = head points 5 to 10; third.next = newNode points 30 to 5; head = newNode updates head to 5.

3. Step 3: Print traversal

   Starting at head (5), traversal prints 5, 10, 20, 30, then stops as it loops back to 5.

4. Final Answer:

   5 -> 10 -> 20 -> 30 (circular) -> Option A

5. Quick Check:

   New head 5 leads list, circle intact [OK]

Hint: New node data first, then old nodes, circle stays [OK]

Common Mistakes:

• Printing null at end instead of circular loop
• Not updating last node's next pointer
• Confusing order of nodes after insertion

4. Identify the error in this TypeScript code snippet that attempts to insert a node at the beginning of a circular linked list:

newNode.next = head;
head = newNode;
last.next = newNode;

medium

A. The last.next pointer is updated after changing head, causing incorrect link.

B. No error; code correctly inserts at beginning.

C. newNode.next should point to last instead of head.

D. head should be updated after last.next to maintain circularity.

Solution

1. Step 1: Analyze pointer updates order

   newNode.next = head sets new node's next to old head correctly.

2. Step 2: Verify the updates

   head = newNode updates head to new node. Then last.next = newNode correctly sets the last node's next to the new head since 'last' references the unchanged last node.

3. Step 3: Confirm circularity

   The final structure is newHead -> oldHead -> ... -> last -> newHead, fully circular with no breaks.

4. Final Answer:

   No error; code correctly inserts at beginning. -> Option B

5. Quick Check:

   last reference stable, circle intact [OK]

Hint: last reference remains valid after head update [OK]

Common Mistakes:

• Assuming changing head before last.next breaks circle
• Not updating last.next at all
• Pointing newNode.next incorrectly

5. You have a circular linked list with nodes containing values [15, 25, 35], where 35 points back to 15. You want to insert a new node with value 5 at the beginning. Which sequence of pointer updates correctly maintains the circular linked list?

hard

A. Set head = newNode; newNode.next = last; last.next = head;

B. Set head.next = newNode; newNode.next = last; last = newNode;

C. Set newNode.next = head; last.next = newNode; head = newNode;

D. Set newNode.next = last; head = newNode; last.next = newNode;

Solution

1. Step 1: Link new node to current head

   newNode.next = head points the new node (5) to the current head (15).

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

   last.next = newNode updates the last node (35) to point to the new node (5), maintaining circularity.

3. Step 3: Update head pointer

   head = newNode sets the new node as the head of the list.

4. Final Answer:

   Set newNode.next = head; last.next = newNode; head = newNode; -> Option C

5. Quick Check:

   New head points to old head; last points to new head [OK]

Hint: Link new node to head, last to new node, then update head [OK]

Common Mistakes:

• Updating pointers in wrong order
• Pointing newNode.next to last instead of head
• Not updating last.next to newNode