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]