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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting 10 at the beginning?

Given the circular linked list: 20 -> 30 -> 40 -> (back to 20), what is the list after inserting 10 at the beginning?

DSA Java

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

class CircularLinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            newNode.next = newNode;
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != head) {
                temp = temp.next;
            }
            newNode.next = head;
            temp.next = newNode;
            head = newNode;
        }
    }

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

public class Main {
    public static void main(String[] args) {
        CircularLinkedList cll = new CircularLinkedList();
        cll.head = new Node(20);
        Node second = new Node(30);
        Node third = new Node(40);
        cll.head.next = second;
        second.next = third;
        third.next = cll.head;

        cll.insertAtBeginning(10);
        cll.printList();
    }
}

A 20 -> 30 -> 40 -> null

B 10 -> 20 -> 30 -> 40 -> null

C 10 -> 20 -> 30 -> 40 -> 10 -> null

D 20 -> 30 -> 40 -> 10 -> null

💡 Hint

Remember to update the last node's next pointer to the new head.

Inserting at the beginning means the new node becomes the head. The last node's next pointer must point to this new head to maintain circularity. So the list becomes 10 -> 20 -> 30 -> 40 -> back to 10, printed as 10 -> 20 -> 30 -> 40 -> null.

❓ Predict Output

intermediate

What is the output after inserting 50 at the beginning of an empty list?

Given an empty circular linked list, what is the output after inserting 50 at the beginning?

DSA Java

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

class CircularLinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            newNode.next = newNode;
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != head) {
                temp = temp.next;
            }
            newNode.next = head;
            temp.next = newNode;
            head = newNode;
        }
    }

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

public class Main {
    public static void main(String[] args) {
        CircularLinkedList cll = new CircularLinkedList();
        cll.insertAtBeginning(50);
        cll.printList();
    }
}

A null

B 50 -> 50 -> null

C 50 -> null

D Error

💡 Hint

When the list is empty, the new node points to itself.

When inserting into an empty circular linked list, the new node points to itself and becomes the head. So the list contains one node with data 50, printed as 50 -> null.

🔧 Debug

advanced

Why does this insertion code cause an infinite loop?

Consider this code snippet for inserting at the beginning of a circular linked list. Why does it cause an infinite loop when printing?

DSA Java

void insertAtBeginning(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        Node temp = head;
        while (temp.next != head) {
            temp = temp.next;
        }
        newNode.next = head;
        temp.next = newNode;
        head = newNode;
    }
}

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

A Because temp.next is not updated to newNode, losing the last node link.

B Because newNode.next is not assigned, breaking the circular link.

C Because head is never assigned when list is empty, causing null pointer exception.

D Because printList uses while(temp != null) which never ends in circular list.

💡 Hint

Think about how to detect the end of a circular linked list.

In a circular linked list, there is no null next pointer. Using while(temp != null) causes an infinite loop because temp never becomes null. The correct approach is to loop until temp reaches head again.

❓ Predict Output

advanced

What is the output after multiple insertions at beginning?

Starting with an empty circular linked list, insert 5, then 15, then 25 at the beginning. What is the final list?

DSA Java

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

class CircularLinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            newNode.next = newNode;
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != head) {
                temp = temp.next;
            }
            newNode.next = head;
            temp.next = newNode;
            head = newNode;
        }
    }

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

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

A 25 -> 15 -> 5 -> null

B 5 -> 15 -> 25 -> null

C 15 -> 25 -> 5 -> null

D 5 -> 25 -> 15 -> null

💡 Hint

Each new node becomes the new head.

Inserting at beginning means the newest inserted node is the head. So after inserting 5, then 15, then 25, the list is 25 -> 15 -> 5 -> null.

🧠 Conceptual

expert

Why is updating the last node's next pointer necessary when inserting at beginning?

In a circular linked list, when inserting a new node at the beginning, why must we update the last node's next pointer to the new node?

A To maintain the circular link so the last node points to the new head, preserving the loop.

B To avoid memory leaks by freeing the old head node.

C To ensure the new node points to null, marking the end of the list.

D To keep the list sorted in ascending order automatically.

💡 Hint

Think about what makes the list circular.

The circular linked list loops back from the last node to the head. When head changes, the last node must point to the new head to keep the circle intact.

Practice

1. What happens when you insert a new node at the beginning of a circular linked list?

easy

A. The new node becomes the head and points to the old head, maintaining the circular link.

