def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if not root:
return None
if root.val != key:
if root.left:
left = self.deleteNode(root.left, key)
root.left = left
if root.right:
right = self.deleteNode(root.right, key)
root.right = right
return root
else:
if root.left:
left = root.left
if left and not left.left and left.right:
left_right = left.right
left.right = self.deleteNode(left_right, left_right.val)
left_right.left = left
left_right.right = root.right
return left_right
real_left = self.deleteNode(root.left, root.left.val)
right = root.right
left.left = real_left
left.right = right
return left
if root.right:
return root.right
return None
def mirrorTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
left = self.mirrorTree(root.left)
right = self.mirrorTree(root.right)
root.left = right
root.right = left
return root
def back(self, preorder, pre_begin, pre_end, inorder, in_begin, in_end):
node = TreeNode(preorder[pre_begin])
if self.pos_in[preorder[pre_begin]] != in_begin:
left = self.back(preorder, pre_begin + 1, pre_begin + self.pos_in[preorder[pre_begin]] - in_begin,
inorder, in_begin, self.pos_in[preorder[pre_begin]] - 1)
node.left = left
if self.pos_in[preorder[pre_begin]] != in_end:
right = self.back(preorder, pre_begin + self.pos_in[preorder[pre_begin]] - in_begin + 1, pre_end,
inorder, self.pos_in[preorder[pre_begin]] + 1, in_end)
node.right = right
return node
def back(self, inorder, in_begin, in_end, postorder, post_begin, post_end):
node = TreeNode(postorder[post_end])
if self.pos_in[node.val] != in_begin:
left = self.back(inorder, in_begin, self.pos_in[node.val] - 1,
postorder, post_begin,
post_begin + self.pos_in[node.val] - in_begin - 1)
node.left = left
if self.pos_in[node.val] != in_end:
right = self.back(inorder, self.pos_in[node.val] + 1, in_end,
postorder,
post_begin + self.pos_in[node.val] - in_begin,
post_end - 1)
node.right = right
return node
def recoverFromPreorder(self, S: str) -> TreeNode:
depths = {}
depth = 0
index = 0
while index < len(S):
while S[index] == '-':
depth += 1
index += 1
start_index = index
while index < len(S) and S[index] != '-':
index += 1
val = int(S[start_index: index])
node = TreeNode(val)
temp_list = depths.get(depth, [])
temp_list.append(node)
depths[depth] = temp_list
# print(depth, depths)
if depth != 0:
father = depths[depth - 1][-1]
if father.left:
father.right = node
else:
father.left = node
depth = 0
return depths[0][0]
def make_tree(node):
if not node.next:
return TreeNode(node.val)
slow, fast, slow_slow = node, node, node
while fast.next and fast.next.next:
slow_slow = slow
slow = slow.next
fast = fast.next.next
current = TreeNode(slow_slow.next.val)
if slow_slow.next.next:
right = make_tree(slow_slow.next.next)
current.right = right
slow_slow.next = None
left = make_tree(node)
current.left = left
return current
def dfs(self, start, end):
if start > end:
return [None]
result = []
for i in range(start, end + 1):
lefts = self.dfs(start, i - 1)
rights = self.dfs(i + 1, end)
for left in lefts:
for right in rights:
node = TreeNode(i)
node.left = left
node.right = right
result.append(node)
return result
def back(self, root: TreeNode):
if not root.right and not root.left:
root.val = max(root.val, self.null)
return
if root.left:
self.back(root.left)
if root.right:
self.back(root.right)
temp = self.null
left_son = self.null
if root.left and root.left.left:
left_son = max(left_son, left_son + root.left.left.val)
if root.left and root.left.right:
left_son = max(left_son, left_son + root.left.right.val)
right_son = self.null
if root.right and root.right.left:
right_son = max(right_son, right_son + root.right.left.val)
if root.right and root.right.right:
right_son = max(right_son, right_son + root.right.right.val)
# 1.l+r 2. l 3. r
if root.left or root.right:
if root.left:
temp = max(temp, root.left.val)
if root.right:
temp = max(temp, root.right.val)
if root.left and root.right:
temp = max(temp, root.left.val + root.right.val)
if root.left and right_son != self.null:
temp = max(temp, root.left.val + right_son)
if root.right and left_son != self.null:
temp = max(temp, root.right.val + left_son)
if left_son != self.null or right_son != self.null:
temp = max(temp, left_son + right_son + root.val)
root.val = temp
if temp > self.ans:
self.ans = temp
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if not root:
return None
if key == root.val:
if not root.right and not root.left:
return None
if root.right:
successor = root.right
while successor.left:
successor = successor.left
root.val = successor.val
root.right = self.deleteNode(root.right, root.val)
return root
if not root.right and root.left:
predecessor = root.left
while predecessor.right:
predecessor = predecessor.right
root.val = predecessor.val
root.left = self.deleteNode(root.left, root.val)
return root
if key > root.val:
root.right = self.deleteNode(root.right, key)
return root
if key < root.val:
root.left = self.deleteNode(root.left, key)
return root
def deserialize(self, data):
"""Decodes your encoded data to tree.
1,2,3
1,2,3
:type data: str
:rtype: TreeNode
"""
data = data[1:len(data) - 1]
nodes = []
nums = data.split(',')
for i in range(len(nums)):
temp = nums[i].strip()
if temp != 'None':
node = TreeNode(int(temp))
father_index = int((i + 1) / 2) - 1
if father_index != -1:
if (i + 1) % 2 == 0:
nodes[father_index].left = node
else:
nodes[father_index].right = node
nodes.append(node)
else:
nodes.append(None)
return nodes[0]