Insert at End of Circular Linked List in DSA Typescript - Build from Scratch

Insert at End of Circular Linked List

📖 Scenario: You are managing a circular linked list that represents a round-robin game queue. Players join the queue one after another, and the list loops back to the first player after the last.

🎯 Goal: Build a circular linked list and write code to insert a new player at the end of the list, maintaining the circular structure.

📋 What You'll Learn

Create a Node class with data and next properties

Create a circular linked list with initial nodes

Add a function to insert a new node at the end of the circular linked list

Print the circular linked list starting from the head to verify insertion

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real-time systems like multiplayer game queues, music playlists, and round-robin scheduling where the list loops continuously.

💼 Career

Understanding circular linked lists helps in roles involving system programming, game development, and any software requiring efficient cyclic data management.

1

Create Node class and initial circular linked list

Create a Node class with data: number and next: Node | null properties. Then create three nodes with data 10, 20, and 30. Link them in a circular way so that the last node points back to the first node. Store the first node in a variable called head.

DSA Typescript

// Your code here to create Node class and circular linked list with 3 nodes

Hint

Define the Node class first. Then create three nodes and link them so the last node points back to the first.

2

Create a variable for the new node data

Create a variable called newData and set it to 40. This will be the data for the new node to insert at the end.

DSA Typescript

class Node {
    data: number;
    next: Node | null;

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;
node3.next = node1;

const head = node1;

// Create newData variable with value 40
// Your code here

Hint

Just create a constant variable newData and assign 40 to it.

3

Insert new node at the end of the circular linked list

Create a new node called newNode using newData. Then traverse the circular linked list starting from head to find the last node (the node whose next points back to head). Insert newNode after the last node and make newNode.next point to head to keep the list circular.

DSA Typescript

class Node {
    data: number;
    next: Node | null;

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;
node3.next = node1;

const head = node1;

const newData = 40;

// Insert newNode at the end of the circular linked list
// Your code here

Hint

Use a while loop to find the last node, then link the new node after it and back to head.

4

Print the circular linked list

Use a console.log statement to print the circular linked list starting from head. Traverse the list and collect the data values in an array until you reach head again. Then print the array joined by -> and ending with -> (back to head).

DSA Typescript

class Node {
    data: number;
    next: Node | null;

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;
node3.next = node1;

const head = node1;

const newData = 40;

const newNode = new Node(newData);

let current = head;
while (current.next !== head) {
    current = current.next!;
}
current.next = newNode;
newNode.next = head;

// Print the circular linked list
// Your code here

Hint

Use a do-while loop to traverse the circular list and collect data, then print it.

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