Insert at End of Circular Linked List in DSA Javascript - 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 Javascript

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

class CircularLinkedList {
  constructor() {
    this.tail = null;
  }

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

  printList() {
    if (!this.tail) return "null";
    let result = "";
    let current = this.tail.next;
    do {
      result += current.data + " -> ";
      current = current.next;
    } while (current !== this.tail.next);
    result += "null";
    return result;
  }
}

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

A 4 -> 1 -> 2 -> 3 -> null

B 1 -> 2 -> 3 -> null

C null

D 1 -> 2 -> 3 -> 4 -> null

💡 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 printList method starts from the node after tail (head) and prints all nodes until it loops back to head.

❓ Predict Output

intermediate

Output after inserting into an empty circular linked list

What is the printed state of the circular linked list after inserting the value 10 into an empty list?

DSA Javascript

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

class CircularLinkedList {
  constructor() {
    this.tail = null;
  }

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

  printList() {
    if (!this.tail) return "null";
    let result = "";
    let current = this.tail.next;
    do {
      result += current.data + " -> ";
      current = current.next;
    } while (current !== this.tail.next);
    result += "null";
    return result;
  }
}

const cll = new CircularLinkedList();
cll.insertAtEnd(10);
console.log(cll.printList());

A Error

B 10 -> null

C 10 -> 10 -> null

D null

💡 Hint

Inserting into an empty circular linked list creates a single node pointing to itself.

When the list is empty, the new node points to itself and becomes the tail. Printing starts from tail.next which is the node itself.

❓ Predict Output

advanced

Output after multiple insertions and one deletion in circular linked list

Given the code below, what is the printed state of the circular linked list after inserting 5, 10, 15 and then deleting the node with value 10?

DSA Javascript

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

class CircularLinkedList {
  constructor() {
    this.tail = null;
  }

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

  deleteNode(data) {
    if (!this.tail) return;
    let current = this.tail.next;
    let prev = this.tail;
    do {
      if (current.data === data) {
        if (current === prev) {
          this.tail = null;
        } else {
          prev.next = current.next;
          if (current === this.tail) {
            this.tail = prev;
          }
        }
        return;
      }
      prev = current;
      current = current.next;
    } while (current !== this.tail.next);
  }

  printList() {
    if (!this.tail) return "null";
    let result = "";
    let current = this.tail.next;
    do {
      result += current.data + " -> ";
      current = current.next;
    } while (current !== this.tail.next);
    result += "null";
    return result;
  }
}

const cll = new CircularLinkedList();
cll.insertAtEnd(5);
cll.insertAtEnd(10);
cll.insertAtEnd(15);
cll.deleteNode(10);
console.log(cll.printList());

A 5 -> 15 -> null

B 5 -> 10 -> 15 -> null

C null

D 15 -> 5 -> null

💡 Hint

Deleting a node updates the links and possibly the tail pointer.

Node with value 10 is removed. The list now has nodes 5 and 15 linked circularly. Printing starts from head (tail.next) which is 5.

🔧 Debug

advanced

Identify the error in insertAtEnd method of circular linked list

What error will occur when running the following insertAtEnd method code snippet?

DSA Javascript

insertAtEnd(data) {
  const newNode = new Node(data);
  if (this.tail === null) {
    newNode.next = null;
    this.tail = newNode;
  } else {
    newNode.next = this.tail.next;
    this.tail.next = newNode;
    this.tail = newNode;
  }
}

A TypeError because newNode.next is assigned null instead of a node.

B SyntaxError due to missing semicolon.

C The list will not be circular; tail.next is null causing infinite loop in print.

D No error; code works correctly.

💡 Hint

In a circular linked list, tail.next should never be null.

Setting newNode.next to null breaks the circular link. The print method loops infinitely because tail.next is null and the loop condition never ends.

❓ Predict Output

expert

Output after inserting nodes and traversing twice in circular linked list

What is the output of the code below that inserts nodes 7, 14, 21 and then prints the list twice in a row?

DSA Javascript

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

class CircularLinkedList {
  constructor() {
    this.tail = null;
  }

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

  printList() {
    if (!this.tail) return "null";
    let result = "";
    let current = this.tail.next;
    do {
      result += current.data + " -> ";
      current = current.next;
    } while (current !== this.tail.next);
    result += "null";
    return result;
  }
}

const cll = new CircularLinkedList();
cll.insertAtEnd(7);
cll.insertAtEnd(14);
cll.insertAtEnd(21);
console.log(cll.printList());
console.log(cll.printList());

