def test_solution(self): for nums, p, q, answer in self.test_case: root = TreeNode.create(nums) p = TreeNode(p) q = TreeNode(q) ans = self.s.lowestCommonAncestor(root, p, q) self.assertEqual(answer, ans.val)
def invert_tree_by_dfs(self, node: TreeNode) -> TreeNode: if node is None: return left = self.invert_tree_by_dfs(node.left) right = self.invert_tree_by_dfs(node.right) node.left = right node.right = left return node
def dfs(nums: List[int]) -> TreeNode: if len(nums) <= 0: return None max_item = max(nums) mid = nums.index(max_item) root = TreeNode(max_item) root.left = dfs(nums[0:mid]) root.right = dfs(nums[mid + 1:len(nums)]) return root
def dfs(node: TreeNode) -> bool: if node is None: return True left = dfs(node.left) right = dfs(node.right) if left: node.left = None if right: node.right = None return left and right and node.val == 0
def postorder(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]: if root is None: return [] t = {} ans = [] stack = [] visited = None node = root head = TreeNode(val=None) head.left = node parent = head position = "l" while True: while node is not None: stack.append((node, parent, position)) parent = node position = "l" node = node.left if len(stack) <= 0: break if stack[-1][0].right != visited: node = stack[-1][0].right parent = stack[-1][0] position = "r" visited = None else: visited, parent, position = stack.pop() for i in to_delete: if t.get(i, False): continue if visited.val == i: if visited.left is not None: ans.append(visited.left) visited.left = None if visited.right is not None: ans.append(visited.right) visited.right = None # 处理parent if position == "l": parent.left = None else: parent.right = None t[i] = True if head.left is not None: ans.append(head.left) head.left = None return ans
def dfs_(node: TreeNode, sum_: int) -> int: if node is None: return sum_ sum_ = dfs_(node.right, sum_) sum_ += node.val node.val = sum_ return dfs_(node.left, sum_)
def insert_dfs(self, node, val): if node is None: return TreeNode(val) if val < node.val: node.left = self.insert_dfs(node.left, val) elif node.val < val: node.right = self.insert_dfs(node.right, val) return node
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.increasingBST(root) # self.assertEqual(answer,ans ) while ans is not None: print(ans.val) print(ans.left) ans = ans.right
def dfs(self, node: TreeNode) -> TreeNode: if node is None: return left = self.increasingBST(node.left) right = self.increasingBST(node.right) node.right = right node.left = None if left is None: return node node = left prev = None while node is not None: prev = node node = node.right prev.right = node return left
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode: if len(inorder) <= 0: return None root_val = postorder[-1] root = TreeNode(val=root_val) index = inorder.index(root_val) inorder_left = inorder[0:index] inorder_right = inorder[index + 1:] postorder_left = postorder[0:index] postorder_right = postorder[index:len(postorder) - 1] root.left = self.buildTree(inorder_left, postorder_left) root.right = self.buildTree(inorder_right, postorder_right) return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: if len(inorder) <= 0: return None root_val = preorder[0] root = TreeNode(val=root_val) index = inorder.index(root_val) inorder_left = inorder[0:index] # [0, root) root=index -> [0, index) inorder_right = inorder[index + 1:] # [root+1, len(inorder)) ->[index+1, ) preorder_left = preorder[ 1:index + 1] # [1:1+len(inorder_left)) -> [1, index+1) preorder_right = preorder[ index + 1:] # [index+1: len(inorder_right] -> [index+1, ) root.left = self.buildTree(preorder_left, inorder_left) root.right = self.buildTree(preorder_right, inorder_right) return root
def inorder(self, node: TreeNode) -> TreeNode: if node is None: return head = TreeNode(val=0) prev = head node = node stack = [] while True: while node is not None: stack.append(node) node = node.left if len(stack) <= 0: break node = stack.pop() node.left = None prev.right = node prev = node node = node.right return head.right
def flatten_by_dfs_recursion(self, node: TreeNode): def merge_left_right(left: TreeNode, right: TreeNode) -> TreeNode: if left is None: return right if right is None: return left parent = None node = left while node is not None: parent = node node = node.right parent.right = right return left if node is None: return left = node.left right = node.right self.flatten_by_dfs_recursion(left) self.flatten_by_dfs_recursion(right) node.right = merge_left_right(left, right) node.left = None
def _dfs(node: TreeNode, parent: TreeNode, position: str): if node is None: return _dfs(node.left, node, "l") _dfs(node.right, node, "r") for i in to_delete: if t.get(i, False): continue if i == node.val: if node.left is not None: ans.append(node.left) node.left = None if node.right is not None: ans.append(node.right) node.right = None if position == "l": parent.left = None else: parent.right = None t[i] = True
def delete_dfs(self, node: TreeNode, key: int) -> TreeNode: if node is None: raise ValueError("key err") if key < node.val: node.left = self.delete_dfs(node.left, key) elif node.val < key: node.right = self.delete_dfs(node.right, key) else: # node.val == val if node.left is None: rnode = node.right del node return rnode elif node.right is None: lnode = node.left del node return lnode else: # node.left is not None and node.right is not None successor = self.minimum(node.right) successor.right = self.delete_dfs(node.right, successor.val) successor.left = node.left del node node = successor return node
def invert_tree_by_bfs(self, node: TreeNode) -> TreeNode: if node is None: return root = node queue = [node] while len(queue) > 0: node = queue.pop(0) node.right, node.left = node.left, node.right if node.left is not None: queue.append(node.left) if node.right is not None: queue.append(node.right) return root
def dfs(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]: ans = [] t = {} def _dfs(node: TreeNode, parent: TreeNode, position: str): if node is None: return _dfs(node.left, node, "l") _dfs(node.right, node, "r") for i in to_delete: if t.get(i, False): continue if i == node.val: if node.left is not None: ans.append(node.left) node.left = None if node.right is not None: ans.append(node.right) node.right = None if position == "l": parent.left = None else: parent.right = None t[i] = True # 处理 root parent = TreeNode(val=None) parent.left = root _dfs(root, parent, "l") if parent.left is not None: ans.append(parent.left) parent.left = None return ans
def inorder(self, node: TreeNode) -> bool: """ 中序遍历 """ prev = TreeNode(val=float("-inf")) stack = [] while True: while node is not None: stack.append(node) node = node.left if not stack: break node = stack.pop() if node.val <= prev.val: return False prev = node node = node.right return True
def inorder(self, node: TreeNode) -> TreeNode: stack = [] root = node prev = TreeNode(val=0) while True: while node is not None: stack.append(node) node = node.right if len(stack) <= 0: break node = stack.pop() node.val += prev.val prev = node node = node.left return root
def test_solution(self): for nums, answer in self.test_case: ans = self.s.constructMaximumBinaryTree(nums) self.assertEqual(answer, TreeNode.literal(ans))
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.convertBST(root) self.assertEqual(TreeNode.literal(ans), answer)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.pruneTree(root) self.assertEqual(answer, TreeNode.literal(ans))
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.zigzagLevelOrder(root) print(ans) self.assertEqual(answer, ans)
def test_solution(self): for nums1, nums2, answer in self.test_case: root1 = TreeNode.create(nums1) root2 = TreeNode.create(nums2) ans = self.s.flipEquiv(root1, root2) self.assertEqual(answer, ans)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) answer = TreeNode.create(answer) ans = self.s.invertTree(root)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.connect(root)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.isSymmetric(root) self.assertEqual(answer, ans)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.largestValues(root) self.assertEqual(answer, ans)
def test_solution(self): for nums, low, high, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.rangeSumBST(root, low, high) self.assertEqual(answer, ans)
def test_solution(self): for nums, answer in self.test_case: root = TreeNode.create(nums) ans = self.s.widthOfBinaryTree(root) self.assertEqual(answer, ans)