Bird
Raised Fist0
DSA C++programming

Insert at Beginning of Circular Linked List in DSA C++

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Mental Model
A circular linked list connects the last node back to the first, forming a loop. Inserting at the beginning means adding a new node before the current first node and updating the last node to point to this new start.
Analogy: Imagine people standing in a circle holding hands. To add a new person at the start, you place them before the first person and make sure the last person now holds hands with the new person, keeping the circle unbroken.
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Dry Run Walkthrough
Input: list: 1 -> 2 -> 3 (circular), insert value 0 at beginning
Goal: Add a new node with value 0 at the start and keep the list circular
Step 1: Create new node with value 0
new(0) null
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Why: We need a new node to insert at the beginning
Step 2: Find last node (node with value 3)
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Why: Last node must point to new first node to keep circular
Step 3: Set new node's next to current head (1)
new(0) -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Why: New node should point to old first node
Step 4: Set last node's next to new node (0)
head -> 1 -> 2 -> 3 -> new(0) -> 1 -> ... circular
But head pointer still at 1
Why: Last node must point to new first node to maintain circle
Step 5: Update head pointer to new node (0)
head -> new(0) -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Why: Head must point to new first node after insertion
Result: 
head -> 0 -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Annotated Code
DSA C++
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

class CircularLinkedList {
public:
    Node* head;
    CircularLinkedList() : head(nullptr) {}

    void insertAtBeginning(int val) {
        Node* newNode = new Node(val); // create new node
        if (!head) { // empty list
            newNode->next = newNode; // points to itself
            head = newNode; // head is new node
            return;
        }
        Node* temp = head;
        while (temp->next != head) { // find last node
            temp = temp->next;
        }
        newNode->next = head; // new node points to old head
        temp->next = newNode; // last node points to new node
        head = newNode; // update head to new node
    }

    void printList() {
        if (!head) {
            cout << "List is empty\n";
            return;
        }
        Node* temp = head;
        do {
            cout << temp->data << " -> ";
            temp = temp->next;
        } while (temp != head);
        cout << "(back to head)\n";
    }
};

int main() {
    CircularLinkedList cll;
    cll.insertAtBeginning(1);
    cll.insertAtBeginning(2);
    cll.insertAtBeginning(3);
    // List is now 3 -> 2 -> 1 circular
    cll.printList();

    cll.insertAtBeginning(0); // insert 0 at beginning
    cll.printList();

    return 0;
}
Node* newNode = new Node(val); // create new node
create new node with given value
if (!head) { newNode->next = newNode; head = newNode; return; }
handle empty list by pointing new node to itself and updating head
while (temp->next != head) { temp = temp->next; }
find last node by traversing until next points to head
newNode->next = head;
new node points to current head
temp->next = newNode;
last node points to new node to maintain circular link
head = newNode;
update head pointer to new node
OutputSuccess
3 -> 2 -> 1 -> (back to head) 0 -> 3 -> 2 -> 1 -> (back to head)
Complexity Analysis
Time: O(n) because we traverse the list to find the last node before insertion
Space: O(1) because we only create one new node regardless of list size
vs Alternative: Compared to inserting at the end which also requires traversal, inserting at beginning still needs traversal to update last node's pointer in circular list
Edge Cases
empty list
new node points to itself and becomes head
DSA C++
if (!head) { newNode->next = newNode; head = newNode; return; }
single node list
last node is the head itself; new node inserted before head and last node updated
DSA C++
while (temp->next != head) { temp = temp->next; }
When to Use This Pattern
When you see a circular linked list and need to add a node at the start, use this pattern to insert and update the last node's pointer to keep the circle intact.
Common Mistakes
Mistake: Not updating the last node's next pointer to the new head, breaking the circular link
Fix: Always find the last node and set its next pointer to the new node after insertion
Mistake: Not handling empty list case where head is null
Fix: Check if head is null and initialize new node to point to itself and set head
Summary
Inserts a new node at the beginning of a circular linked list and updates pointers to maintain the circle.
Use when you want to add an element at the start of a circular linked list.
Remember to update the last node's next pointer to the new head to keep the list circular.

Practice

(1/5)
1. What happens when you insert a new node at the beginning of a circular linked list?
easy
A. The new node replaces the last node in the list.
B. The new node is added at the end of the list, breaking the circular link.
C. The new node becomes the head and points to the old head, maintaining the circular link.
D. The list becomes linear instead of circular.

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 C

  4. Quick Check:

    New head points to old head, circle intact = A [OK]
