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