def helper(left: int, right: int) -> TreeNode:
if left > right:
return None
mid = (left + right) // 2
node = TreeNode(nums[mid])
node.left = helper(left, mid-1)
node.right = helper(mid+1, right)
return node
def constructFromPrePost(self, pre: List[int], post: List[int]) -> TreeNode:
root = TreeNode(pre.pop(0))
if root.val != post[0]:
root.left = self.constructFromPrePost(pre, post)
if root.val != post[0]:
root.right = self.constructFromPrePost(pre, post)
post.pop(0)
return root
def helper2(low:int, hight: int) -> TreeNode:
if low > hight:
return None
rootval = postorder.pop();
node = TreeNode(rootval)
mid = valindex[rootval];
node.right = helper2(mid+1, hight)
node.left = helper2(low, mid-1)
return node
def helper() -> TreeNode:
root = TreeNode(pre[self.preindex])
self.preindex += 1
if root.val != post[self.postindex]:
root.left = helper()
if root.val != post[self.postindex]:
root.right = helper()
self.postindex += 1
return root
def listToBST(l: int, r: int) -> TreeNode:
if l > r:
return None
if l == r:
return TreeNode(sorted_list[l])
mid = (l + r) // 2
node = TreeNode(sorted_list[mid])
node.left = listToBST(l, mid - 1)
node.right = listToBST(mid + 1, r)
return node
def helper(infrom: int, postfrom: int, length: int) -> TreeNode:
if length == 0:
return None
rootval = postorder[postfrom+length-1]
node = TreeNode(rootval)
inorderindex = valindex[rootval]
leftlen = inorderindex - infrom
rightlen = length - 1 - leftlen
node.left = helper(infrom, postfrom, leftlen)
node.right = helper(infrom+leftlen+1, postfrom+leftlen, rightlen)
return node
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
def previousNumber(node: TreeNode) -> int:
"""
previous number is the maximum of its left subtree(if not null), one left, other right
:param node:
:return:
"""
#node and node.left is not null
node = node.left
while node.right:
node = node.right
return node.val
def nextNumber(node: TreeNode) -> int:
"""
next number is the minimum of its right subtree(if not null), one right, other left
:param node:
:return:
"""
#node and node.right is not null
node = node.right
while node.left:
node = node.left
return node.val
if not root:
return root
if key < root.val:
root.left = self.deleteNode(root.left, key)
elif key > root.val:
root.right = self.deleteNode(root.right, key)
else: #key = root.val
"""
if not root.left and not root.right:
root = None
elif root.right:
root.val = nextNumber(root)
root.right = self.deleteNode(root.right, root.val)
else: #root.left
root.val = previousNumber(root)
root.left = self.deleteNode(root.left, root.val)
"""
if not root.left:
return root.right
elif not root.right:
return root.left
root.val = nextNumber(root)
root.right = self.deleteNode(root.right, root.val)
return root
def test():
s = INodeAllocator(None, 12)
root_n = TreeNode()
root_inode = s.add_inode(node=root_n)
assert s.get_by_node(root_n) is root_inode
assert s.get_by_value(12) is root_inode
assert root_inode.value == 12
ln1 = LeafNode(b'foo')
root_n.add_child(ln1)
child_n = TreeNode()
assert root_inode.refcnt == 1
child_inode = s.add_inode(node=child_n, leaf_node=ln1)
assert s.get_by_leaf_node(ln1) is child_inode
assert root_inode.refcnt == 2
assert child_inode.value == 13
assert not s.remove_old_inodes()
child_inode.deref()
assert child_inode.refcnt == 0
assert s.remove_old_inodes() == 1
assert s.count() == 1
# Test that 'None' inodes also work (=very leafy inodes)
ln2 = LeafNode(b'bar')
root_n.add_child(ln2)
child_inode2 = s.add_inode(node=None, leaf_node=ln2)
assert root_inode.refcnt == 2
child_inode2.deref()
assert s.remove_old_inodes() == 1
assert s.count() == 1
def backtracking(lower: int, upper: int) -> TreeNode:
if self.idx == n:
return None
val = preorder[self.idx]
if val < lower or val > upper: #not this sub tree
return None
node: TreeNode = TreeNode(val)
self.idx += 1
node.left = backtracking(lower, val)
node.right = backtracking(val, upper)
return node
def helper() -> TreeNode:
val, sign = 0, True
if s[self.index] == '-':
sign = False
self.index += 1
while self.index < len(s) and s[self.index].isdigit():
val = val * 10 + int(s[self.index])
self.index += 1
if not sign:
val = -val
node = TreeNode(val)
if self.index < len(s) and s[self.index] == '(':
self.index += 1
node.left = helper()
if self.index < len(s) and s[self.index] == '(':
self.index += 1
node.right = helper()
if self.index < len(s) and s[self.index] == ')':
self.index += 1
return node
def test_inodes_get_by_node_nonexistent():
s = INodeAllocator(None, 13)
with pytest.raises(KeyError):
s.get_by_node(TreeNode())
new_root.right = merge_tree(t1.right, t2.right)
return new_root
def invertTree(root):
if not root:
return root
root.left, root.right = root.right, root.left
invertTree(root.left)
invertTree(root.right)
return root
if __name__ == "__main__":
tree = TreeNode.InitTree().init_tree()
lc1 = LeetcodeSolution(112)
lc1.execute()
print(lc1.has_path_sum(tree, 30))
one_path = []
lc2 = LeetcodeSolution(129)
lc2.execute()
tree_ = CreateTree('49051').create_tree_by_list()
print(lc2.sum_numbers(tree_))
lc3 = LeetcodeSolution(236)
lc3.execute()
ancestor = lc3.lowest_common_ancestor(tree, tree.right.left.left,
tree.right.right)
def main():
print TreeNode(0, TreeNode(1, None, TreeNode(2)),
TreeNode(3, TreeNode(4), TreeNode(5, TreeNode(6))))
print TreeNode(0, TreeNode(1, TreeNode(5), TreeNode(6, TreeNode(7))),
TreeNode(2, TreeNode(3), TreeNode(4)))