B. The new node is added at the end of the list, breaking the circular link.

C. The new node replaces the last node in the list.

D. The list becomes linear and loses its circular property.

Solution

1. Step 1: Understand the circular linked list structure

   In a circular linked list, the last node points 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 A

4. Quick Check:

   New head points to old head, circle intact = C [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 linking last node
• Replacing last node instead of adding new head

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

easy

A. last.next = head; head = newNode; newNode.next = last;

B. head.next = newNode; newNode.next = last; last = newNode;

C. newNode.next = null; head = newNode; last.next = head;

D. newNode.next = head; last.next = newNode; head = newNode;

Solution

1. Step 1: Link new node to current head

   Set newNode.next = head to point new node to the current head.

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

   Set last.next = newNode to maintain circular link, then update head = newNode.

3. Final Answer:

   newNode.next = head; last.next = newNode; head = newNode; -> Option D

4. Quick Check:

   Correct pointer updates = A [OK]

Hint: Link new node to head, update last.next, then move head [OK]

Common Mistakes:

• Setting newNode.next to null breaks circular link
• Not updating last.next to new node
• Incorrect order of pointer updates

3. What will be the output of the following code snippet after inserting a node with value 10 at the beginning of the circular linked list?

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

Node head = new Node(20);
Node second = new Node(30);
head.next = second;
second.next = head; // circular link

Node newNode = new Node(10);
// Insert at beginning
newNode.next = head;
second.next = newNode;
head = newNode;

// Print list starting from head
Node temp = head;
do {
  System.out.print(temp.data + " -> ");
  temp = temp.next;
} while(temp != head);
System.out.print("null");

medium

A. 10 -> 20 -> 30 -> null

B. 20 -> 30 -> 10 -> null

C. 10 -> 30 -> 20 -> null

D. 30 -> 20 -> 10 -> null

Solution

1. Step 1: Understand initial list and insertion

   Initial list: 20 -> 30 -> back to 20. New node 10 inserted at beginning, so head moves to 10.

2. Step 2: Trace the print loop

   Starting at head (10), print 10, then 20, then 30, then loop ends at head again.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   New head 10 followed by old nodes = D [OK]

Hint: Start printing from new head, follow next pointers until back to head [OK]

Common Mistakes:

• Printing nodes in wrong order
• Not updating last node's next pointer
• Confusing circular link with null termination

4. Identify the error in the following code that attempts to insert a new node at the beginning of a circular linked list:

Node newNode = new Node(5);
newNode.next = head;
head = newNode;
// Missing update of last node's next pointer

medium

A. The head should not be updated before updating last node's next pointer.

B. The new node's next pointer should be null instead of head.

C. The last node's next pointer is not updated to point to the new head, breaking the circular link.

D. The new node should be inserted at the end, not the beginning.

Solution

1. Step 1: Check pointer updates after insertion

   New node points to old head, and head is updated, but last node still points to old head.

2. Step 2: Identify circular link break

   Since last node's next is not updated to new head, the circular link breaks, causing incorrect list traversal.

3. Final Answer:

   The last node's next pointer is not updated to point to the new head, breaking the circular link. -> Option C

4. Quick Check:

   Last node must point to new head to keep circle [OK]

Hint: Always update last.next to new head after insertion [OK]

Common Mistakes:

• Forgetting to update last node's next pointer
• Assuming head update is enough
• Not maintaining circular property

5. Given a circular linked list with nodes 5 -> 15 -> 25 -> back to 5, write the sequence of node values after inserting a new node with value 1 at the beginning. Assume the insertion updates all pointers correctly. What is the resulting list?

hard

A. 5 -> 15 -> 25 -> 1 -> null

B. 1 -> 5 -> 15 -> 25 -> null

C. 1 -> 15 -> 25 -> 5 -> null

D. 25 -> 5 -> 15 -> 1 -> null

Solution

1. Step 1: Insert new node at beginning

   New node with value 1 points to old head (5), and last node (25) points to new node.

2. Step 2: Update head pointer

   Head is updated to new node (1), so traversal starts from 1.

3. Final Answer:

   1 -> 5 -> 15 -> 25 -> null -> Option B

4. Quick Check:

   New head 1 followed by old nodes in order [OK]

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

Common Mistakes:

• Not updating last node's next pointer
• Incorrect order of nodes after insertion
• Confusing circular list with linear list