链表题目：将链表分隔成 K 个部分

题目

标题和出处

标题：将链表分隔成 K 个部分

出处：725. 将链表分隔成 K 个部分

难度

5 级

题目描述

要求

给你单链表的头结点 $\text{head}$ 和一个整数 $\text{k}$，将链表分隔成 $\text{k}$ 个连续的部分。

每部分的长度应尽可能相等：任意两部分的长度相差不超过 $\text{1}$。可能有些部分为 $\text{null}$。

每个部分的顺序应和输入链表的顺序相同，并且前面部分的长度应总是大于或等于后面部分的长度。

返回分隔成的 $\text{k}$ 个部分的数组。

示例

示例 1：

输入：$\text{head = [1,2,3], k = 5}$
输出：$\text{[[1],[2],[3],[],[]]}$
解释：
第一个元素 $\text{output[0]}$ 满足 $\text{output[0].val = 1}$，$\text{output[0].next = null}$。
最后一个元素 $\text{output[4]}$ 是 $\text{null}$，空链表的字符串表示是 $\text{[]}$。

示例 2：

输入：$\text{head = [1,2,3,4,5,6,7,8,9,10], k = 3}$
输出：$\text{[[1,2,3,4],[5,6,7],[8,9,10]]}$
解释：
输入链表被分隔成连续的部分，每部分的长度相差不超过 $\text{1}$，前面部分的长度大于或等于后面部分的长度。

数据范围

• 链表中结点的数目在范围 $\text{[0, 1000]}$ 内
• $\text{0}\le \text{Node.val}\le \text{1000}$
• $\text{1}\le \text{k}\le \text{50}$

解法

思路和算法

由于每个部分的长度和原始链表的长度有关，因此需要遍历原始链表得到原始链表的长度，即结点数。

记原始链表的长度为 $\text{length}$，令 $\text{quotient}=\lfloor \frac{\text{length}}{k}\rfloor$，$\text{remainder}=\text{length}\mathrm{m}\mathrm{o}\mathrm{d}k$，则分隔成的 $k$ 个部分中，前面 $\text{remainder}$ 个部分的长度为 $\text{quotient}+1$，其余 $k-\text{remainder}$ 个部分的长度为 $\text{quotient}$。

将原始链表分隔成 $k$ 个部分的做法是，找到每个部分的头结点和尾结点，将每个部分的头结点存入结果链表，并将每个部分的尾结点和后一个部分的头结点的连接关系断开。

用 $\text{curr}$ 表示当前遍历到的结点，初始时 $\text{curr}=\text{head}$。对于每个部分进行如下操作：

1. 当前部分的头结点即为 $\text{curr}$，将 $\text{curr}$ 存入结果数组的对应下标处；

2. 计算得到该部分的长度 $\text{partLength}$；

3. 将 $\text{curr}$ 向后移动 $\text{partLength}-1$ 次，此时 $\text{curr}$ 位于该部分的尾结点；

4. 记录 $\text{next}=\text{curr}.\text{next}$，则 $\text{next}$ 为后一个部分的头结点；

5. 令 $\text{curr}.\text{next}:=\text{null}$，将当前部分的尾结点和后一个部分的头结点的连接关系断开；

6. 令 $\text{curr}:=\text{next}$，此时 $\text{curr}$ 位于后一个部分的头结点，重复上述操作。

分隔链表的结束条件是 $k$ 个部分全部分隔完毕，或者链表遍历结束。当链表长度大于或等于 $k$ 时，每个部分至少有 $1$ 个结点，因此需要将 $k$ 个部分全部分隔完毕。当链表长度小于 $k$ 时，分隔成的 $k$ 个部分中，前面 $\text{length}$ 个部分的长度都是 $1$，其余的 $k-\text{length}$ 个部分都是空链表，因此当链表遍历结束时即完成分隔。

代码

class Solution {
    public ListNode[] splitListToParts(ListNode head, int k) {
        int length = 0;
        ListNode curr = head;
        while (curr != null) {
            length++;
            curr = curr.next;
        }
        int quotient = length / k, remainder = length % k;
        ListNode[] parts = new ListNode[k];
        curr = head;
        for (int i = 0; i < k && curr != null; i++) {
            parts[i] = curr;
            int partLength = quotient + (i < remainder ? 1 : 0);
            for (int j = 1; j < partLength; j++) {
                curr = curr.next;
            }
            ListNode next = curr.next;
            curr.next = null;
            curr = next;
        }
        return parts;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要遍历链表两次，第一次遍历得到链表的长度，第二次遍历分隔链表，分隔链表时对于每个结点的操作的时间都是 $O(1)$。

• 空间复杂度：$O(1)$。除了返回值以外，使用的空间复杂度是常数。