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
