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)
