Insert at Beginning of Circular Linked List in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Typescript

const newNode = new Node([1]);

Drag options to blanks, or click blank then click option'

Avalue

Bnode

Chead

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' or 'node' instead of the value to create the new node.

Passing null instead of the value.

We create a new node using the given value to insert at the beginning.

2fill in blank

medium

Complete the code to handle the empty list case by pointing newNode.next to itself.

DSA Typescript

if (!head) {
  newNode.next = [1];
  return newNode;
}

Drag options to blanks, or click blank then click option'

Aundefined

Bhead

Cnull

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to null or undefined breaks the circular property.

Using head which is null in this case.

For an empty circular list, the new node points to itself to form a single-node circle.

3fill in blank

hard

Fix the error in the loop that finds the last node in the circular list.

DSA Typescript

let current = head;
while (current.next !== [1]) {
  current = current.next;
}

Drag options to blanks, or click blank then click option'

Ahead

Bnull

CnewNode

Dundefined

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for null or undefined which never occurs in circular lists.

Using newNode which is not yet linked.

The last node points back to head in a circular linked list, so we loop until current.next is head.

4fill in blank

hard

Fill both blanks to insert newNode at the beginning and update the last node's next pointer.

DSA Typescript

current.next = [1];
newNode.next = [2];
return newNode;

Drag options to blanks, or click blank then click option'

AnewNode

Bhead

Ccurrent

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the pointers incorrectly.

Setting next to null which breaks circularity.

The last node's next points to newNode, and newNode's next points to the old head to insert at beginning.

5fill in blank

hard

Fill all three blanks to complete the insertAtBeginning function for a circular linked list.

DSA Typescript

function insertAtBeginning(head: Node | null, value: number): Node {
  const newNode = new Node([1]);
  if (!head) {
    newNode.next = [2];
    return newNode;
  }
  let current = head;
  while (current.next !== [3]) {
    current = current.next;
  }
  current.next = newNode;
  newNode.next = head;
  return newNode;
}

Drag options to blanks, or click blank then click option'

Avalue

BnewNode

Chead

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up pointers causing broken circular links.

Not handling empty list correctly.

Create newNode with value, point newNode.next to itself if list empty, loop until current.next is head to find last node.

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