def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder or not inorder: return None
index = inorder.index(preorder.pop(0))
current_root = TreeNode(inorder[index])
current_root.left = self.buildTree(preorder,inorder[0:index])
current_root.right = self.buildTree(preorder,inorder[index+1:])
return current_root
def recoverFromPreorder(self, S: str) -> TreeNode:
S += "$"
stack = []
current_key, prev_key, current_value, current_children = "", "", "", []
for ch in S:
if ch == "$":
level = prev_key.count("-")
while stack and (level < stack[-1][0]):
while (current_children
== []) or current_children[-1][0] == stack[-1][0]:
current_children.append(stack.pop())
if len(current_children) == 2:
stack[-1][1].left = current_children.pop()[1]
stack[-1][1].right = current_children.pop()[1]
elif len(current_children) == 1:
stack[-1][1].left = current_children.pop()[1]
stack.append((level, TreeNode(int(current_value))))
if ch == '-':
current_key += "-"
if current_value:
level = prev_key.count("-")
while stack and (level < stack[-1][0]):
while (current_children == []
) or current_children[-1][0] == stack[-1][0]:
current_children.append(stack.pop())
if len(current_children) == 2:
stack[-1][1].left = current_children.pop()[1]
stack[-1][1].right = current_children.pop()[1]
elif len(current_children) == 1:
stack[-1][1].left = current_children.pop()[1]
stack.append((level, TreeNode(int(current_value))))
current_value = ""
prev_key = ""
elif ch.isdigit():
if current_key:
prev_key = current_key
current_key = ""
current_value += ch
while len(stack) > 1:
while (current_children
== []) or current_children[-1][0] == stack[-1][0]:
current_children.append(stack.pop())
if len(current_children) == 2:
stack[-1][1].left = current_children.pop()[1]
stack[-1][1].right = current_children.pop()[1]
elif len(current_children) == 1:
stack[-1][1].left = current_children.pop()[1]
return stack[0][1]
from leetcode_problems.leetcode.common_tools.tree_node import TreeNode
class Solution:
def preorderTraversal_recursive(self, root: TreeNode) -> List[int]:
"""1刷递归"""
"""执行用时 :28 ms, 在所有 Python3 提交中击败了98.38%的用户"""
def helper(root, res):
if root:
res.append(root.val)
helper(root.left, res)
helper(root.right, res)
return res
return helper(root, [])
def preorderTraversal(self, root: TreeNode) -> List[int]:
res, stack = [], []
while root or stack:
while root:
res.append(root.val)
stack.append(root.right)
root = root.left
root = stack.pop()
return res
if __name__ == '__main__':
test = Solution()
root = TreeNode.generate_tree([1, None, 2, 3])
print(test.preorderTraversal(root))
while stack or root:
while root:
stack.append(root)
root = root.left
root = stack.pop()
curr_val = root.val
if curr_val <= prev_val:
return False
prev_val = curr_val
root = root.right
return True
if __name__ == '__main__':
null = None
test = Solution()
root = TreeNode.generate_tree([1, 1])
root1 = TreeNode.generate_tree([2, 1, 3])
root2 = TreeNode.generate_tree([5, 1, 4, null, null, 3, 6])
root3 = TreeNode.generate_tree([])
root4 = TreeNode.generate_tree([10, 5, 15, null, null, 6, 20])
res = test.isValidBST(root)
res1 = test.isValidBST(root1)
res2 = test.isValidBST(root2)
res3 = test.isValidBST(root3)
res4 = test.isValidBST(root4)
print(res)
print(res1)
print(res2)
print(res3)
print(res4)
def invertTree(self, root: TreeNode) -> TreeNode:
if root:
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root
class Solution:
def minDepth1(self, root: TreeNode) -> int:
"DFS 优雅的光头哥"
if not root: return 0
depth = list(map(self.minDepth, (root.left, root.right)))
return 1 + (min(depth) or max(depth))
def minDepth(self, root: TreeNode) -> int:
"""用deque效率会不会好点"""
if not root: return 0
min_depth, stack = 0, deque([(1, root)])
while stack:
min_depth, root = stack.pop()
if root:
if not (root.left or root.right):
return min_depth
stack.insert(0, (min_depth + 1, root.left))
stack.insert(0, (min_depth + 1, root.right))
if __name__ == '__main__':
null = None
root = TreeNode.generate_tree([3, 9, 20, null, null, 15, 7]) #2
root1 = TreeNode.generate_tree([1, 2]) #2
root2 = TreeNode.generate_tree([1, 2, 3, 4, 5]) #2
test = Solution()
print(test.minDepth(root))
print(test.minDepth(root1))
print(test.minDepth(root2))
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode',
q: 'TreeNode') -> 'TreeNode':
parents = {root.val: None}
ans = set()
stack = deque([root])
while p.val not in parents or q.val not in parents:
node = stack.pop()
if node.left:
parents[node.left.val] = node
stack.append(node.left)
if node.right:
parents[node.right.val] = node
stack.appendleft(node.right)
while p:
ans.add(p.val)
p = parents[p.val]
while q.val not in ans:
q = parents[q.val]
return q
if __name__ == '__main__':
null = None
root = TreeNode.generate_tree([3, 5, 1, 6, 2, 0, 8, null, null, 7, 4])
p = TreeNode.generate_tree([5, 6, 2, null, null, 7, 4])
q = TreeNode.generate_tree([1, 0, 8])
test = Solution()
ans = test.lowestCommonAncestor(root, p, q)
print(ans)
current_nodes = []
for node in stack:
if node.left:
current_nodes.append(node.left)
if node.right:
current_nodes.append(node.right)
stack = current_nodes
return res
def maxDepth3(self, root: TreeNode) -> int:
"DFS 优雅de光头哥"
return 1 + max(map(self.maxDepth, (root.left, root.right))) if root else 0
def maxDepth(self, root: TreeNode) -> int:
"BFS 优雅"
max_depth, stack = 0, [(1, root)] if root else []
while stack:
depth, root = stack.pop()
if root:
max_depth = max(depth, max_depth)
stack.append((depth+1, root.left))
stack.append((depth+1, root.right))
return max_depth
if __name__ == '__main__':
null = None
root = TreeNode.generate_tree([3,9,20,null,null,15,7])
root1 = TreeNode.generate_tree([1,2])
test = Solution()
print(test.maxDepth(root))
print(test.maxDepth(root1))
def buildTree1(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if inorder:
current_root = TreeNode(preorder.pop(0))
current_root.left = self.buildTree(preorder,inorder[0:inorder.index(current_root.val)])
current_root.right = self.buildTree(preorder,inorder[inorder.index(current_root.val)+1:])
return current_root
class Solution:
def buildTree1(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if inorder:
current_root = TreeNode(preorder.pop(0))
current_root.left = self.buildTree(preorder,inorder[0:inorder.index(current_root.val)])
current_root.right = self.buildTree(preorder,inorder[inorder.index(current_root.val)+1:])
return current_root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder or not inorder: return None
index = inorder.index(preorder.pop(0))
current_root = TreeNode(inorder[index])
current_root.left = self.buildTree(preorder,inorder[0:index])
current_root.right = self.buildTree(preorder,inorder[index+1:])
return current_root
# 3
# / \
# 9 20
# / \
# 15 7
# preorder = [3,9,20,15,7]
# inorder = [9,3,15,20,7]
if __name__ == '__main__':
test = Solution()
print(TreeNode.print_tree_preorder(test.buildTree([3,9,20,15,7], [9,3,15,20,7])))