if head is None or head.next is None or head.next.next is None: return head flag = True even_head = head.next odds = head evens = even_head ptr = even_head.next while ptr is not None: if flag: odds.next = ptr odds = ptr else: evens.next = ptr evens = ptr ptr = ptr.next flag = not flag odds.next = even_head evens.next = None return head test( odd_even_list, [ (new_list(1, 2, 3, 4, 5), new_list(1, 3, 5, 2, 4)), (new_list(2, 1, 3, 5, 6, 4, 7), new_list(2, 3, 6, 7, 1, 5, 4)), ], )
nonlocal head if start > end: return None middle = (start + end) // 2 left = build_bst(start, middle - 1) root = TreeNode(head.val) root.left = left head = head.next root.right = build_bst(middle + 1, end) return root return build_bst(0, length - 1) def list_length(list_head: Optional[ListNode]) -> int: node, length = list_head, 0 while node: length += 1 node = node.next return length test( sorted_list_to_bst, [ (new_list(-10, 3, 0, 5, 9), None), (new_list(), None), ], equals_func=lambda root, _: is_valid_avl(root), )
return None while p1 is not p2: p1, p2 = p1.next, p2.next return p1 if __name__ == "__main__": def _make_test_case(nums, cycle_entry_index): head = ListNode(nums[0]) node, entry_node = head, head for i, num in enumerate(nums[1:]): node.next = ListNode(num) node = node.next if i + 1 <= cycle_entry_index: entry_node = entry_node.next node.next = entry_node return head, entry_node tests = [ _make_test_case([3, 2, 0, -4], 1), _make_test_case([1, 2], 0), (new_list(1), None), ] for head, node in tests: head = detect_cycle(head) if head and node: assert head.val == node.val else: assert head is None and node is None
from leetcode import ListNode, new_list, new_cycle_list def has_cycle(head: ListNode) -> bool: if not head: return False slow, fast = head, head.next while slow and fast: if slow is fast: return True slow, fast = slow.next, fast.next if fast: fast = fast.next return False if __name__ == "__main__": assert has_cycle(new_cycle_list([3, 2, 0, -4], 1)) is True assert has_cycle(new_cycle_list([1, 2], 0)) is True assert has_cycle(new_list(1)) is False assert has_cycle(new_list(1, 2)) is False
length = list_length(head) if length <= 0: return None def build_bst(start: int, end: int) -> Optional[TreeNode]: nonlocal head if start > end: return None middle = (start + end) // 2 left = build_bst(start, middle - 1) root = TreeNode(head.val) root.left = left head = head.next root.right = build_bst(middle + 1, end) return root return build_bst(0, length - 1) def list_length(list_head: Optional[ListNode]) -> int: node, length = list_head, 0 while node: length += 1 node = node.next return length if __name__ == "__main__": assert is_valid_avl(sorted_list_to_bst(new_list(-10, 3, 0, 5, 9))) assert is_valid_avl(sorted_list_to_bst(new_list()))
while tops: tail.next = tops[0].node tail = tail.next if tail.next is not None: heapreplace(tops, CmpListNode(tail.next)) else: heappop(tops) return head.next CmpListNode = namedtuple("CmpListNode", ["node"]) def cmp_list_node_lt(lhs, rhs): return lhs.node.val < rhs.node.val CmpListNode.__slots__ = () CmpListNode.__lt__ = cmp_list_node_lt test( merge_k_lists, [( [new_list(1, 4, 5), new_list(1, 3, 4), new_list(2, 6)], new_list(1, 1, 2, 3, 4, 4, 5, 6), )], )
from leetcode import ListNode, new_list def odd_even_list(head: Optional[ListNode]) -> Optional[ListNode]: if head is None or head.next is None or head.next.next is None: return head flag = True even_head = head.next odds = head evens = even_head ptr = even_head.next while ptr is not None: if flag: odds.next = ptr odds = ptr else: evens.next = ptr evens = ptr ptr = ptr.next flag = not flag odds.next = even_head evens.next = None return head if __name__ == "__main__": assert odd_even_list(new_list(1, 2, 3, 4, 5)) == new_list(1, 3, 5, 2, 4) assert odd_even_list(new_list(2, 1, 3, 5, 6, 4, 7)) == new_list(2, 3, 6, 7, 1, 5, 4)
pre, end = dummy, dummy while end.next: for _ in range(k): if end: end = end.next else: break if not end: return dummy.next start, nxt, end.next = pre.next, end.next, None pre.next = reverse_list(start) start.next, pre, end = nxt, start, start return dummy.next def reverse_list(head: ListNode) -> ListNode: prev, curr = None, head while curr: next_ = curr.next curr.next = prev prev = curr curr = next_ return prev if __name__ == "__main__": assert reverse_group(new_list(1, 2, 3, 4, 5), 2) == new_list(2, 1, 4, 3, 5) assert reverse_group(new_list(1, 2, 3, 4, 5), 3) == new_list(3, 2, 1, 4, 5)
end = end.next else: break if not end: return dummy.next start, nxt, end.next = pre.next, end.next, None pre.next = reverse_list(start) start.next, pre, end = nxt, start, start return dummy.next def reverse_list(head: ListNode) -> ListNode: prev, curr = None, head while curr: next_ = curr.next curr.next = prev prev = curr curr = next_ return prev test( reverse_group, [ (new_list(1, 2, 3, 4, 5), 2, new_list(2, 1, 4, 3, 5)), (new_list(1, 2, 3, 4, 5), 3, new_list(3, 2, 1, 4, 5)), ], )
from leetcode import ListNode, test, new_list, new_cycle_list def has_cycle(head: ListNode) -> bool: if not head: return False slow, fast = head, head.next while slow and fast: if slow is fast: return True slow, fast = slow.next, fast.next if fast: fast = fast.next return False test( has_cycle, [ (new_cycle_list([3, 2, 0, -4], 1), True), (new_cycle_list([1, 2], 0), True), (new_list(1), False), (new_list(1, 2), False), ], )
heappush(tops, CmpListNode(node)) head = ListNode(-1) tail = head while tops: tail.next = tops[0].node tail = tail.next if tail.next is not None: heapreplace(tops, CmpListNode(tail.next)) else: heappop(tops) return head.next CmpListNode = namedtuple("CmpListNode", ["node"]) def cmp_list_node_lt(lhs, rhs): return lhs.node.val < rhs.node.val CmpListNode.__slots__ = () CmpListNode.__lt__ = cmp_list_node_lt if __name__ == "__main__": assert merge_k_lists( [new_list(1, 4, 5), new_list(1, 3, 4), new_list(2, 6)]) == new_list(1, 1, 2, 3, 4, 4, 5, 6)
from leetcode import ListNode, new_list def remove_duplicate_nodes(head: ListNode) -> ListNode: values = set() prev, node = None, head while node: if node.val not in values: prev = node values.add(node.val) else: prev.next = node.next node = node.next return head if __name__ == "__main__": assert remove_duplicate_nodes(new_list(1, 2, 3, 3, 2, 1)) == new_list(1, 2, 3) assert remove_duplicate_nodes(new_list(1, 1, 1, 2)) == new_list(1, 2)