Split Linked List in Parts - Practice Coding Problems

Split Linked List in Parts - Problem

Linked List Medium

Imagine you have a long chain of connected elements, and you need to divide it fairly into k separate groups. This is exactly what we're doing with a linked list!

Given the head of a singly linked list and an integer k, your task is to split the linked list into k consecutive parts. The challenge is to make the split as fair as possible:

Equal distribution: No two parts should differ in size by more than one node
Front-heavy: If sizes can't be perfectly equal, earlier parts should be larger
Order preserved: Maintain the original order of nodes
Null parts allowed: Some parts can be empty if k is larger than the list length

Return an array of k ListNode heads, where each head points to the start of one part.

Example: A list of 10 nodes split into 3 parts would create parts of sizes [4, 3, 3] - the first part gets the extra node.

Input & Output

Basic Split Example

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

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

💡 Note: The list has 3 nodes but we need 5 parts. Each node becomes its own part, and the remaining 2 parts are null/empty.

Uneven Distribution

$ Input: head = [1,2,3,4,5,6,7,8,9,10], k = 3

› Output: [[1,2,3,4],[5,6,7],[8,9,10]]

💡 Note: 10 nodes split into 3 parts: 10÷3 = 3 remainder 1. So sizes are [4,3,3]. The first part gets the extra node.

Empty List Edge Case

$ Input: head = [], k = 3

› Output: [[],[],[]]

💡 Note: When the input list is empty, all k parts will be null/empty arrays.

Visualization

Tap to expand

Understanding the Visualization

Count the Pizzas

First, count all pizzas on the conveyor belt to know what you're working with

Calculate Distribution

Determine how many pizzas each truck gets: base amount plus extras for first trucks

Load the Trucks

Move along the belt once, cutting it at precise points to fill each truck

Handle Extras

If there are more trucks than pizzas, some trucks stay empty

Key Takeaway

🎯 Key Insight: By calculating the mathematical distribution first (length÷k and length%k), we can make precise cuts in a single pass, avoiding the inefficiency of multiple traversals.

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We traverse n nodes to count, then for each of k parts, we may traverse up to n nodes again to reach the starting position

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 1000]
1 ≤ k ≤ 50
0 ≤ Node.val ≤ 1000
Follow-up: Can you solve this without modifying the original list structure?

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 22

The optimal approach uses two passes: first count all nodes to determine the perfect size distribution, then make a single traversal to split the list at calculated positions. Key insight: use length ÷ k for base size and length % k to determine which parts get an extra node. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple List Traversals)	O(n*k)	O(1)	Count nodes, then traverse k times to build each part separately
Two-Pass Optimal Solution	O(n)	O(1)	Count nodes first, then make one efficient pass to split the list

Brute Force (Multiple List Traversals) — Algorithm Steps

Traverse the entire list to count total nodes
Calculate base size (length/k) and extra nodes (length%k)
For each of k parts, traverse from head to find the starting position
Extract the required number of nodes for current part
Repeat traversal for next part

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Phase

Traverse entire list to count nodes

Calculate Sizes

Determine how many nodes each part should have

Extract Parts

For each part, traverse from head to extract nodes

Code -

solution.c — C

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

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode** splitListToParts(struct ListNode* head, int k, int* returnSize) {
    *returnSize = k;
    
    // Count total nodes
    int length = 0;
    struct ListNode* current = head;
    while (current) {
        length++;
        current = current->next;
    }
    
    // Calculate part sizes
    int baseSize = length / k;
    int extraNodes = length % k;
    
    struct ListNode** result = (struct ListNode**)malloc(k * sizeof(struct ListNode*));
    current = head;
    
    for (int i = 0; i < k; i++) {
        if (!current) {
            result[i] = NULL;
            continue;
        }
        
        struct ListNode* partHead = current;
        int partSize = baseSize + (i < extraNodes ? 1 : 0);
        
        // Move to end of current part
        for (int j = 0; j < partSize - 1; j++) {
            if (current) {
                current = current->next;
            }
        }
        
        // Break the connection
        if (current) {
            struct ListNode* nextPart = current->next;
            current->next = NULL;
            current = nextPart;
        }
        
        result[i] = partHead;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We traverse n nodes to count, then for each of k parts, we may traverse up to n nodes again to reach the starting position

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

The number of nodes in the list is in the range [0, 1000]
1 ≤ k ≤ 50
0 ≤ Node.val ≤ 1000
Follow-up: Can you solve this without modifying the original list structure?

73.9K Views

Medium Frequency

~15 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 List Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler