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)
