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

Insert at End of Circular Linked List

📖 Scenario: You are managing a circular linked list that represents a round-robin queue of tasks. Each node holds a task number. You want to add a new task at the end of the queue.

🎯 Goal: Build a circular linked list with initial tasks, then write code to insert a new task at the end of the list, and finally print the list to verify the insertion.

📋 What You'll Learn

Create a circular linked list with three nodes containing values 10, 20, and 30

Create a variable called newData with value 40

Write code to insert a new node with newData at the end of the circular linked list

Print the circular linked list starting from head to verify the new node is added at the end

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real-world systems like task schedulers, multiplayer games turn management, and buffering data streams where the list cycles continuously.

💼 Career

Understanding circular linked lists is important for software engineers working on operating systems, embedded systems, and real-time applications where efficient cyclic data handling is required.

1

Create initial circular linked list

Create a class Node with an integer data and a Node next. 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 Java

// Define Node class and create circular linked list with nodes 10, 20, 30
// Your code here

Hint

Remember to link the last node's next to the head to make the list circular.

2

Create new data variable

Create an integer variable called newData and set it to 40.

DSA Java

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

public class CircularLinkedList {
    public static void main(String[] args) {
        Node head = new Node(10);
        Node second = new Node(20);
        Node third = new Node(30);
        head.next = second;
        second.next = third;
        third.next = head; // circular link
        
        // Create newData variable
        // Your code here
    }
}

Hint

Just create a simple integer variable named newData and assign 40.

3

Insert new node at end of circular linked list

Create a new Node with newData. Then traverse the circular linked list starting from head to find the last node (the node whose next is head). Insert the new node after the last node and update the new node's next to point to head.

DSA Java

        Node newNode = new Node(newData);
        Node temp = head;
        while (temp.next != head) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.next = head;
        // Print the circular linked list

Hint

Traverse until you find the node whose next points to head. Then insert the new node there.

4

Print the circular linked list

Write a Node variable current starting at head. Use a do-while loop to print each node's data followed by " -> ". Stop when current reaches head again. After the loop, print "null".

DSA Java

Hint

Use a do-while loop to print all nodes in the circular linked list starting from head.

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 the head, but the list remains empty.

B. The new node points to itself, becoming the only node in the list.

C. The new node is discarded because the list is empty.

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

Solution

1. Step 1: Understand circular linked list empty state

   When the list is empty, there is no node, so the new node must point to itself to form a circle.

2. Step 2: Insert new node and update pointers

   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: Empty circular list node points to itself [OK]

Common Mistakes:

• Setting new node's next to null
• Not updating head pointer
• Assuming list remains empty

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

easy

A. newNode.next = head; tail.next = newNode; tail = newNode;

B. newNode.next = null; tail.next = newNode; tail = newNode;

C. newNode.next = tail; head.next = newNode; tail = newNode;

D. newNode.next = head; 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 = head is correct.

2. Step 2: Update tail's next and tail pointer

   Tail's next should point to newNode, and tail should be updated to newNode to maintain the list.

3. Final Answer:

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

4. Quick Check:

   New node points to head, tail updated [OK]

Hint: New node next = head, tail next = new node [OK]

Common Mistakes:

• Setting newNode.next to null
• Updating head.next instead of tail.next
• Not updating tail pointer

3. Given the following circular linked list with nodes 10 -> 20 -> 30 -> back to 10, what will be the list after inserting 40 at the end?

Node head = new Node(10);
Node second = new Node(20);
Node third = new Node(30);
head.next = second;
second.next = third;
third.next = head;

Node newNode = new Node(40);
Node tail = third;
newNode.next = head;
tail.next = newNode;
tail = newNode;

medium

A. 40 -> 10 -> 20 -> 30 -> back to 40

B. 10 -> 20 -> 30 -> back to 10 (unchanged)

C. 10 -> 20 -> 30 -> 40 -> back to 10

D. 10 -> 20 -> 40 -> 30 -> back to 10

Solution

1. Step 1: Understand initial list and insertion

   Initial list is 10 -> 20 -> 30 -> back to 10. Inserting 40 at end means 30's next points to 40, and 40 points to head (10).

2. Step 2: Update tail and next pointers

   After insertion, tail is updated to 40, and list becomes 10 -> 20 -> 30 -> 40 -> back to 10.

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> back to 10 -> Option C

4. Quick Check:

   New node added at end, circular link maintained [OK]

Hint: New node next = head, tail next = new node [OK]

Common Mistakes:

• Not updating tail.next to new node
• Not updating tail pointer
• Breaking circular link

4. Identify the error in the following code snippet that inserts a node at the end of a circular linked list:

Node newNode = new Node(50);
newNode.next = null;
tail.next = newNode;
tail = newNode;
tail.next = head;

medium

A. Setting newNode.next to null breaks the circular link.

B. Not updating tail pointer causes list corruption.

C. tail.next should point to null, not newNode.

D. head pointer is incorrectly updated.

Solution

1. Step 1: Check newNode.next assignment

   Setting newNode.next to null breaks the circular property because last node must point to head.

2. Step 2: Verify tail.next and tail updates

   tail.next is set to newNode and tail updated correctly, but newNode.next should point to head, not null.

3. Final Answer:

   Setting newNode.next to null breaks the circular link. -> Option A

4. Quick Check:

   newNode.next must point to head, not null [OK]

Hint: Last node next must point to head, never null [OK]

Common Mistakes:

• Setting newNode.next to null
• Not maintaining circular link
• Confusing tail and head pointers

5. You have a circular linked list with nodes 5 -> 15 -> 25 -> back to 5. You want to insert a new node with value 35 at the end. After insertion, you want to print the list starting from head. Which code snippet correctly performs insertion and prints the list?

Node head = new Node(5);
Node second = new Node(15);
Node third = new Node(25);
head.next = second;
second.next = third;
third.next = head;

Node newNode = new Node(35);
Node tail = third;
// Insert newNode at end
// Print list starting from head

hard

A. newNode.next = null;
tail.next = newNode;
tail = newNode;
Node temp = head;
while(temp != null) { System.out.print(temp.data + " -> "); temp = temp.next; }
System.out.print("null");

B. newNode.next = head;
tail.next = newNode;
tail = newNode;
Node temp = tail;
do { System.out.print(temp.data + " -> "); temp = temp.next; } while(temp != tail);
System.out.print("null");

C. newNode.next = head;
head.next = newNode;
tail = newNode;
Node temp = head;
do { System.out.print(temp.data + " -> "); temp = temp.next; } while(temp != head);
System.out.print("null");

D. newNode.next = head;
tail.next = newNode;
tail = newNode;
Node temp = head;
do { System.out.print(temp.data + " -> "); temp = temp.next; } while(temp != head);
System.out.print("null");

Solution

1. Step 1: Insert newNode correctly at end

   Set newNode.next to head, update tail.next to newNode, and update tail to newNode to maintain circular list.

2. Step 2: Print list starting from head using do-while

   Use a do-while loop starting at head, printing each node until we return to head, ensuring all nodes are printed once.

3. Final Answer:

   newNode.next = head; tail.next = newNode; tail = newNode; followed by do-while print from head -> Option D

4. Quick Check:

   Insert at end + do-while print from head [OK]

Hint: Use do-while to print circular list once [OK]

Common Mistakes:

• Setting newNode.next to null
• Using while loop with null condition
• Starting print from tail instead of head