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)
