leetcode 86. 分隔链表

本文介绍了一种将链表分隔为k个连续部分的算法,确保各部分长度尽可能相等,任意两部分长度差距不超过1。通过实例展示了如何根据链表长度和k值计算各部分元素数量,实现链表的有效分割。

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

  1. 题目链接 https://leetcode-cn.com/problems/partition-list/

  2. 题目描述

    1. 给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。

      每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1,也就是说可能有些部分为 null。

      这k个部分应该按照在链表中出现的顺序进行输出,并且排在前面的部分的长度应该大于或等于后面的长度。

      返回一个符合上述规则的链表的列表。

      举例: 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]

    2. 输入: 
      root = [1, 2, 3], k = 5
      输出: [[1],[2],[3],[],[]]
    3. 输入: 
      root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
      输出: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
  3. 解题思路

    1. 求得链表的长度 n
    2. 取 n / k, n % k
    3. 分割k个链表,每个链表 n / k个元素,其中前 n%k个链表多加一项
    4. 如果结果不足k个,那么在结尾处补充空数组
  4. 代码

    1. python
      class Solution:
          def splitListToParts(self, root: ListNode, k: int) -> list:
              len = 0
              tmp = root
              while tmp:
                  len, tmp = len+1, tmp.next
      
              mod, rem = len//k, len%k
              res = []
              while root and k:
                  res.append(root)
                  tmp, n = res[-1], mod-1 + (1 if rem > 0 and mod else 0)
                  while n > 0:
                      tmp, n = tmp.next, n-1
                  root, tmp.next = tmp.next, None
                  k -= 1
                  rem -= 1
      
              res += [[] for _ in range(k)]
              return res

       

### C++ 实现分隔链表算法 以下是基于 LeetCode 题目 #725 的 C++ 解决方案,该方法能够将一个链表分割成 `k` 个连续的部分。每部分的长度应尽可能相等,并满足任意两部分之间的长度差不超过 1。 #### 算法思路 为了实现这一目标,可以先计算整个链表的总长度 `n`,然后通过整除和取模操作分别得到每一部分的基础长度以及剩余节点的数量。具体来说: - 基础长度为 `len = n / k`; - 剩余节点数量为 `remainder = n % k`。 对于前 `remainder` 个子链表,它们会额外分配一个节点;其余的则只保留基础长度。 下面是完整的代码实现: ```cpp #include <vector> using namespace std; struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; class Solution { public: vector<ListNode*> splitListToParts(ListNode* root, int k) { // 计算链表长度 int n = 0; ListNode* current = root; while (current != nullptr) { n++; current = current->next; } // 每部分的基础长度和多余节点数 int len = n / k, remainder = n % k; // 初始化结果向量 vector<ListNode*> result(k, nullptr); current = root; ListNode* prev = nullptr; for (int i = 0; i < k && current != nullptr; ++i) { result[i] = current; // 当前部分的起始节点 // 移动到当前部分的最后一个节点 int partSize = len + ((i < remainder) ? 1 : 0); for (int j = 0; j < partSize - 1; ++j) { current = current->next; } // 断开当前部分与下一部分的连接 prev = current; current = current->next; prev->next = nullptr; } return result; } }; ``` 此代码实现了以下功能: - 使用循环遍历链表以获取其总长度[^1]。 - 将链表分为多个部分并调整各部分的长度[^3]。 - 返回由这些部分组成的向量作为最终结果[^2]。 #### 复杂度分析 时间复杂度主要取决于两次线性扫描过程:第一次用于统计链表中的节点总数,第二次则是实际拆分的过程。因此总体的时间复杂度为 O(n),其中 n 是输入链表的长度。空间复杂度方面,除了存储输出外并未引入其他辅助数据结构,故可视为常数级即 O(1)[^4]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值