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)))