def make_example():
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
return root
def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode:
if root is None or root is not None and root.val < val:
node = TreeNode(val)
node.left = root
return node
root.right = self.insertIntoMaxTree(root.right, val)
return root
def make_example_2():
root = TreeNode(5)
root.left = TreeNode(1)
root.right = TreeNode(4)
root.right.left = TreeNode(3)
root.right.right = TreeNode(6)
return root
def make_example_1():
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right.left = TreeNode(4)
root.right.right = TreeNode(3)
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if nums:
nums_left, middle, nums_right = nums[:len(nums) //
2], nums[len(nums) //
2], nums[len(nums) //
2 + 1:]
tree = TreeNode(middle)
tree.left = self.sortedArrayToBST(nums_left)
tree.right = self.sortedArrayToBST(nums_right)
return tree
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
length = len(nums)
if length == 0:
return None
else:
idx = length // 2
node = TreeNode(nums[idx])
node.left = self.sortedArrayToBST(nums[:idx])
node.right = self.sortedArrayToBST(nums[idx + 1:])
return node
def generate_tree_with_range(start, end):
if start > end:
return [None]
result = []
for index in range(start, end + 1):
for left_tree in generate_tree_with_range(start, index - 1):
for right_tree in generate_tree_with_range(index + 1, end):
this_node = TreeNode(index)
this_node.left, this_node.right = left_tree, right_tree
result.append(this_node)
return result
def construct_tree(nums, left, right):
if left >= right:
return None
max_i = left
for index in range(left + 1, right):
if nums[index] > nums[max_i]:
max_i = index
node = TreeNode(nums[max_i])
node.left = construct_tree(nums, left, max_i)
node.right = construct_tree(nums, max_i + 1, right)
return node
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if nums is None or len(nums) == 0:
return None
mid_index = len(nums) >> 1
node = TreeNode(nums[mid_index])
node.left = self.sortedArrayToBST(nums[:mid_index])
node.right = self.sortedArrayToBST(nums[mid_index + 1:])
return node
def sortedArrayToBST(self, num):
if not num:
return None
if len(num) % 2 == 0:
mid = len(num)/2 - 1
else:
mid = (len(num)+1)/2 - 1
root = TreeNode(num[mid])
root.left = self.sortedArrayToBST(num[:mid])
root.right = self.sortedArrayToBST(num[mid+1:])
return root
def sortedListToBST(self, head: ListNode) -> TreeNode:
if not head:
return None
elif not head.next:
return TreeNode(head.val)
else:
slow = fast = head
pre = None
while fast and fast.next:
pre = slow
slow = slow.next
fast = fast.next.next
node = TreeNode(slow.val)
pre.next = None
node.left = self.sortedListToBST(head)
node.right = self.sortedListToBST(slow.next)
return node
def buildTree(self, inorder, postorder):
"""
:type inorder: List[int]
:type postorder: List[int]
:rtype: TreeNode
"""
def find(l, v):
for index, ele in enumerate(l):
if ele == v:
return index
return -1
if len(postorder) == 0 or len(inorder) == 0:
return None
node = TreeNode(postorder[-1])
index = find(inorder, postorder[-1])
node.left = self.buildTree(inorder[:index], postorder[:index])
node.right = self.buildTree(inorder[index + 1:], postorder[index:-1])
return node
sums.append(self.dfsSum(root.left, root.val))
if root.right != None:
sums.append(self.dfsSum(root.right, root.val))
return sum(sums)
def dfsSum(self, root, cursum):
ret = []
cursum = cursum * 10 + root.val
if not root.left and not root.right:
return cursum
if root.left != None and root.right != None:
return self.dfsSum(root.left, cursum) + self.dfsSum(root.right, cursum)
if root.left != None and not root.right:
return self.dfsSum(root.left, cursum)
if root.right != None and not root.left:
return self.dfsSum(root.right, cursum)
sol = Solution()
t = TreeNode(8)
t.left = TreeNode(3)
t.right = TreeNode(5)
t.left.right = TreeNode(9)
t.left.right.left = TreeNode(9)
t.left.right.right = TreeNode(5)
print sol.sumNumbers(t)
# @param q, a tree node
# @return a boolean
def isSameTree(self, p, q):
if not bool(p):
if not bool(q):
return True
else:
return False
if not bool(q):
if not bool(p):
return True
else:
return False
if p.val == q.val:
return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
else:
return False
sol = Solution()
print sol.isSameTree({}, {0})
pTree = TreeNode(2)
pTree.left = TreeNode(1)
pTree.right = TreeNode(3)
qTree = TreeNode(2)
qTree.left = TreeNode(1)
qTree.right = TreeNode(3)
print sol.isSameTree(pTree, qTree)
# @param root, a tree node
# @return an integer
def maxDepth(self, root):
if not bool(root):
return 0
if root.left == None:
if root.right == None:
return 1
else:
return 1 + self.maxDepth(root.right)
elif root.right == None:
if root.left == None:
return 1
else:
return 1 + self.maxDepth(root.left)
else:
return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
testRoot = TreeNode(5)
testRoot.left = TreeNode(3)
testRoot.right = TreeNode(8)
testRoot.left.left = TreeNode(2)
testRoot.left.right = TreeNode(4)
testRoot.right.left = TreeNode(7)
testRoot.right.left.left = TreeNode(6)
sol = Solution()
print sol.maxDepth(testRoot)
print sol.maxDepth({})