A

7 -> 14 -> 21 -> null
7 -> 14 -> 21 -> null

B 7 -> 14 -> 21 -> 7 -> 14 -> 21 -> null

C

null
null

D

7 -> 14 -> 21 -> null
null

💡 Hint

Each printList call prints the full circular list once.

printList starts from head and prints all nodes once until it loops back. Calling it twice prints the same list twice separately.

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 itself, becoming the only node in the list.

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

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

D. The new node points to the head, but the list is not circular.

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 forming a circular link.

3. Final Answer:

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

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 maintaining circular link for single node

2. Which of the following is the correct syntax to insert a new node at the end of a circular linked list in JavaScript?

easy

A. newNode.next = head; lastNode.next = newNode;

B. newNode.next = null; lastNode.next = newNode;

C. newNode.next = lastNode; head.next = newNode;

D. newNode.next = newNode; head = 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 to maintain circularity.

2. Step 2: Update last node's next to new node

   The current last node's next pointer is updated to newNode, inserting it at the end.

3. Final Answer:

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

4. Quick Check:

   New node points to head, last node points to new node [OK]

Hint: New node next points to head, last node next points to new node [OK]

Common Mistakes:

• Setting newNode.next to null breaks circularity
• Swapping pointers incorrectly
• Not updating last node's next pointer

3. What will be the printed circular linked list after inserting a node with value 4 at the end of the list: 1 -> 2 -> 3 -> (back to 1)?

medium

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

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

C. 1 -> 2 -> 3 -> (back to 4)

D. 1 -> 2 -> 3 -> 4 -> null

Solution

1. Step 1: Identify current list structure

   The list currently has nodes 1, 2, 3 linked circularly, so last node 3 points back to 1.

2. Step 2: Insert node with value 4 at end

   New node 4's next points to head (1), and node 3's next points to node 4, extending the circle.

3. Final Answer:

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

4. Quick Check:

   New node added at end, circle maintained [OK]

Hint: New node added after last, points to head [OK]

Common Mistakes:

• Placing new node at start instead of end
• Breaking circular link by pointing to null
• Incorrectly updating pointers causing broken list

4. Given the code snippet below, what is the error when inserting at the end of a circular linked list?

function insertEnd(head, data) {
  let newNode = { value: data, next: null };
  if (!head) {
    head = newNode;
    newNode.next = head;
    return head;
  }
  let temp = head;
  while (temp.next !== head) {
    temp = temp.next;
  }
  temp.next = newNode;
  newNode.next = head;
  return head;
}

medium

A. Head is not updated when list is empty.

B. The while loop condition is incorrect and causes infinite loop.

C. New node is not created properly.

D. New node's next is not set to head, breaking circularity.

Solution

1. Step 1: Check new node's next pointer

   New node's next is initialized to null and never updated to point to head, breaking the circular link.

2. Step 2: Verify circularity after insertion

   Since temp.next points to newNode but newNode.next is null, the list is no longer circular.

3. Final Answer:

   New node's next is not set to head, breaking circularity. -> Option D

4. Quick Check:

   New node next must point to head [OK]

Hint: Always set new node's next to head in circular list [OK]

Common Mistakes:

• Forgetting to link new node back to head
• Incorrect loop condition causing infinite loop
• Not handling empty list properly

5. You have a circular linked list with nodes 10 -> 20 -> 30 -> (back to 10). You want to insert a new node with value 40 at the end, but also keep the list sorted in ascending order. Which approach correctly inserts the node and maintains circularity and order?

hard

A. Insert 40 at the end as usual, then rotate the list to start at 40.

B. Insert 40 at the head and update last node's next to new node.

C. Traverse to find correct position for 40, insert it there, update pointers to keep circularity.

D. Insert 40 at the end and break circularity temporarily.

Solution

1. Step 1: Find correct sorted position for new node

   Traverse the list to find where 40 fits between nodes to keep ascending order.

2. Step 2: Insert new node at found position and update pointers

   Insert new node between nodes, update previous node's next to new node, and new node's next to next node, maintaining circularity.

3. Final Answer:

   Traverse to find correct position for 40, insert it there, update pointers to keep circularity. -> Option C

4. Quick Check:

   Sorted insert requires correct position and pointer updates [OK]

Hint: Insert in sorted order by finding correct spot, update pointers [OK]

Common Mistakes:

• Inserting at end without sorting
• Breaking circularity during insertion
• Not updating last node's next pointer correctly