Insert at End of Circular Linked List in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of inserting nodes at end in Circular Linked List

What is the printed state of the circular linked list after inserting 10, 20, and 30 at the end?

DSA Java

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

class CircularLinkedList {
    Node last;

    void insertEnd(int data) {
        Node newNode = new Node(data);
        if (last == null) {
            last = newNode;
            last.next = last;
        } else {
            newNode.next = last.next;
            last.next = newNode;
            last = newNode;
        }
    }

    void printList() {
        if (last == null) return;
        Node temp = last.next;
        do {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        } while (temp != last.next);
        System.out.print("null");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularLinkedList cll = new CircularLinkedList();
        cll.insertEnd(10);
        cll.insertEnd(20);
        cll.insertEnd(30);
        cll.printList();
    }
}

A 10 -> 20 -> 30 -> null

B 30 -> 20 -> 10 -> null

C 10 -> 20 -> null

D 20 -> 30 -> 10 -> null

💡 Hint

Remember that in a circular linked list, the last node points back to the first node.

Inserting at the end updates the last pointer to the new node, and the new node points to the first node. The print starts from last.next (first node) and prints in order: 10 -> 20 -> 30 -> null.

🧠 Conceptual

intermediate

Understanding pointer updates in Circular Linked List insertion

When inserting a new node at the end of a circular linked list, which pointer update is essential to maintain the circular structure?

A New node's next points to last.next, and last is updated to new node

B New node's next points to null, and last.next is updated to new node

C Last.next points to null, and new node becomes the first node

D New node's next points to last, and last.next is updated to new node

💡 Hint

Think about how the circular link is preserved after insertion.

The new node's next must point to the first node (last.next), and last must be updated to the new node to keep the list circular.

🔧 Debug

advanced

Identify the error in circular linked list insertion code

What error will occur when running this insertion code snippet for a circular linked list?

DSA Java

void insertEnd(int data) {
    Node newNode = new Node(data);
    if (last == null) {
        last = newNode;
        last.next = null;
    } else {
        newNode.next = last.next;
        last.next = newNode;
        last = newNode;
    }
}

A Compilation error due to missing return type

B NullPointerException when last is null

C Infinite loop during traversal

D The list will not be circular because last.next is set to null for the first node

💡 Hint

Check how the next pointer is set when the list is empty.

Setting last.next = null breaks the circular link for the first node. It should point to itself to maintain circularity.

❓ Predict Output

advanced

Output after multiple insertions and one traversal

Given the code below, what is the output after inserting 5, 15, 25 at the end and then printing the list?

DSA Java

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

class CircularLinkedList {
    Node last;

    void insertEnd(int data) {
        Node newNode = new Node(data);
        if (last == null) {
            last = newNode;
            last.next = last;
        } else {
            newNode.next = last.next;
            last.next = newNode;
            last = newNode;
        }
    }

    void printList() {
        if (last == null) return;
        Node temp = last.next;
        do {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        } while (temp != last.next);
        System.out.print("null");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularLinkedList cll = new CircularLinkedList();
        cll.insertEnd(5);
        cll.insertEnd(15);
        cll.insertEnd(25);
        cll.printList();
    }
}

A 25 -> 15 -> 5 -> null

B 5 -> 15 -> 25 -> null

C 5 -> 15 -> null

D 15 -> 25 -> 5 -> null

💡 Hint

The print starts from last.next which is the first node inserted.

Insertion at end updates last to new node, and new node points to first node. Printing from last.next prints in insertion order.

🧠 Conceptual

expert

Why is the last pointer important in Circular Linked List?

Which statement best explains the role of the 'last' pointer in a circular linked list?

A It is used to break the circular link temporarily during insertion

B It points to the first node to simplify traversal from the start

C It points to the last node to allow O(1) insertion at the end and easy access to the first node via last.next

D It stores the size of the list for quick length retrieval

💡 Hint

Think about how insertion at the end is efficient in circular linked lists.

The last pointer allows quick insertion at the end by pointing to the last node, and last.next points to the first node, enabling circular traversal.

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