def removeLeafNodes(self, root: TreeNode, target: int) -> TreeNode:
if root:
root.left = self.removeLeafNodes(root.left, target)
root.right = self.removeLeafNodes(root.right, target)
if root.val == target and not root.left and not root.right:
root = None
return root
def pruneTree(self, root: TreeNode) -> TreeNode:
if root:
root.left = self.pruneTree(root.left)
root.right = self.pruneTree(root.right)
if root.val == 0 and not root.left and not root.right:
return None
return root
def reConstructBinaryTree(self, pre, tin):
if not pre or not tin:
return None
root = TreeNode(pre.pop(0))
index = tin.index(root.val)
root.left = self.reConstructBinaryTree(pre, tin[:index])
root.right = self.reConstructBinaryTree(pre, tin[index + 1:])
return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
root = TreeNode(preorder[0])
i = inorder.index(root.val)
root.left = self.buildTree(preorder[1:i+1], inorder[:i])
root.right = self.buildTree(preorder[i+1:], inorder[i+1:])
return root
def buildTree(self, data, pos):
pos += 1
if pos >= len(data) or data[pos] == None:
return None, pos
root = TreeNode(data[pos])
root.left, pos = self.buildTree(data, pos)
root.right, pos = self.buildTree(data, pos)
return root, pos
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if t1 is None:
return t2
if t2 is None:
return t1
t1.val += t2.val
t1.left = self.mergeTrees(t1.left, t2.left)
t1.right = self.mergeTrees(t1.right, t2.right)
return t1
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if inorder:
index = inorder.index(preorder.pop(0))
node = TreeNode(inorder[index])
node.left = self.buildTree(preorder, inorder[0:index])
node.right = self.buildTree(preorder, inorder[index + 1:])
return node
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not inorder:
return None
root = TreeNode(postorder[-1])
i = inorder.index(root.val)
root.left = self.buildTree(inorder[:i], postorder[:i])
root.right = self.buildTree(inorder[i+1:], postorder[i:-1])
return root
def sortedArrayToBST(self, num):
if not num:
return None
mid = len(num) // 2
root = TreeNode(num[mid])
root.left = self.sortedArrayToBST(num[:mid])
root.right = self.sortedArrayToBST(num[mid + 1:])
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
left = nums[:mid]
right = nums[mid + 1:]
if left:
root.left = self.sortedArrayToBST(left)
if right:
root.right = self.sortedArrayToBST(right)
return root
def helper(in_left, in_right):
# if there is no elements to construct subtrees
if in_left > in_right:
return None
# pick up the last element as a root
val = postorder.pop()
root = TreeNode(val)
# root splits inorder list
# into left and right subtrees
index = idx_map[val]
# build right subtree
root.right = helper(index + 1, in_right)
# build left subtree
root.left = helper(in_left, index - 1)
return root
def helper(in_left=0, in_right=len(inorder)):
nonlocal pre_idx
# if there is no elements to construct subtrees
if in_left == in_right:
return None
# pick up pre_idx element as a root
root_val = preorder[pre_idx]
root = TreeNode(root_val)
# root splits inorder list
# into left and right subtrees
index = idx_map[root_val]
# recursion
pre_idx += 1
# build left subtree
root.left = helper(in_left, index)
# build right subtree
root.right = helper(index + 1, in_right)
return root
def invertTree(root: TreeNode) -> TreeNode:
if root:
root.left, root.right = \
invertTree(root.right), invertTree(root.left)
return root
return None
def invertTree(root: TreeNode):
if root:
root.left, root.right = \
invertTree(root.right), invertTree(root.left)
return root
return None # 사실 파이썬에선 이거 생략해도 오류를 안내지만, 좀더 정석적인 코드를 위해!
return 0
left = self.get_max_depth(root.left)
right = self.get_max_depth(root.right)
self.result = max(self.result, right + left)
return max(left + 1, right + 1)
# Main Call
# Initialize the Tree First
tree_root = TreeNode(1)
tree_left_1 = TreeNode(2)
tree_right_1 = TreeNode(3)
tree_left_2 = TreeNode(4)
tree_left_3 = TreeNode(5)
tree_root.left = tree_left_1
tree_left_1.left = tree_left_2
tree_left_1.right = tree_left_3
tree_root.right = tree_right_1
tree_right_1.left = None
tree_right_1.right = None
tree_left_2.left = None
tree_left_2.right = None
tree_left_3.left = None
tree_left_3.right = None
print(tree_root.val)
print(tree_root.left.val)
print(tree_root.left.left.val)
print(tree_root.left.right.val)
while queue:
tmp, new_queue = [], collections.deque()
while queue:
node = queue.popleft() if to_right else queue.pop()
tmp.append(node.val)
if to_right:
if node.left:
new_queue.append(node.left)
if node.right:
new_queue.append(node.right)
else:
if node.right:
new_queue.appendleft(node.right)
if node.left:
new_queue.appendleft(node.left)
to_right = not to_right
queue = new_queue
res.append(tmp)
return res
root = TreeNode(1)
left = TreeNode(2)
left.left = TreeNode(4)
right = TreeNode(3)
right.right = TreeNode(5)
root.left = left
root.right = right
print(Solution().levelOrder(root))
