def test_solutions():
inter = ListNode.initList([1, 8, 4, 5])
headA = ListNode.initList([4])
headB = ListNode.initList([5, 0])
headA.next = inter
headB.next = inter
res = Solution().getIntersectionNode(headA, headB)
assert res == inter
def test_solutions():
l1 = ListNode.initList([4, 1, 8, 4, 5])
l2 = ListNode.initList([5, 0])
l2.next.next = l1.next
res = Solution().getIntersectionNode(l1, l2)
res1 = Solution1().getIntersectionNode(l1, l2)
assert res == l1.next
assert res1 == l1.next
def test_solutions():
head = ListNode.initList([3, 2, 0, -4])
cur = head
while cur.val != 0:
cur = cur.next
cur.next = head
res = Solution().detectCycle(head)
assert res.val == 3
def test_solution():
l = ListNode.initList([3, 2, 0, -4])
assert not Solution().hasCycle(l)
cur = l
while cur.next:
cur = cur.next
cur.next = l
assert Solution().hasCycle(l)
def test_solution():
cycle = ListNode.initList([2, 0, -4])
cur = cycle
while cur.next:
cur = cur.next
cur.next = cycle
head = ListNode(3)
head.next = cycle
res = Solution().detectCycle(head)
assert res and res.val == 2
if not head:
return True
if not root:
return False
return dfs(head, root) or self.isSubPath(
head, root.left) or self.isSubPath(head, root.right)
# leetcode submit region end(Prohibit modification and deletion)
@pytest.mark.parametrize("kwargs,expected", [
(dict(
head=ListNode.initList([4, 2, 8]),
root=TreeNode(1,
left=TreeNode(4, right=TreeNode(2, left=TreeNode(1))),
right=TreeNode(4,
left=TreeNode(2,
left=TreeNode(6),
right=TreeNode(
8, TreeNode(1),
TreeNode(3)))))), True),
pytest.param(
dict(head=ListNode.initList([1, 4, 2, 6]),
root=TreeNode(1,
left=TreeNode(4,
right=TreeNode(2, left=TreeNode(1))),
right=TreeNode(4,
left=TreeNode(2,
class Solution1:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(-1)
dummy.next = head
first = head
second = dummy
for i in range(n):
first = first.next
while first:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
@pytest.mark.parametrize("kw,expected", [
[
dict(head=ListNode.initList(list(range(1, 6))), n=2),
ListNode.init_list_from_str("1->2->3->5")
],
])
@pytest.mark.parametrize("SolutionCLS", [Solution, Solution1])
def test_solutions(kw, expected, SolutionCLS):
assert repr(
SolutionCLS().removeNthFromEnd(**copy.deepcopy(kw))) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
class Solution1:
def deleteDuplicates(self, head: ListNode) -> ListNode:
dummy = ListNode(-1)
dummy.next = head
cur = dummy
while cur.next and cur.next.next:
if cur.next.val == cur.next.next.val:
x = cur.next.val
while cur.next and cur.next.val == x:
cur.next = cur.next.next
else:
cur = cur.next
return dummy.next
@pytest.mark.parametrize("kw,expected", [
[dict(head=ListNode.initList([1, 2, 3, 3, 4, 4, 5])), ListNode.initList([1, 2, 5])],
[dict(head=ListNode.initList([1, 1, 1, 2, 3])), ListNode.initList([2, 3])],
[dict(head=ListNode.initList([3, 1, 1, 1, 2, 2, 2])), ListNode.initList([3])],
])
@pytest.mark.parametrize("SolutionCLS", [Solution, Solution1])
def test_solutions(kw, expected, SolutionCLS):
assert repr(SolutionCLS().deleteDuplicates(**copy.deepcopy(kw))) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
cur = cur.next
res.append(head.next)
return res
# leetcode submit region end(Prohibit modification and deletion)
@pytest.mark.parametrize("kwargs,expected", [
[
dict(tree=TreeNode(1,
left=TreeNode(2, TreeNode(4, left=TreeNode(8)),
TreeNode(5)),
right=TreeNode(3, right=TreeNode(7)))),
[
ListNode(1),
ListNode.initList([2, 3]),
ListNode.initList([4, 5, 7]),
ListNode.initList([8]),
]
],
])
def test_solutions(kwargs, expected):
res = Solution().listOfDepth(**kwargs)
# print(res)
assert all(repr(x) == repr(y) for x, y in zip(res, expected))
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=tee-sys", __file__])
class Solution:
def oddEvenList(self, head: ListNode) -> ListNode:
"""
TODO
https://leetcode-cn.com/problems/odd-even-linked-list/solution/qi-ou-lian-biao-by-leetcode/
我们用变量 head 和 odd_tail 保存奇链表的头和尾指针。 even_head 和 cur 保存偶链表的头和尾指针
"""
if not (head and head.next):
return head
odd_tail, even, even_head = head, head.next, head.next
while even and even.next:
odd_tail.next = even.next
odd_tail = odd_tail.next
even.next = odd_tail.next
even = even.next
odd_tail.next = even_head
return head
@pytest.mark.parametrize("args,expected", [(
ListNode.initList([1, 2, 3, 4, 5]),
ListNode.initList([1, 3, 5, 2, 4]),
)])
def test_solutions(args, expected):
assert repr(Solution().oddEvenList(args)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
if not head:
return head
slow = head
fast = head.next
while fast:
if fast.val != slow.val:
slow.next = fast
slow = slow.next
fast = fast.next
slow.next = None
return head
@pytest.mark.parametrize("kw,expected", [
[
dict(head=ListNode.initList([1, 2, 3, 4, 5, 5])),
ListNode.initList([1, 2, 3, 4, 5])
],
[
dict(head=ListNode.initList([1, 1, 1, 2, 3])),
ListNode.initList([1, 2, 3])
],
])
def test_solutions(kw, expected):
assert repr(
Solution().deleteDuplicates(**copy.deepcopy(kw))) == repr(expected)
assert repr(
Solution1().deleteDuplicates(**copy.deepcopy(kw))) == repr(expected)
if __name__ == '__main__':
old_tail.next = head
# find new tail : (n - k % n - 1)th node
# and new head : (n - k % n)th node
new_tail = head
for i in range(n - k % n - 1):
new_tail = new_tail.next
new_head = new_tail.next
# break the ring
new_tail.next = None
return new_head
@pytest.mark.parametrize("args,expected", [
[(ListNode.initList([1, 2, 3, 4, 5]), 2),
ListNode.initList([4, 5, 1, 2, 3])],
[(ListNode.initList([0, 1, 2]), 4),
ListNode.initList([2, 0, 1])],
[(ListNode.initList([1, 2]), 2),
ListNode.initList([1, 2])],
])
def test_solutions(args, expected):
assert repr(Solution().rotateRight(*copy.deepcopy(args))) == repr(expected)
assert repr(Solution1().rotateRight(*args)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
cur_head.next = l1
l1 = l1.next
elif l1.val > l2.val:
cur_head.next = l2
l2 = l2.next
cur_head = cur_head.next
while l1:
cur_head.next = l1
l1 = l1.next
cur_head = cur_head.next
while l2:
cur_head.next = l2
l2 = l2.next
cur_head = cur_head.next
return dummyHead.next
@pytest.mark.parametrize("kw,expected", [
[
dict(l1=ListNode.init_list_from_str("1->2->4"),
l2=ListNode.init_list_from_str("1->3->4")),
ListNode.initList([1, 1, 2, 3, 4, 4])
],
])
def test_solutions(kw, expected):
assert repr(Solution().mergeTwoLists(**kw)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
sorted_l2 = self.sortList(slow)
return self.mergeTwoLists(sorted_l1, sorted_l2)
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
dummy = ListNode(-1)
cur = dummy
while l1 and l2:
if l1.val <= l2.val:
cur.next = l1
cur = cur.next
l1 = l1.next
else:
cur.next, cur, l2 = l2, l2, l2.next
if l1:
cur.next = l1
if l2:
cur.next = l2
return dummy.next
@pytest.mark.parametrize("args,expected", [(
ListNode.initList([4, 2, 1, 3]),
ListNode.initList([1, 2, 3, 4]),
)])
def test_solutions(args, expected):
assert repr(Solution().sortList(args)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
start = end
end = end.next
start.next = list2
while list2.next:
list2 = list2.next
list2.next = end.next
end.next = None
return list1
# leetcode submit region end(Prohibit modification and deletion)
@pytest.mark.parametrize("kw,expected", [
[
dict(list1=ListNode.initList([0, 1, 2, 3, 4, 5]),
a=3,
b=4,
list2=ListNode.initList([1000000, 1000001, 1000002])),
ListNode.initList([0, 1, 2, 1000000, 1000001, 1000002, 5])
],
[
dict(list1=ListNode.initList([0, 1, 2, 3, 4, 5, 6]),
a=2,
b=5,
list2=ListNode.initList(
[1000000, 1000001, 1000002, 1000003, 1000004])),
ListNode.initList(
[0, 1, 1000000, 1000001, 1000002, 1000003, 1000004, 6])
],
])
cur = head
while cur:
dummy.next, cur.next, cur = cur, dummy.next, cur.next
return dummy.next
class Solution1:
def reverseList(self, head: ListNode) -> ListNode:
if not (head and head.next):
return head
p = self.reverseList(head.next)
head.next.next = head
head.next = None
return p
@pytest.mark.parametrize("kw,expected", [
[
dict(head=ListNode.initList([1, 2, 3, 4, 5])),
ListNode.initList([5, 4, 3, 2, 1])
],
])
def test_solutions(kw, expected):
kw1 = copy.deepcopy(kw)
assert repr(Solution().reverseList(**kw)) == repr(expected)
assert repr(Solution1().reverseList(**kw1)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
class Solution:
def numComponents(self, head: ListNode, G: List[int]) -> int:
"""
TODO 题义转换
我们对链表进行一次扫描，一个组件在链表中对应一段极长的连续节点，因此如果当前的节点在列表 G 中，
并且下一个节点不在列表 G 中，我们就找到了一个组件的尾节点，可以将答案加 1
"""
lookup = set(G)
dummy = ListNode(-1)
dummy.next = head
cur = dummy
result = 0
while cur and cur.next:
if cur.val not in lookup and cur.next.val in lookup:
result += 1
cur = cur.next
return result
@pytest.mark.parametrize(
"args,expected", [([ListNode.initList([0, 1, 2, 3]), [0, 1, 3]], 2),
([ListNode.initList([0, 1, 2, 3, 4]), [0, 3, 1, 4]], 2)])
def test_solutions(args, expected):
assert Solution().numComponents(*args) == expected
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
from common_utils import ListNode
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(-1)
dummy.next = head
prev, cur = dummy, head
while cur:
if cur.val == val:
break
prev, cur = cur, cur.next
prev.next = cur.next
return dummy.next
@pytest.mark.parametrize("head,val,expected", [
(ListNode.initList([4, 5, 1, 9]), 5, ListNode.initList([4, 1, 9]))
])
def test_solutions(head, val, expected):
res = Solution().deleteNode(head, val)
while res and expected:
assert res.val == expected.val
res, expected = res.next, expected.next
assert res is None and expected is None
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
carry += l2.val
l2 = l2.next
ans.next = ListNode(carry % 10)
ans = ans.next
carry //= 10
if carry:
ans.next = ListNode(carry)
return dummy.next
# leetcode submit region end(Prohibit modification and deletion)
@pytest.mark.parametrize(
"kwargs,expected",
[
[
dict(l1=ListNode.initList([7, 1, 6]),
l2=ListNode.initList([5, 9, 2])),
ListNode.initList([2, 1, 9])
],
# [dict(l1=ListNode.initList([6, 1, 7]), l2=ListNode.initList([2, 9, 5])), ListNode.initList([9, 1, 2])],
])
def test_solutions(kwargs, expected):
assert repr(Solution().addTwoNumbers(**kwargs)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=tee-sys", __file__])
increase_stack.append((len(result), cur_val))
result.append(0)
return result
class Solution1:
def nextLargerNodes(self, head: ListNode) -> List[int]:
result, stack = [], []
while head:
while stack and stack[-1][1] < head.val:
idx, v = stack.pop()
result[idx] = head.val
stack.append((len(result), head.val))
result.append(0)
head = head.next
# print(stack)
return result
@pytest.mark.parametrize("args,expected", [
(ListNode.initList([2, 1, 5]), [5, 5, 0]),
(ListNode.initList([2, 7, 4, 3, 5]), [7, 0, 5, 5, 0]),
(ListNode.initList([1, 7, 5, 1, 9, 2, 5, 1]), [7, 9, 9, 9, 0, 5, 0, 0]),
])
def test_solutions(args, expected):
assert Solution().nextLargerNodes(args) == expected
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
while cur:
prev = dummy
while prev.next.val < cur.val:
prev = prev.next
if prev == sorted_tail:
cur, sorted_tail = cur.next, cur
else:
cur.next, prev.next, sorted_tail.next = prev.next, cur, cur.next
cur = sorted_tail.next
return dummy.next
@pytest.mark.parametrize("kw,expected", [
[
dict(head=ListNode.init_list_from_str("4->2->1->3")),
ListNode.initList([1, 2, 3, 4])
],
[
dict(head=ListNode.init_list_from_str("-1->5->3->4->0")),
ListNode.initList([-1, 0, 3, 4, 5])
],
])
def test_solutions(kw, expected):
kw1 = copy.deepcopy(kw)
assert repr(Solution().insertionSortList(**kw)) == repr(expected)
assert repr(Solution1().insertionSortList(**kw1)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
def test_solutions():
head = ListNode.initList(list(range(9)))
sol = Solution(head)
assert sol.getRandom()
我们正处于Nk
所以
Nk.next.next=Nk
"""
if not (head and head.next):
return head
p = self.reverseList(head.next)
head.next.next = head
head.next = None
return p
@pytest.mark.parametrize("kw,expected", [
[
dict(head=ListNode.initList([1, 2, 3, 4, 5])),
ListNode.initList([1, 2, 3, 4, 5][::-1])
],
[dict(head=ListNode.initList([1, 2])),
ListNode.initList([2, 1])],
[dict(head=ListNode.initList([1])),
ListNode.initList([1])],
])
@pytest.mark.parametrize("SolutionCLS", [Solution1, Solution2, Solution])
def test_solutions(kw, expected, SolutionCLS):
assert repr(
SolutionCLS().reverseList(**copy.deepcopy(kw))) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
curr = curr.next
n += 1
width, remainder = divmod(n, k)
result = []
curr = root
for i in range(k):
head = curr
for j in range(width - 1 + int(i < remainder)):
if curr:
curr = curr.next
if curr:
curr.next, curr = None, curr.next
result.append(head)
return result
@pytest.mark.parametrize("kw,expected", [
[dict(root=ListNode.initList([1, 2, 3]), k=5), [[1], [2], [3], [], []]],
[dict(root=ListNode.initList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), k=3),
[[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]],
])
def test_solutions(kw, expected):
expected = [ListNode.initList(x) for x in expected]
res = Solution().splitListToParts(**kw)
assert repr(res) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
prev, head = None, None
sum = 0
while stack1 or stack2:
sum //= 10
if stack1:
sum += stack1.pop()
if stack2:
sum += stack2.pop()
head = ListNode(sum % 10)
head.next = prev
prev = head
if sum >= 10:
head = ListNode(sum // 10)
head.next = prev
return head
@pytest.mark.parametrize("kw,expected", [
[
dict(l1=ListNode.init_list_from_str("7 -> 2 -> 4 -> 3"),
l2=ListNode.init_list_from_str("5 -> 6 -> 4")),
ListNode.initList([7, 8, 0, 7])
],
])
def test_solutions(kw, expected):
assert repr(Solution().addTwoNumbers(**kw)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
while l1 or l2:
x = l1.val if l1 else 0
y = l2.val if l2 else 0
v_sum = x + y + carry
carry = v_sum // 10
curr_node.next = ListNode(v_sum % 10)
curr_node = curr_node.next
if l1:
l1 = l1.next
if l2:
l2 = l2.next
if carry:
curr_node.next = ListNode(1)
return head_node.next
@pytest.mark.parametrize("kw,expected", [
[
dict(l1=ListNode.initList([2, 4, 3]), l2=ListNode.initList([5, 6, 4])),
ListNode.initList([7, 0, 8])
],
])
def test_solutions(kw, expected):
assert repr(Solution().addTwoNumbers(**kw)) == repr(expected)
assert repr(Solution1().addTwoNumbers(**kw)) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
self.front_pointer = self.front_pointer.next
return True
return recursively_check(head)
class Solution3:
def isPalindrome(self, head: ListNode) -> bool:
l = []
cur = head
while cur:
l.append(cur.val)
cur = cur.next
return list(reversed(l)) == l
@pytest.mark.parametrize("args,expected", [
(ListNode.initList([1, 2, 3, 4, 5]), False),
(ListNode.initList([1, 2, 3, 2, 1]), True),
(ListNode.initList([1, 2, 3, 3, 2, 1]), True),
])
def test_solutions(args, expected):
assert Solution().isPalindrome(copy.deepcopy(args)) == expected
assert Solution1().isPalindrome(copy.deepcopy(args)) == expected
assert Solution2().isPalindrome(copy.deepcopy(args)) == expected
assert Solution3().isPalindrome(copy.deepcopy(args)) == expected
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=no", __file__])
from common_utils import ListNode
# leetcode submit region begin(Prohibit modification and deletion)
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteNode(self, node):
node.val = node.next.val
node.next = node.next.next
# leetcode submit region end(Prohibit modification and deletion)
@pytest.mark.parametrize("args,expected", [
(ListNode.initList([1, 2, 3]), ListNode.initList([2, 3])),
])
def test_solutions(args, expected):
Solution().deleteNode(args)
assert repr(args) == repr(expected)
if __name__ == '__main__':
pytest.main(["-q", "--color=yes", "--capture=tee-sys", __file__])
def test_solutions(kw, expected):
expected = [ListNode.initList(x) for x in expected]
res = Solution().splitListToParts(**kw)
assert repr(res) == repr(expected)
prefix += cur.val
seen[prefix] = cur
cur = cur.next
cur2 = dummy
prefix = 0
# // 第二遍遍历 若当前节点处sum在下一处出现了则表明两结点之间所有节点和为0 直接删除区间所有节点
while cur2:
prefix += cur2.val
cur2.next = seen[prefix].next
cur2 = cur2.next
return dummy.next
@pytest.mark.parametrize("args,expected", [
[ListNode.initList([1, 2, -3, 3, 1], ),
ListNode.initList([3, 1])],
[ListNode.initList([1, 2, 3, -3, 4], ),
ListNode.initList([1, 2, 4])],
[ListNode.initList([1, 2, 3, -3, -2], ),
ListNode.initList([1])], [ListNode.initList(
[], ), ListNode.initList([])],
[ListNode.initList([0], ), ListNode.initList([])],
[ListNode.initList([0, 0], ),
ListNode.initList([])],
[ListNode.initList([-1, 1, 0, 1], ),
ListNode.initList([1])],
[ListNode.initList([2, 2, -2, 1, -1, -1], ),
ListNode.initList([2, -1])],
[ListNode.initList([-1, -2, 0, -1, 2, 2, -1, 1], ),
ListNode.initList([])],
