[Leetcode] 725. Split Linked List in Parts 解题报告-优快云博客

本文介绍了一种算法，用于将一个单链表均匀分割成k个连续的部分，确保各部分尽可能等长，相差不超过1个节点，并按出现顺序返回这些部分。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts".

The length of each part should be as equal as possible: no two parts should have a size differing by more than 1. This may lead to some parts being null.

The parts should be in order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal parts occurring later.

Return a List of ListNode's representing the linked list parts that are formed.

Examples 1->2->3->4, k = 5 // 5 equal parts [ [1], [2], [3], [4], null ]

Example 1:

Input:
root = [1, 2, 3], k = 5
Output: [[1],[2],[3],[],[]]
Explanation:
The input and each element of the output are ListNodes, not arrays.
For example, the input root has root.val = 1, root.next.val = 2, \root.next.next.val = 3, and root.next.next.next = null.
The first element output[0] has output[0].val = 1, output[0].next = null.
The last element output[4] is null, but it's string representation as a ListNode is [].

Example 2:

Input: 
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Explanation:
The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.

Note:

The length of root will be in the range [0, 1000].
Each value of a node in the input will be an integer in the range [0, 999].

k will be an integer in the range

[1,
 50]

思路：

我们采用递归来求解：首先计算出链表的长度length，这样根据length和k的关系，就可以知道第一段链表需要多长了。所以我们首先分割出第一段，然后再递归地分割后续的链表。需要注意的是在某些情况下需要拆分的长度可能大于链表的长度，这样就会导致最终拆分结果的个数不足k，所以在返回之前我们还需要用空指针来填充。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        int length = 0;
        ListNode *node = root;
        while (node != NULL) {
            ++length;
            node = node->next;
        }
        vector<ListNode*> ret;
        splitListToParts(root, ret, k, length);
        while (ret.size() < k) {
            ret.push_back(NULL);
        }
        return ret;
    }
private:
    void splitListToParts(ListNode *root, vector<ListNode*> &ret, int k, int length) {
        if (root == NULL) {
            return;
        }
        if (k == 1) {
            ret.push_back(root);
            return;
        }
        int size = length / k, remain = length % k;
        if (remain != 0) {
            ++size;
        }
        ListNode *node = root;
        for (int i = 1; i < size; ++i) {
            node = node->next;
        }
        ListNode *next_root = node->next;
        node->next = NULL;
        ret.push_back(root);
        splitListToParts(next_root, ret, k - 1, length - size);
    }
};