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 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 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 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 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(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 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 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 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 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 flatten(self, root: TreeNode) -> None: if root is None: return numList = [] self.preOrder(root, numList) root.val = numList[0] root.left = None cur = root for i in range(1, len(numList)): cur.right = TreeNode(numList[i]) cur = cur.right
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
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()
# return False # 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)
node = 0 level = 0 while not q.empty(): while cur: tmpNode = q.get() cur -= 1 if tmpNode.left: node += 1 q.put(tmpNode.left) if tmpNode.right: node += 1 q.put(tmpNode.right) level += 1 cur = node node = 0 return level if __name__ == '__main__': root = TreeNode(3) left = TreeNode(4) right = TreeNode(5) root.left = left root.right = right print(tree_depth(root)) print(tree_depth2(root))
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))
totalPath += countPathWithSumFromNode(node.right, target, runningSum, 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
curr_sum = sums[curr] 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()
if node.left is None: 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)