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 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 _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 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 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 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 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