Hint: New head points to old head; last node links 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 is the correct syntax to create a new node and insert it at the beginning of a circular linked list in C++?
easy
A. Node* newNode = new Node(data); newNode->next = head; last->next = newNode; head = newNode;
B. Node newNode(data); newNode.next = head; head = &newNode;
C. Node* newNode = new Node(data); newNode->next = head; head = newNode;
D. Node newNode = new Node(data); head = newNode; newNode->next = head;

Solution

  1. Step 1: Create new node dynamically

    Use 'new' keyword to allocate memory for new node: Node* newNode = new Node(data);

  2. Step 2: Link new node and update pointers

    Set newNode->next to current head, update last node's next to newNode, then update head to newNode.

  3. Final Answer:

    Node* newNode = new Node(data); newNode->next = head; last->next = newNode; head = newNode; -> Option A

  4. Quick Check:

    Dynamic node + last->next update + head change = C [OK]
Hint: Update last node's next before changing head [OK]
Common Mistakes:
  • Not updating last node's next pointer
  • Using stack allocation for node causing scope issues
  • Assigning head before updating last->next
3. What will be the output of the following code snippet after inserting 10 at the beginning of the circular linked list?
struct Node {
  int data;
  Node* next;
};

Node* head = new Node{20, nullptr};
head->next = head;

// Insert 10 at beginning
Node* newNode = new Node{10, nullptr};
Node* temp = head;
while(temp->next != head) {
  temp = temp->next;
}
newNode->next = head;
temp->next = newNode;
head = newNode;

// Print list
Node* curr = head;
do {
  std::cout << curr->data << " -> ";
  curr = curr->next;
} while(curr != head);
std::cout << "null";
medium
A. 20 -> null
B. 20 -> 10 -> null
C. 10 -> null
D. 10 -> 20 -> null

Solution

  1. Step 1: Initial list and insertion

    Initially, list has one node with data 20 pointing to itself. New node 10 is inserted before 20, updating last node's next to new node and head to new node.

  2. Step 2: Print traversal

    Traversal starts at head (10), prints 10, moves to 20, prints 20, then back to head stops loop.

  3. Final Answer:

    10 -> 20 -> null -> Option D

  4. Quick Check:

    New head 10 followed by 20 = A [OK]
Hint: Head changes to new node; print starts from new head [OK]
Common Mistakes:
  • Not updating last node's next pointer
  • Printing stops too early or infinite loop
  • Confusing order of nodes after insertion
4. Identify the error in the following code that attempts to insert a node at the beginning of a circular linked list:
void insertAtBeginning(Node*& head, int data) {
  Node* newNode = new Node{data, nullptr};
  newNode->next = head;
  head = newNode;
  Node* temp = head;
  while(temp->next != head) {
    temp = temp->next;
  }
  temp->next = head;
}
medium
A. The last node's next pointer is updated after changing head, causing infinite loop.
B. The new node is not linked to the old head.
C. The while loop condition is incorrect and never executes.
D. The new node is created on stack instead of heap.

Solution

  1. Step 1: Analyze pointer updates order

    The code updates head to newNode before finding the last node, so temp starts at newNode, causing the while loop to never find the last node correctly.

  2. Step 2: Consequence of wrong order

    Because last node is not found properly, temp->next = head may not update the correct node, breaking the circular link or causing infinite loops.

  3. Final Answer:

    The last node's next pointer is updated after changing head, causing infinite loop. -> Option A

  4. Quick Check:

    Update last node before changing head to avoid loop [OK]
Hint: Update last node's next before changing head [OK]
Common Mistakes:
  • Changing head before updating last node's next
  • Not handling empty list case
  • Incorrect while loop condition
5. You have a circular linked list with nodes: 5 -> 15 -> 25 -> (back to 5). You want to insert 1 at the beginning. Which sequence of pointer updates correctly inserts the new node and maintains the circular structure?
hard
A. Create new node with data 1; set newNode->next = head; update head = newNode; find last node and set last->next = newNode;
B. Create new node with data 1; find last node; set last->next = newNode; set newNode->next = head; update head = newNode;
C. Create new node with data 1; update head = newNode; set newNode->next = head; find last node and set last->next = newNode;
D. Create new node with data 1; set newNode->next = nullptr; update head = newNode; find last node and set last->next = newNode;

Solution

  1. Step 1: Create new node and find last node

    Create new node with data 1. Traverse list to find last node (node pointing back to head).

  2. Step 2: Update pointers in correct order

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

  3. Final Answer:

    Create new node with data 1; find last node; set last->next = newNode; set newNode->next = head; update head = newNode; -> Option B

  4. Quick Check:

    Last node updated before head change = B [OK]
Hint: Update last node's next before changing head [OK]
Common Mistakes:
  • Changing head before updating last node's next
  • Setting newNode->next to nullptr breaks circular link
  • Incorrect order of pointer updates
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard