Insert into a Sorted Circular Linked List

Insert into a Sorted Circular Linked List - Problem

Linked List Medium

Insert into a Sorted Circular Linked List

You're working with a circular linked list that maintains elements in non-descending sorted order. Your task is to insert a new value insertVal into this list while preserving its sorted property.

What makes this tricky?
• The list is circular - the last node points back to the first
• You're given a reference to any node in the list (not necessarily the smallest)
• You need to find the correct insertion point to maintain sorted order
• Special case: if the list is empty (null), create a new single-node circular list

Goal: Insert the value and return the originally given node reference (or the new node if list was empty).

Key Challenge: There are three main scenarios to handle:
1. Insert between two nodes where prev.val ≤ insertVal ≤ next.val
2. Insert at the boundary (smallest or largest position)
3. All nodes have the same value

Input & Output

example_1.py — Normal Insertion

$ Input: head = [3,4,1], insertVal = 2

› Output: [3,4,1,2] (circular: 3→4→1→2→3→...)

💡 Note: The value 2 fits perfectly between 1 and 3. We find the position where 1 ≤ 2 ≤ 3 and insert there. The list remains sorted in circular fashion.

example_2.py — Boundary Insertion

$ Input: head = [1,3,5], insertVal = 6

› Output: [1,3,5,6] (circular: 1→3→5→6→1→...)

💡 Note: The value 6 is larger than all existing values, so it should be inserted at the 'boundary' - between the largest value (5) and smallest value (1) in the circular arrangement.

example_3.py — Empty List

$ Input: head = null, insertVal = 1

› Output: [1] (circular: 1→1→1→...)

💡 Note: When the list is empty, we create a new node that points to itself, forming a single-node circular list.

Visualization

Tap to expand

Understanding the Visualization

Normal Case

Insert when prev.val ≤ insertVal ≤ next.val

Boundary Case

Insert at wrap-around when insertVal is largest or smallest

Same Values

Insert anywhere when all nodes have identical values

Key Takeaway

🎯 Key Insight: A sorted circular list has at most one 'break point' where large values wrap to small values. This is where boundary insertions occur!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal through the circular list, visiting each node at most once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 5 × 10⁴]
-10⁶ ≤ Node.val ≤ 10⁶
-10⁶ ≤ insertVal ≤ 10⁶
The list is guaranteed to be sorted in non-descending order

Asked in

f Facebook 45 G Google 38 ⊞ Microsoft 32 a Amazon 28

The optimal solution uses a single-pass traversal with smart condition checking. Key insight: in a circular sorted list, we need to handle three cases: normal insertion between two values, boundary insertion at the wrap-around point (between max and min), and insertion when all values are the same. The algorithm achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Traversals)	O(n)	O(1)	Traverse the list multiple times to handle different cases separately
One-Pass Traversal (Optimal)	O(n)	O(1)	Single traversal with smart condition checking to find insertion point

Brute Force (Multiple Traversals) — Algorithm Steps

Handle empty list case by creating new single-node circular list
First traversal: Find the minimum and maximum values in the list
Second traversal: Find the exact insertion position based on value comparisons
Handle three cases: normal insertion, boundary insertion, and duplicate values
Insert the new node and update pointers

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Traverse entire list to find min/max values

Second Pass

Traverse again to find exact insertion position

Insert Node

Create and link the new node at found position

Code -

solution.c — C

struct Node {
    int val;
    struct Node* next;
};

struct Node* createNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->next = NULL;
    return node;
}

struct Node* insert(struct Node* head, int insertVal) {
    // Handle empty list
    if (!head) {
        struct Node* newNode = createNode(insertVal);
        newNode->next = newNode;
        return newNode;
    }
    
    // Single node case
    if (head->next == head) {
        struct Node* newNode = createNode(insertVal);
        newNode->next = head;
        head->next = newNode;
        return head;
    }
    
    // Find min and max in first traversal
    struct Node* current = head;
    int minVal = head->val;
    int maxVal = head->val;
    
    do {
        if (current->val < minVal) minVal = current->val;
        if (current->val > maxVal) maxVal = current->val;
        current = current->next;
    } while (current != head);
    
    // Second traversal to find insertion point
    current = head;
    do {
        struct Node* nextNode = current->next;
        
        // Case 1: Normal insertion
        if (current->val <= insertVal && insertVal <= nextNode->val) {
            struct Node* newNode = createNode(insertVal);
            current->next = newNode;
            newNode->next = nextNode;
            return head;
        }
        
        // Case 2: Boundary insertion
        if (current->val > nextNode->val) {
            if (insertVal >= current->val || insertVal <= nextNode->val) {
                struct Node* newNode = createNode(insertVal);
                current->next = newNode;
                newNode->next = nextNode;
                return head;
            }
        }
        
        current = current->next;
    } while (current != head);
    
    // Case 3: All same values
    struct Node* newNode = createNode(insertVal);
    newNode->next = head->next;
    head->next = newNode;
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Although we make multiple traversals, each is O(n) and we do a constant number of them, so overall still O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointer variables regardless of input size

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 5 × 10⁴]
-10⁶ ≤ Node.val ≤ 10⁶
-10⁶ ≤ insertVal ≤ 10⁶
The list is guaranteed to be sorted in non-descending order

89.0K Views

Medium-High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler