Insert at Beginning of Circular Linked List in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a circular linked list?

A circular linked list is a linked list where the last node points back to the first node, forming a circle with no null end.

intermediate

Why do we need to update the last node's next pointer when inserting at the beginning of a circular linked list?

Because the last node points to the first node, when we insert a new node at the beginning, the last node's next pointer must point to the new node to keep the circle intact.

beginner

What is the time complexity of inserting a node at the beginning of a circular linked list if we have a pointer to the last node?

O(1) because we can directly update pointers without traversing the list.

beginner

In TypeScript, what type of variable would you use to represent a node in a circular linked list?

An object with a value property and a next property pointing to another node or itself.

beginner

What happens if you insert a node into an empty circular linked list?

The new node points to itself, making it both the first and last node in the list.

When inserting at the beginning of a circular linked list, which pointer must be updated besides the new node's next?

A The new node's previous pointer

B The second node's next pointer

C The last node's next pointer

D The head pointer only

The last node's next pointer must point to the new first node to maintain the circular structure.

If the circular linked list is empty, what should the new node's next pointer point to after insertion?

A itself

B null

C the last node

D undefined

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

What is the time complexity of inserting at the beginning of a circular linked list when you have a pointer to the last node?

A O(1)

B O(log n)

C O(n^2)

D O(n)

Insertion is O(1) because you can update pointers directly without traversal.

In a circular linked list, what does the last node's next pointer point to?

A null

B the first node

C itself

D the previous node

The last node's next pointer points to the first node to form a circle.

Which of the following is true when inserting a new node at the beginning of a circular linked list?

A The new node becomes the last node

B The list becomes linear

C The last node's next pointer remains unchanged

D The new node's next points to the old first node

The new node's next pointer must point to the old first node to keep the list connected.

Explain step-by-step how to insert a new node at the beginning of a circular linked list when you have a pointer to the last node.

Think about how the circle is maintained by updating pointers.

Describe what changes when inserting into an empty circular linked list versus a non-empty one.

Consider the special case of a single-node circle.

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