Split a Circular Linked List

Split a Circular Linked List - Problem

Given a circular linked list list of positive integers, your task is to split it into 2 circular linked lists so that the first one contains the first half of the nodes in list (exactly ceil(list.length / 2) nodes) in the same order they appeared in list, and the second one contains the rest of the nodes in list in the same order they appeared in list.

Return an array answer of length 2 in which the first element is a circular linked list representing the first half and the second element is a circular linked list representing the second half.

A circular linked list is a normal linked list with the only difference being that the last node's next node, is the first node.

Input & Output

Example 1 — Odd Number of Nodes

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

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

💡 Note: The list has 5 nodes. First half gets ceil(5/2) = 3 nodes: [1,2,3]. Second half gets remaining 2 nodes: [4,5]. Both halves are made circular.

Example 2 — Even Number of Nodes

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

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

💡 Note: The list has 4 nodes. First half gets ceil(4/2) = 2 nodes: [1,2]. Second half gets remaining 2 nodes: [3,4]. Both are circular.

Example 3 — Single Node

$ Input: head = [1]

› Output: [[1],[]]

💡 Note: Only one node, so first half contains [1] and second half is empty. The single node points to itself.

Constraints

1 ≤ list.length ≤ 10⁵
1 ≤ list[i] ≤ 10⁶
The input list is a circular linked list

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 f Facebook 8

Split a circular linked list into two halves efficiently. The key insight is using fast-slow pointers to find the middle in one pass. Best approach is two-pointer technique with Time: O(n), Space: O(1).

Common Approaches

✓ Fast-Slow Pointer Optimized

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

Use two pointers moving at different speeds to find the middle of the circular list in a single traversal. Fast pointer moves 2 steps while slow moves 1 step.

Two Pass Approach

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

First pass counts all nodes in the circular list. Second pass traverses to the split point and breaks the list into two circular lists.

Fast-Slow Pointer Optimized — Algorithm Steps

Step 1: Initialize fast and slow pointers at head
Step 2: Move fast 2 steps, slow 1 step until fast completes the circle
Step 3: Slow pointer will be at the split position
Step 4: Break connections and make both parts circular

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Both fast and slow pointers start at head

Move Pointers

Fast moves 2 steps, slow moves 1 step each iteration

Split When Fast Completes Circle

When fast returns to start, slow is at the split position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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** solution(struct ListNode* head) {
    struct ListNode** result = (struct ListNode**)malloc(2 * sizeof(struct ListNode*));
    
    if (!head) {
        result[0] = NULL;
        result[1] = NULL;
        return result;
    }
    
    if (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 first half size: ceil(count/2)
    int firstHalfSize = (count + 1) / 2;
    
    // Find the end of first half
    current = head;
    for (int i = 0; i < firstHalfSize - 1; i++) {
        current = current->next;
    }
    
    // Split the list
    struct ListNode* secondHead = current->next;
    current->next = head; // Make first half circular
    
    // Make second half circular if it exists
    if (secondHead != head) {
        // Find the last node of second half
        struct ListNode* last = secondHead;
        while (last->next != head) {
            last = last->next;
        }
        last->next = secondHead;
        result[0] = head;
        result[1] = secondHead;
    } else {
        result[0] = head;
        result[1] = NULL;
    }
    
    return result;
}

struct ListNode* buildList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = createNode(arr[0]);
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = createNode(arr[i]);
        current = current->next;
    }
    current->next = head;
    return head;
}

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input manually
    int arr[1000];
    int size = 0;
    char* p = line;
    
    // Skip to first digit
    while (*p && (*p < '0' || *p > '9') && *p != '-') p++;
    
    while (*p && *p != ']') {
        if (*p >= '0' && *p <= '9') {
            arr[size] = (int)strtol(p, &p, 10);
            size++;
        } else {
            p++;
        }
    }
    
    struct ListNode* head = buildList(arr, size);
    struct ListNode** result = solution(head);
    
    printf("[");
    printList(result[0]);
    printf(",");
    printList(result[1]);
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the circular list with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only uses two pointer variables, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

845 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

Fast-Slow Pointer Optimized — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler