def delNodes(self, root: TreeNode, to_delete: list) -> list:
dic = {v: v for v in to_delete}
res = []
if root is None:
return []
# sub_dir 代表左子树或右子树(0:左子树; １:右子树）
def get_sub(node: TreeNode, parent: TreeNode, sub_dir: int):
nonlocal dic
nonlocal res
k = dic.get(node.val, 0)
if k > 0:
if node.left:
res.append(node.left)
get_sub(node.left, node, 0)
if node.right:
res.append(node.right)
get_sub(node.right, node, 1)
if sub_dir:
parent.right = None
else:
parent.left = None
else:
if node.left:
get_sub(node.left, node, 0)
if node.right:
get_sub(node.right, node, 1)
head = TreeNode(-1)
head.left = root
get_sub(root, head, 0)
res.append(root)
return [node for node in res if node.val not in dic]
def buildTree(treelist):
# 构建根元素
tree_dic = {}
max_len = len(treelist)
root = 0
stack = [root]
root_tree = TreeNode(treelist[root])
tree_dic[root] = root_tree
while True:
poped = stack.pop()
tree = tree_dic[poped]
right = poped * 2 + 2
left = poped * 2 + 1
if (right < max_len and treelist[right] != None):
right_tree = TreeNode(treelist[right])
tree.right = right_tree
tree_dic[right] = right_tree
stack.append(right)
if (left < max_len and treelist[left] != None):
left_tree = TreeNode(treelist[left])
tree.left = left_tree
tree_dic[left] = left_tree
stack.append(left)
if (len(stack) == 0):
break
return root_tree
def increasingBST(self, root: TreeNode) -> TreeNode:
iter_head = TreeNode(None)
head = iter_head
if root.left is not None:
head = self.build_left_tree(root.left, root)
if root.right is not None:
root.right = self.build_right_tree(root.right)
return head
def build_tree(lst: list):
le = len(lst)
if le == 0:
return
if le == 1:
return TreeNode(lst[0])
middle = int(le / 2)
r = TreeNode(lst[middle])
r.left = build_tree(lst[0:middle])
r.right = build_tree(lst[middle + 1:])
return r
def allPossibleFBT(self, N: int):
Solution.dic.clear()
if N == 1:
return [TreeNode(0)]
if N % 2 == 0:
return []
Solution.dic[1] = [TreeNode(0)]
for i in range(3, N + 1, 2):
Solution.dic[i] = self.build_tree_list(i)
return Solution.dic[N]
def build_tree_list(self, sub_tree_num):
sub_tree_num -= 1
lst = [(i, sub_tree_num - i) for i in range(1, sub_tree_num, 2)]
ret_lst = []
for left, right in lst:
for L in Solution.dic[left]:
for R in Solution.dic[right]:
node = TreeNode(0)
node.left = L
node.right = R
ret_lst.append(node)
Solution.dic[sub_tree_num + 1] = ret_lst
return ret_lst
def bstFromPreorder(self, preorder: list) -> TreeNode:
if len(preorder) == 0:
return None
left = []
right = []
mid = preorder[0]
for x in preorder[1:]:
if x < mid:
left.append(x)
else:
right.append(x)
node = TreeNode(mid)
if len(left) > 0:
node.left = self.bstFromPreorder(left)
if len(right) > 0:
node.right = self.bstFromPreorder(right)
return node
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return
if not root.left and not root.right:
return root
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root
def get_subtree(self, node: TreeNode):
if node is None:
return 0, None
t = TreeNode(node.val)
left_num, left_subtree = self.get_subtree(node.left)
right_num, right_subtree = self.get_subtree(node.right)
if left_num > 0 or right_num > 0:
if left_num > 0:
t.left = left_subtree
if right_num > 0:
t.right = right_subtree
return 1, t
else:
if t.val > 0:
return 1, t
else:
return 0, None
def increasingBST(self, root: TreeNode) -> TreeNode:
head = TreeNode(None)
pre = head
current = root
deq = deque()
while (True):
if current is not None:
deq.append(current)
current = current.left
elif len(deq) > 0:
current = deq.pop()
node = TreeNode(current.val)
head.right = node
head = head.right
current = current.right
else:
break;
return pre.right
def get_sub(node: TreeNode, parent: TreeNode, sub_dir: int):
nonlocal dic
nonlocal res
k = dic.get(node.val, 0)
if k > 0:
if node.left:
res.append(node.left)
get_sub(node.left, node, 0)
if node.right:
res.append(node.right)
get_sub(node.right, node, 1)
if sub_dir:
parent.right = None
else:
parent.left = None
else:
if node.left:
get_sub(node.left, node, 0)
if node.right:
get_sub(node.right, node, 1)
def recoverFromPreorder(self, S: str) -> TreeNode:
# 先找到第一个-， 有可能不存在
i = S.find('-')
if i == -1:
return TreeNode(int(S))
else:
first_num = int(S[:i])
cur_node = TreeNode(-1)
root = TreeNode(first_num)
nodelist = [(root.val, 0, root)]
word = []
while i < len(S):
level = 0
word.clear()
while S[i] == '-':
level += 1
i += 1
while i < len(S) and S[i] != '-':
word.append(S[i])
i += 1
num = int(''.join(word))
nodelist.append((num, level, TreeNode(num)))
stacks = []
cur_lever = -1
for num, level, node in nodelist:
if level > cur_lever:
cur_lever = level
stacks.append((level, node))
if cur_node.left is None:
cur_node.left = node
cur_node = cur_node.left
else:
cur_node.right = node
cur_node = cur_node.right
continue
else:
while True:
cur_lever, cur_node = stacks[-1]
if cur_lever + 1 == level:
break
else:
cur_lever, cur_node = stacks.pop()
continue
cur_node.right = node
cur_node = cur_node.right
cur_lever = level
stacks.append((level, node))
return root
def make_tree(left, right):
root = TreeNode(left[0])
if len(left) == 1:
return root
left_begin_index = right.index(left[1])
# 中左右遍历的左树
left_tree = left[1:1 + len(right) - left_begin_index]
# 中右左遍历的左树
left_tree_post = right[left_begin_index:]
# 中左右遍历的右树
right_tree = left[1 + len(right) - left_begin_index:]
# 中右左遍历的右树
right_tree_post = right[1:left_begin_index]
if len(left_tree) > 0:
root.left = make_tree(left_tree, left_tree_post)
if len(right_tree) > 0:
root.right = make_tree(right_tree, right_tree_post)
return root
def recoverFromPreorder(self, S: str) -> TreeNode:
stack, i = [], 0
while i < len(S):
level, val = 0, ""
while i < len(S) and S[i] == '-':
level, i = level + 1, i + 1
while i < len(S) and S[i] != '-':
val, i = val + S[i], i + 1
while len(stack) > level:
stack.pop()
node = TreeNode(val)
if stack and stack[-1].left is None:
stack[-1].left = node
elif stack:
stack[-1].right = node
stack.append(node)
return stack[0]
def get_sub(self, node: TreeNode, target: int):
if node.val == target:
if node.left is None and node.right is None:
return (None, 1)
else:
if node.left:
tree, is_need_delete = self.get_sub(node.left, target)
if is_need_delete == 1:
node.left = None
else:
node.left = tree
if node.right:
tree, is_need_delete = self.get_sub(node.right, target)
if is_need_delete == 1:
node.right = None
else:
node.right = tree
if node.left is None and node.right is None:
return (None, 1)
else:
return (node, 0)
else:
if node.left:
tree, is_need_delete = self.get_sub(node.left, target)
if is_need_delete == 1:
node.left = None
else:
node.left = tree
if node.right:
tree, is_need_delete = self.get_sub(node.right, target)
if is_need_delete == 1:
node.right = None
else:
node.right = tree
return (node, 0)
class Solution:
def getTargetCopy(self, original: TreeNode, cloned: TreeNode,
target: TreeNode) -> TreeNode:
v = target.val
stacks = []
if cloned:
stacks.append(cloned)
while len(stacks) > 0:
poped = stacks.pop()
if poped.val == v:
return poped
if poped.right:
stacks.append(poped.right)
if poped.left:
stacks.append(poped.left)
return None
arr = '[1,2,3,4,5,6,7,8,9,10]'
original = stringToTreeNode(arr)
cloned = stringToTreeNode(arr)
target = TreeNode(5)
t1 = datetime.now()
s = Solution()
res = s.getTargetCopy(original, cloned, target)
print(res)
t2 = datetime.now()
print(t2 - t1)