def sorted_array_to_bst(self, nums): """ Converted an array of nums into a tree. Args: nums -- An array of nums sorted in ascending order. Returns: TreeNode """ # Time: O(n) where n is the number of items in the list. # Space: O(1) if not nums: return None n = len(nums) if n % 2 == 0: mid = int(n / 2) - 1 else: mid = int(n / 2) node = TreeNode(nums[mid]) node.left = self.sorted_array_to_bst(nums[:mid]) node.right = self.sorted_array_to_bst(nums[mid + 1:]) return node
def buildTree(self, preorder: list, inorder: list) -> TreeNode: if preorder: root = TreeNode(preorder[0]) mid = inorder.index(preorder[0]) root.left = self.buildTree(preorder[1:mid+1], inorder[0:mid]) root.right = self.buildTree(preorder[mid+1:len(preorder)], inorder[mid+1:len(inorder)]) return root
def rebuild_tree(pre_order, in_order, length): """ 根据前序遍历和中序遍历重建二叉树 所构建的二叉树是否唯一?参考:https://www.cnblogs.com/jiaxin359/p/9512348.html :param pre_order: :param in_order: :param length: :return: """ if len(pre_order) == 0 or len(in_order) == 0 or length <= 0: return None i = 0 tn = pre_order[0] root = TreeNode(tn) while i < length and in_order[i] != tn: i += 1 if i == length: return None root.left = rebuild_tree(pre_order[1:], in_order, i) root.right = rebuild_tree(pre_order[i + 1:], in_order[i + 1:], length - i - 1) return root
def invertTree(self, root: TreeNode) -> TreeNode: if root: right = root.right left = root.left root.right = self.invertTree(left) root.left = self.invertTree(right) return root
def create(nums: list) -> TreeNode: if not nums: return node = TreeNode(nums[len(nums) // 2]) node.left = create(nums[:len(nums) // 2]) node.right = create(nums[len(nums) // 2 + 1:]) return node
def invertTree(self, root: TreeNode) -> TreeNode: if root: left = self.invertTree(root.right) right = self.invertTree(root.left) root.left = left root.right = right return root
def main(): root = TreeNode(12) root.left = TreeNode(7) root.right = TreeNode(1) root.left.left = TreeNode(4) root.right.left = TreeNode(10) root.right.right = TreeNode(5) print("Tree has paths: " + str(count_paths(root, 11)))
def buildTree(self, inorder: list, postorder: list) -> TreeNode: if inorder: root = TreeNode(postorder[len(postorder) - 1]) mid = inorder.index(postorder[len(postorder) - 1]) root.left = self.buildTree(inorder[0:mid], postorder[0:mid]) root.right = self.buildTree(inorder[mid + 1:len(inorder)], postorder[mid:len(inorder) - 1]) return root
def helper(start, end): if start > end: return None mid = start + (end - start) // 2 root = TreeNode(A[mid]) root.left = helper(start, mid - 1) root.right = helper(mid + 1, end) return root
def insert(root: TreeNode, val: int) -> TreeNode: if not root: return TreeNode(val) elif val < root: root.left = insert(root.left, val) else: root.right = insert(root.right, val) return root
def main(): root = TreeNode(1) root.left = TreeNode(0) root.right = TreeNode(1) root.left.left = TreeNode(1) root.right.left = TreeNode(6) root.right.right = TreeNode(5) print("Total Sum of Path Numbers: " + str(find_sum_of_path_numbers(root)))
def main(): root = TreeNode(12) root.left = TreeNode(7) root.right = TreeNode(1) root.left.left = TreeNode(9) root.right.left = TreeNode(10) root.right.right = TreeNode(5) print("Tree has path: " + str(has_path(root, 23))) print("Tree has path: " + str(has_path(root, 16)))
def buildBST(nums: List[int], lb: int, ub: int) -> TreeNode: if lb > ub: return None mid = (lb + ub) >> 1 node = TreeNode(nums[mid]) node.left = buildBST(nums, lb, mid - 1) node.right = buildBST(nums, mid + 1, ub) return node
def main(): root = TreeNode(1) root.left = TreeNode(0) root.right = TreeNode(1) root.left.left = TreeNode(1) root.right.left = TreeNode(6) root.right.right = TreeNode(5) print("Tree has path sequence: " + str(find_path(root, [1, 0, 7]))) print("Tree has path sequence: " + str(find_path(root, [1, 1, 6])))
def main(): root = TreeNode(12) root.left = TreeNode(7) root.right = TreeNode(1) root.left.left = TreeNode(4) root.right.left = TreeNode(10) root.right.right = TreeNode(5) sum = 23 print("Tree paths with sum " + str(sum) + ": " + str(find_paths(root, sum)))
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode: if not t1: return t2 elif not t2: return t1 t = TreeNode(t1.val + t2.val) t.left = self.mergeTrees(t1.left, t2.left) t.right = self.mergeTrees(t1.right, t2.right) return t
def sortedListToBST(self, head: ListNode) -> TreeNode: if not head: return None mid = self.getMidNode(head) root = TreeNode(mid.val) if head == mid: return root root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(mid.next) return root
def createMinimalBst(arr, start, end): if end < start: return None mid = (start+end)/2 print "Mid:", mid, arr[mid] n = TreeNode(arr[mid]) n.left = createMinimalBst(arr, start, mid-1) n.right = createMinimalBst(arr, mid+1, end) print "left, mid, right", n.left, n, n.right return n
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode: if not inorder: return None l = len(inorder) root = TreeNode(postorder[-1]) # 找到root在inorder的位置 ri = inorder.index(root.val) root.left = self.buildTree(inorder[0:ri], postorder[0:ri]) root.right = self.buildTree(inorder[ri+1:], postorder[ri:l-1]) return root
def flatten1(self, root: TreeNode) -> None: if root is None: return left = root.left right = root.right root.left = None self.flatten(left) self.flatten(right) root.right = left cur = root while cur.right: cur = cur.right cur.right = right
def generateTree(self, start, end): nodeList = [] if start > end: nodeList.append(None) else: for i in range(start, end + 1): leftTree = self.generateTree(start, i - 1) rightTree = self.generateTree(i + 1, end) for leftRoot in leftTree: for rightRoot in rightTree: root = TreeNode(i) root.left = leftRoot root.right = rightRoot nodeList.append(root) return nodeList
def main(): treeDiameter = TreeDiameter() root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.right.left = TreeNode(5) root.right.right = TreeNode(6) print("Tree Diameter: " + str(treeDiameter.find_diameter(root))) root.left.left = None root.right.left.left = TreeNode(7) root.right.left.right = TreeNode(8) root.right.right.left = TreeNode(9) root.right.left.right.left = TreeNode(10) root.right.right.left.left = TreeNode(11) print("Tree Diameter: " + str(treeDiameter.find_diameter(root)))
def buildBST(lb: int, ub: int) -> TreeNode: ''' 按中序遍历节点列表构造数 ''' if lb > ub: return None mid = (lb + ub) >> 1 left = buildBST(lb, mid - 1) nonlocal head node = TreeNode(head.val) head = head.next right = buildBST(mid + 1, ub) node.left = left node.right = right return node
def generateSearchTrees(lb: int, ub: int) -> List[TreeNode]: ''' [lb, ub] : 生成搜索树节点范围闭区间 ''' trees = [] if lb > ub: trees.append(None) elif lb == ub: trees.append(TreeNode(lb)) else: for r in range(lb, ub + 1): leftSubTrees = generateSearchTrees(lb, r - 1) rightSubTrees = generateSearchTrees(r + 1, ub) for leftSubTree in leftSubTrees: for rightSubTree in rightSubTrees: root = TreeNode(r) root.left = leftSubTree root.right = rightSubTree trees.append(root) return trees
if curr.left: sums[curr.left] = curr_sum + curr.left.val queue.append(curr.left) maxSum = max(maxSum, sums[curr.left]) if curr.right: sums[curr.right] = curr_sum + curr.right.val queue.append(curr.right) maxSum = max(maxSum, sums[curr.right]) del(sums[curr]) return maxSum root = TreeNode(1) root.left = TreeNode(2) root.left.left = TreeNode(3) root.left.right = TreeNode(4) root.left.right.left = TreeNode(10) root.left.right.right = TreeNode(7) root.left.left.left = TreeNode(9) root.left.left.right = TreeNode(8) root.right = TreeNode(5) root.right.right = TreeNode(6) print root.print_tree(root) print '----------------' s = Solution() print s.maxPathSum(root)
print(treeNode, end='') if treeNode.right: self.simetric_traversal(treeNode.right) print(')', end='') if __name__ == '__main__': tree = BinaryTree() n1 = TreeNode('a') n2 = TreeNode('+') n3 = TreeNode('*') n4 = TreeNode('b') n5 = TreeNode('-') n6 = TreeNode('/') n7 = TreeNode('c') n8 = TreeNode('d') n9 = TreeNode('e') n6.left = n7 n6.right = n8 n5.left = n6 n5.right = n9 n3.left = n4 n3.right = n5 n2.left = n1 n2.right = n3 tree.root = n2 tree.simetric_traversal() print()
# lnode = lnode.right # return self.isValidBST(root.left) # while lnode: # if lnode.val >= root.val: # return False # lnode = lnode.right # while rnode: # if rnode.val <= root.val: # return False # rnode = rnode.left # return self.isValidBST(root.left) and self.isValidBST(root.right) import sys test = TreeNode(4) test.left = TreeNode(2) test.right = TreeNode(6) test.left.left = TreeNode(1) test.left.right = TreeNode(3) test.right.left = TreeNode(5) test.right.right = TreeNode(7) def inordtrv(arr: list, root: TreeNode): # root = self if not root: return inordtrv(arr, root.left) arr.append(root.val) inordtrv(arr, root.right)
r = find_arrays_from_bst(node.right) elif node.right is None: r = find_arrays_from_bst(node.left) else: for left_arr in find_arrays_from_bst(node.left): for right_arr in find_arrays_from_bst(node.right): r.extend(permute_with_partial_ordering(left_arr, right_arr)) res = [] for item in r: item.insert(0, node.val) res.append(item) return res root = TreeNode(2) root.left = TreeNode(1) root.right = TreeNode(3) root.right.right = TreeNode(10) root = TreeNode(12) root.left = TreeNode(10) root.right = TreeNode(14) root.left.left = TreeNode(9) root.left.right = TreeNode(11) root.right.left = TreeNode(13) root.right.left.right = TreeNode(13.5) root.right.right = TreeNode(16) root.right.right.right = TreeNode(17) root.right.right.right.right = TreeNode(19) root = TreeNode(10) for i in [100, 5, 500]:
root.val = (root.val, x, y) if root.left: self.set_pos(root.left, x - 1, y - 1) if root.right: self.set_pos(root.right, x + 1, y - 1) def print_node(self, root): # if not root: # return self.res.append(root.val) if root.left: self.print_node(root.left) if root.right: self.print_node(root.right) root = TreeNode(3) root.left = TreeNode(9) tr = TreeNode(20) tr.left = TreeNode(15) tr.right = TreeNode(7) root.right = tr a = Solution() print(a.verticalTraversal(root))
return res def inorderTraversalIterative(self, root: TreeNode): stack = [] res = [] cur = root while cur or stack: while cur: stack.append(cur) cur = cur.left cur = stack.pop() res.append(cur.val) cur = cur.right return res def traverse(self, res: list, p: TreeNode): if p != None: self.traverse(res, p.left) res.append(p.val) self.traverse(res, p.right) if __name__ == '__main__': root = TreeNode(3) root.left = TreeNode(1) root.left.right = TreeNode(2) root.right = TreeNode(5) root.right.left = TreeNode(4) root.right.right = TreeNode(6) print(Solution().inorderTraversalIterative(root))
pathDict) incrementHashTable(pathDict, runningSum, -1) print 'After:', node.name, pathDict, totalPath return totalPath # Input n3 = TreeNode(3) n_2 = TreeNode(-2) n1 = TreeNode(1) n3_1 = TreeNode(3) n3_1.left = n3 n3_1.right = n_2 n2 = TreeNode(2) n2.right = n1 n11 = TreeNode(11) n5 = TreeNode(5) n5.left = n3_1 n5.right = n2 n_3 = TreeNode(-3) n_3.right = n11 root = TreeNode(10) root.left = n5 root.right = n_3 rs = countPathWithSum(root, 8)
return left right = common_ancestor(root.right, n1, n2) # right contains both n1 and n2 but is not rooted at either if right is not None and right is not n1 and right is not n2: return right # left and right are both non-null, ie common ancestor found if left is not None and right is not None: return root # either left is null or right is null, but root is n1 or n2, so # common ancestor is the root if root is n1 or root is n2: return root # either left is null or right is null, so the non-null subtree contains # both n1 and n2, return the non-null one if left is not None: return left return right root = TreeNode(10) root.left = TreeNode(20) root.right = TreeNode(30) root.right.left = TreeNode(210) root.right.right = TreeNode(40) print find_ancestor(root, root.right.left, root.right.right) print common_ancestor(root, root.left, root.right.right)
#! usr/bin/python3 from treenode import TreeNode def maxDepth(root: TreeNode) -> int: if not root: return 0 if not root.left and not root.right: return 1 else: return max(maxDepth(root.left), maxDepth(root.right)) + 1 t = TreeNode(1) t.right = TreeNode(2) print(maxDepth(t))