Split a Circular Linked List - Practice Coding Problems

Split a Circular Linked List - Problem

Split a Circular Linked List

Imagine you have a circular linked list where the last node points back to the first node, forming an endless loop. Your task is to split this circular structure into two separate circular linked lists.

The first circular list should contain the first half of the nodes (exactly ceil(n/2) nodes), and the second circular list should contain the remaining nodes. Both resulting lists must maintain their circular property and preserve the original order of nodes.

Input: Head of a circular linked list with positive integers
Output: Array of two circular linked lists representing the split halves

Example: If you have a circular list [1→2→3→4→1], you should return [[1→2→1], [3→4→3]]

Input & Output

example_1.py — Basic Even Length List

$ Input: Circular list: [1,2,3,4] → 1 (4 nodes)

› Output: [[1,2], [3,4]] where both are circular

💡 Note: With 4 nodes, first half gets ceil(4/2) = 2 nodes [1,2], second half gets remaining 2 nodes [3,4]. Both maintain circular structure.

example_2.py — Odd Length List

$ Input: Circular list: [1,2,3,4,5] → 1 (5 nodes)

› Output: [[1,2,3], [4,5]] where both are circular

💡 Note: With 5 nodes, first half gets ceil(5/2) = 3 nodes [1,2,3], second half gets remaining 2 nodes [4,5]. The extra node goes to the first half.

example_3.py — Single Node Edge Case

$ Input: Circular list: [1] → 1 (1 node)

› Output: [[1], null]

💡 Note: Single node forms the first circular list, second list is null since there are no remaining nodes.

Constraints

The number of nodes in the list is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁶
The given list is guaranteed to be circular
You must maintain the original order of nodes in both resulting lists

Visualization

Tap to expand

Understanding the Visualization

Identify the Circle

Start with a circular linked list where the last node points back to the first

Find the Middle

Use fast/slow pointers to locate the exact split point efficiently

Break and Reconnect

Carefully break the circle at the middle and form two new circular lists

Verify Circles

Ensure both resulting lists maintain their circular property

Key Takeaway

🎯 Key Insight: The fast and slow pointer technique eliminates the need to count nodes first, finding the optimal split point in a single pass through the circular list.

Asked in

⊞ Microsoft 35 a Amazon 28 G Google 22 f Meta 18

The optimal approach uses the fast and slow pointer technique (tortoise and hare) to find the middle of the circular linked list in a single traversal. When the fast pointer completes a full cycle, the slow pointer will be positioned exactly at the end of the first half. We then split the list at this point and reconnect the pointers to form two separate circular lists, ensuring the first list contains ceil(n/2) nodes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Traversals)	O(n)	O(1)	Count nodes first, then traverse again to split at the calculated position
Two Pointers (Fast & Slow)	O(n)	O(1)	Use fast and slow pointers to find the middle in one traversal

Brute Force (Multiple Traversals) — Algorithm Steps

Traverse the circular list once to count total nodes
Calculate split position: ceil(n/2)
Traverse again to reach the split position
Break the circular connection and create two separate circular lists
Ensure both new lists have proper circular connections

Visualization

Tap to expand

Step-by-Step Walkthrough

First Traversal - Count Nodes

Traverse the entire circular list to count total nodes

Calculate Split Position

Determine where to split: ceil(n/2)

Second Traversal - Find Split Point

Traverse again to reach the calculated split position

Split and Reconnect

Break connections and form two separate circular lists

Code -

solution.c — C

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

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

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

struct ListNode** splitCircularList(struct ListNode* head) {
    struct ListNode** result = (struct ListNode**)malloc(2 * sizeof(struct ListNode*));
    
    if (!head || head->next == head) {
        result[0] = head;
        result[1] = NULL;
        return result;
    }
    
    // Count total nodes
    int count = 0;
    struct ListNode* current = head;
    do {
        count++;
        current = current->next;
    } while (current != head);
    
    // Calculate split position
    int firstHalfSize = (count + 1) / 2;
    
    // Find the split point
    current = head;
    for (int i = 0; i < firstHalfSize - 1; i++) {
        current = current->next;
    }
    
    // Split the list
    struct ListNode* secondHead = current->next;
    current->next = head; // Complete first circle
    
    // Find end of second list and complete second circle
    if (secondHead && secondHead != head) {
        struct ListNode* temp = secondHead;
        while (temp->next != head) {
            temp = temp->next;
        }
        temp->next = secondHead;
    }
    
    result[0] = head;
    result[1] = (secondHead == head) ? NULL : secondHead;
    return result;
}

int main() {
    // Example usage
    struct ListNode* nodes[4];
    for (int i = 0; i < 4; i++) {
        nodes[i] = createNode(i + 1);
    }
    for (int i = 0; i < 4; i++) {
        nodes[i]->next = nodes[(i + 1) % 4];
    }
    
    struct ListNode** result = splitCircularList(nodes[0]);
    if (result[0]) printf("First list head: %d\n", result[0]->val);
    if (result[1]) printf("Second list head: %d\n", result[1]->val);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the list twice: once to count (O(n)) and once to split (O(n/2)), resulting in O(n) total

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointer variables, no additional data structures needed

✓ Linear Space

31.5K Views

Medium Frequency

~25 min Avg. Time

1.3K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler