def test_same_tree():
l1 = [1, 2, 4]
l2 = [1, 2, 3, None, 4, 5, 6]
t1 = construct_tree(l1)
t2 = construct_tree(l2)
s = Solution()
print()
for i in s.iterate(t1):
print(i, end=' ')
print()
for i in s.iterate(t2):
print(i, end=' ')
def test_has_pathsum():
nums = [5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1]
root = construct_tree(nums)
s = Solution()
assert s.hasPathSum(root, 22)
nums = [1, 2]
root = construct_tree(nums)
assert not s.hasPathSum(root, 1)
nums = [1, -2, -3, 1, 3, -2, None, -1]
root = construct_tree(nums)
assert s.hasPathSum(root, -1)
def sum_left(self, node, left=True):
if not node:
return 0
if not (node.left or node.right):
if left:
return node.val
else:
return 0
return self.sum_left(node.left, True) + self.sum_left(
node.right, False)
def sumOfLeftLeaves(self, root: TreeNode) -> int:
isNodeLeaf = lambda node: not node.left and not node.right
def dfs(node) -> int:
ans = 0
if node.left:
ans += node.left.val if isNodeLeaf(node.left) else dfs(
node.left)
if node.right:
ans += dfs(node.right) if not isNodeLeaf(node.right) else 0
return ans
return dfs(root) if root else 0
if __name__ == '__main__':
s = Solution()
l = [3, 9, 20, None, None, 15, 7]
root = construct_tree(l)
print(s.sumOfLeftLeaves(root))
if first.right:
new_level.append(first.right)
this_level.append(first.val)
ret.append(this_level)
queue.extend(new_level)
return ret
def levelOrder3(self, root: TreeNode) -> List[List[int]]:
"""DFS"""
if not root:
return []
self.result = []
self._dfs(root, 0)
return self.result
def _dfs(self, root: TreeNode, level: int):
if not root:
return
if len(self.result) < level + 1:
self.result.append([])
self.result[level].append(root.val)
self._dfs(root.left, level + 1)
self._dfs(root.right, level + 1)
if __name__ == '__main__':
tree = construct_tree([3, 9, 20, None, None, 15, 7])
s = Solution()
ret = s.levelOrder3(tree)
print(ret)
return 0
self.min = None
self._bfs(root)
return self.min
def _bfs(self, node: TreeNode):
queue = deque([node])
level = 0
while queue:
level += 1
q_len = len(queue)
# print(q_len)
for _ in range(q_len): # 遍历完一层
top = queue.popleft()
if top.left is None and top.right is None:
self.min = level # 因为level是不断上升的, 因此头一个发现的叶子肯定是层数最低的
return
if top.left:
queue.append(top.left)
if top.right:
queue.append(top.right)
if __name__ == '__main__':
tree = construct_tree([3, 9, 20, None, None, 15, 7, 4, 5, 45, 12])
s = Solution()
assert s.minDepth2(tree) == 2
tree = construct_tree([1, 2])
assert s.minDepth2(tree) == 2
tree = construct_tree([1, None, 2])
assert s.minDepth2(tree) == 2
def test_symmetric(nums, expected):
root = construct_tree(nums)
s = Solution()
assert s.isSymmetric(root) == expected
memo[(node, v)] = 1
return True
if node.val == v.val:
memo[(node, v)] = 1
return True
if self.in_tree(node.right, v):
memo[(node, v)] = 1
return True
return False
def lowestCommonAncestor2(self, root: 'TreeNode', p: 'TreeNode',
q: 'TreeNode') -> 'TreeNode':
if root is None or root.val == p.val or root.val == q.val:
return root
left = self.lowestCommonAncestor2(root.left, p, q)
right = self.lowestCommonAncestor2(root.right, p, q)
if left is None:
return right
elif right is None:
return left
else:
# assert (left is None and right is None)
return root
if __name__ == '__main__':
s = Solution()
tree = construct_tree([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4])
node = s.lowestCommonAncestor2(tree, TreeNode(5), TreeNode(1))
print(node.val)
node3.left = node1.left
else:
stack1.append(node1.left)
stack2.append(node2.left)
left = TreeNode(node1.left.val + node2.left.val)
node3.left = left
stack3.append(left)
if node1.right is None:
node3.right = node2.right
elif node2.right is None:
node3.right = node1.right
else:
stack1.append(node1.right)
stack2.append(node2.right)
right = TreeNode(node1.right.val + node2.right.val)
node3.right = right
stack3.append(right)
return head
e
if __name__ == '__main__':
s = Solution()
l1 = [1, 3, 2, 5]
l2 = [2, 1, 3, None, 4, None, 7]
t1 = construct_tree(l1)
t2 = construct_tree(l2)
t = s.mergeTrees2(t1, t2)
print(bfs_visit_tree(t))
def test():
tree1 = construct_tree([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
s = Solution()
assert s.btreeGameWinningMove(tree1, 11, 3)
tree2 = construct_tree([1, 2, 3, 4, 5])
assert not s.btreeGameWinningMove(tree2, 5, 2)
def test3():
l = [10, 5, 15, 3, 7, None, 18]
tree = construct_tree(l)
s = Solution()
a_sum = s.rangeSumBST3(tree, 7, 15)
assert a_sum == 32
from typing import List
from collections import deque
from leetcode_projects.tree import TreeNode, construct_tree
class Solution:
def rightSideView(self, root: TreeNode) -> List[int]:
if not root:
return []
stack = deque([root])
ret = []
while stack:
size = len(stack)
ret.append(stack[0].val)
for _ in range(size):
node = stack.popleft()
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return ret
if __name__ == '__main__':
l = [1, 2, 3, None, 5, None, 4]
tree = construct_tree(l)
s = Solution()
ret = s.rightSideView(tree)
assert ret == [1, 3, 4]
