Insert into a Sorted Circular Linked List

Insert into a Sorted Circular Linked List - Problem

Linked List Medium

Given a Circular Linked List node, which is sorted in non-descending order, write a function to insert a value insertVal into the list such that it remains a sorted circular list.

The given node can be a reference to any single node in the list and may not necessarily be the smallest value in the circular list.

If there are multiple suitable places for insertion, you may choose any place to insert the new value. After the insertion, the circular list should remain sorted.

If the list is empty (i.e., the given node is null), you should create a new single circular list and return the reference to that single node. Otherwise, you should return the originally given node.

Input & Output

Example 1 — Normal Insertion

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

› Output: [1,2,3,4]

💡 Note: Insert 2 between 1 and 3 to maintain sorted order. The circular structure is preserved with the last node pointing back to the first.

Example 2 — Empty List

$ Input: head = [], insertVal = 1

› Output: [1]

💡 Note: Empty list case: Create a new single-node circular list where the node points to itself.

Example 3 — Insert at Boundary

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

› Output: [3,4,1,2]

💡 Note: Insert 2 at the wrap-around point between 4 and 1, since 2 fits between the maximum (4) and minimum (1) values.

Constraints

0 ≤ Number of Nodes ≤ 5 × 10⁴
-10⁶ ≤ Node.val ≤ 10⁶
-10⁶ ≤ insertVal ≤ 10⁶

Visualization

Tap to expand

Asked in

F Facebook 25 G Google 20 a Amazon 15 M Microsoft 12

The key insight is recognizing the three insertion cases in a circular sorted list: normal insertion between nodes, insertion at the wrap-around point, and handling uniform values. The optimal approach uses two pointers to traverse the list once, checking all conditions simultaneously. Time: O(n), Space: O(1).

Common Approaches

✓ Heap

⏱️ Time: N/A Space: N/A

Single Pass Traversal

⏱️ Time: O(n) Space: O(1)

Walk through the circular linked list checking three cases: normal insertion between two nodes, insertion at the wrap-around point, or handling when all values are the same.

Two-Pointer Approach

⏱️ Time: O(n) Space: O(1)

Use prev and curr pointers to traverse the circular list, checking for normal insertion points, wrap-around transitions, and uniform value cases in a single pass.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

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

Node* insert(Node* head, int insertVal) {
    Node* newNode = createNode(insertVal);
    
    // Case 1: Empty list
    if (head == NULL) {
        return newNode;
    }
    
    // Case 2: Single node list
    if (head->next == head) {
        head->next = newNode;
        newNode->next = head;
        return head;
    }
    
    // Case 3: Multiple nodes - find insertion point
    Node* curr = head;
    
    do {
        // Case 3a: Normal insertion between curr and curr->next
        if (curr->val <= insertVal && insertVal <= curr->next->val) {
            newNode->next = curr->next;
            curr->next = newNode;
            return head;
        }
        
        // Case 3b: Insertion at wrap-around point (curr->val > curr->next->val)
        if (curr->val > curr->next->val) {
            // Insert if value is >= max or <= min
            if (insertVal >= curr->val || insertVal <= curr->next->val) {
                newNode->next = curr->next;
                curr->next = newNode;
                return head;
            }
        }
        
        curr = curr->next;
    } while (curr != head);
    
    // Case 3c: All nodes have same value - insert anywhere
    newNode->next = head->next;
    head->next = newNode;
    return head;
}

void parseArray(char* str, int* arr, int* size) {
    *size = 0;
    if (strlen(str) <= 2) return; // Empty array "[]"
    
    char* ptr = str + 1; // Skip '['
    char* endPtr;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',') {
            ptr++;
            continue;
        }
        arr[(*size)++] = (int)strtol(ptr, &endPtr, 10);
        ptr = endPtr;
    }
}

void printList(Node* head) {
    if (head == NULL) {
        printf("[]");
        return;
    }
    
    printf("[");
    Node* curr = head;
    int first = 1;
    do {
        if (!first) printf(",");
        printf("%d", curr->val);
        first = 0;
        curr = curr->next;
    } while (curr != head);
    printf("]");
}

int main() {
    char line[1000];
    int arr[100];
    int size;
    
    // Read array
    if (fgets(line, sizeof(line), stdin)) {
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        parseArray(line, arr, &size);
    }
    
    // Read insertVal
    int insertVal;
    scanf("%d", &insertVal);
    
    // Build circular linked list
    Node* head = NULL;
    if (size > 0) {
        head = createNode(arr[0]);
        Node* curr = head;
        for (int i = 1; i < size; i++) {
            curr->next = createNode(arr[i]);
            curr = curr->next;
        }
        curr->next = head; // Make it circular
    }
    
    // Insert value
    head = insert(head, insertVal);
    
    // Print result
    printList(head);
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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