725. 分隔链表
给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。
每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。
这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。
返回一个符合上述规则的链表的列表。
举例： 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]
示例 1：
输入:
root = [1, 2, 3], k = 5
输出: [[1],[2],[3],[],[]]
解释:
输入输出各部分都应该是链表，而不是数组。
例如, 输入的结点 root 的 val= 1, root.next.val = 2,
oot.next.next.val = 3, 且 root.next.next.next = null。
第一个输出 output[0] 是 output[0].val = 1, output[0].next = null。
最后一个元素 output[4] 为 null, 它代表了最后一个部分为空链表。
class Solution:
def splitListToParts(self, root: ListNode, k: int):
total_len = 0
cur = root
while cur:
total_len += 1
cur = cur.next
length = total_len // k # 每段的基础长度
m = total_len % k # 前 l 段需要在基础长度上+1
res = []
cur = root
for i in range(k):
res.append(cur)
size = length + (1 if m > 0 else 0) # 算出每段的长度
if cur: # 这里判断cur是否存在，防止cur.next不存在报错
for j in range(size-1):
cur = cur.next
m -= 1
tmp = cur.next # 把后面一段截掉，后面一段需在后面继续划分
cur.next = None
cur = tmp
return res
View Code
1019. 链表中的下一个更大节点
给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, ... 。
每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且 node_j.val > node_i.val，
而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。
返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。
注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。
示例 1：
输入：[2,1,5]
输出：[5,5,0]
示例 2：
输入：[2,7,4,3,5]
输出：[7,0,5,5,0]
class Solution:
def nextLargerNodes(self, head: ListNode) -> List[int]:
vals, stack = [], [0]
while head:
vals.append(head.val)
head = head.next
for i in range(len(vals) - 1, -1, -1):
while stack[-1] and vals[i] >= stack[-1]:
stack.pop()
stack.append(vals[i])
vals[i] = stack[-2]
return vals
View Code
1367. 二叉树中的列表
给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表。
如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。
一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。
class Solution:
def dfs(self, head: ListNode, rt: TreeNode) -> bool:
if not head:
return True
if not rt:
return False
if rt.val != head.val:
return False
return self.dfs(head.next, rt.left) or self.dfs(head.next, rt.right)
def isSubPath(self, head: ListNode, root: TreeNode) -> bool:
if not root:
return False
return self.dfs(head, root) or self.isSubPath(head, root.left) or self.isSubPath(head, root.right)
链表求和
给定两个用链表表示的整数，每个节点包含一个数位。
这些数位是反向存放的，也就是个位排在链表首部。
编写函数对这两个整数求和，并用链表形式返回结果。
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
return self.addLists(l1, l2, 0)
def addLists(self, l1, l2, carry):
if not l1 and not l2 and carry == 0:
return None
value = carry
if l1:
value += l1.val
if l2:
value += l2.val
result = ListNode(value % 10) # 数字的第二个数位
if l1 or l2: # 递归
more = self.addLists(l1.next if l1 else None, l2.next if l2 else None, 1 if value >= 10 else 0)
result.next = more
return result