def constructMaximumBinaryTree(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
rootTreeNode = None
for num in nums:
if rootTreeNode == None:
rootTreeNode = TreeNode(num)
currentTreeNode = rootTreeNode
else:
parentTreeNode = None
currentTreeNode = rootTreeNode
while currentTreeNode != None:
if num > currentTreeNode.val:
if parentTreeNode == None:
newTreeNode = TreeNode(num)
newTreeNode.left = rootTreeNode
rootTreeNode = newTreeNode
else:
parentTreeNode.right = TreeNode(num)
parentTreeNode.right.left = currentTreeNode
break
else:
parentTreeNode = currentTreeNode
currentTreeNode = currentTreeNode.right
if currentTreeNode == None:
parentTreeNode.right = TreeNode(num)
return rootTreeNode
def generate_trees_2(self, n: int) -> List[TreeNode]:
"""
dp
:param n:
:return:
"""
def modify_tree(node: TreeNode, offset: int):
if offset == 0 or not node:
return
node.val += offset
modify_tree(node.left, offset)
modify_tree(node.right, offset)
# dp[i] stores the trees of n=i
if n == 0:
return []
dp = [[] for _ in range(n + 2)]
dp[0].append(None)
dp[1].append(TreeNode(1))
for i in range(2, n + 1):
for j in range(1, i + 1):
for left_tree in dp[j - 1]:
for right_tree in dp[i - j]:
root = TreeNode(j)
root.left = left_tree
new_right_tree = copy.deepcopy(right_tree)
modify_tree(new_right_tree, j)
root.right = new_right_tree
dp[i].append(root)
return dp[n]
def test(self):
solution = Solution()
treeNode1 = TreeNode(1)
treeNode1.right = TreeNode(3)
treeNode1.right.left = TreeNode(2)
self.assertEqual(solution.getMinimumDifference(treeNode1), 1)
def recover_from_preorder(self, s: str) -> TreeNode:
if not s:
return None
i = 0
while i < len(s) and s[i] != '-':
i += 1
root = TreeNode(s[:i])
store = [root]
cur_depth, pre_depth = 0, -1
while i < len(s):
if s[i] == '-':
cur_depth += 1
i += 1
else:
j = i + 1
while j < len(s) and s[j] != '-':
j += 1
val = s[i:j]
i = j
cur_node = TreeNode(val)
if cur_depth > pre_depth:
# cur node is the left sub node for the previous node
store[-1].left = cur_node
else:
# cur node is the right sibling for the previous node
while cur_depth <= pre_depth:
store.pop()
pre_depth -= 1
store[-1].right = cur_node
store.append(cur_node)
pre_depth = cur_depth
cur_depth = 0
return root
def addOneRow(self, root, v, d):
"""
:type root: TreeNode
:type v: int
:type d: int
:rtype: TreeNode
"""
if d == 1:
treeNode = TreeNode(v)
treeNode.left = root
return treeNode
elif d == 2:
left = root.left
right = root.right
root.left = TreeNode(v)
root.right = TreeNode(v)
root.left.left = left
root.right.right = right
return root
else:
if root.left:
self.addOneRow(root.left, v, d - 1)
if root.right:
self.addOneRow(root.right, v, d - 1)
return root
def list2tree(l: List[int]) -> Optional[TreeNode]:
if not l:
return None
root = TreeNode(int(l[0]))
node_queue = [root]
front = 0
index = 1
while index < len(l):
node = node_queue[front]
front = front + 1
item = l[index]
index = index + 1
if item is not None:
left_number = int(item)
node.left = TreeNode(left_number)
node_queue.append(node.left)
if index >= len(l):
break
item = l[index]
index = index + 1
if item is not None:
right_number = int(item)
node.right = TreeNode(right_number)
node_queue.append(node.right)
return root
def test(self):
solution = Solution()
treeNode1 = TreeNode(3)
treeNode1.left = TreeNode(9)
treeNode1.right = TreeNode(20)
treeNode1.right.left = TreeNode(15)
treeNode1.right.right = TreeNode(7)
self.assertEqual(solution.averageOfLevels(treeNode1), [3, 14.5, 11])
def test(self):
solution = Solution()
treeNode1 = TreeNode(4)
treeNode1.left = TreeNode(2)
treeNode1.right = TreeNode(6)
treeNode1.left.left = TreeNode(1)
treeNode1.left.right = TreeNode(3)
self.assertEqual(solution.minDiffInBST(treeNode1), 1)
def test(self):
solution = Solution()
tree1 = TreeNode(1)
tree1.left = TreeNode(0)
tree1.right = TreeNode(2)
tree1output = TreeNode(1)
tree1output.right = TreeNode(2)
self.assertEqual(
assertTreeNodeEqual(solution.trimBST(tree1, 1, 2), tree1output),
True)
def dfs(node: Optional[TreeNode]):
if node.val < val:
if not node.right:
node.right = TreeNode(val)
else:
dfs(node.right)
if node.val > val:
if not node.left:
node.left = TreeNode(val)
else:
dfs(node.left)
def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode:
if not root:
raise 'root is not defined'
if val >= root.val:
newRoot = TreeNode(val)
newRoot.left = root
return newRoot
if root.right:
root.right = self.insertIntoMaxTree(root.right, val)
return root
root.right = TreeNode(val)
return root
def increasing_bst2(self, root: TreeNode) -> TreeNode:
dummy = cur = TreeNode(-1)
stack = []
while root or stack:
if root:
stack.append(root)
root = root.left
else:
root = stack.pop()
cur.right = TreeNode(root.val)
cur = cur.right
root = root.right
return dummy.right
def backtrack(left: int, right: int) -> List[TreeNode]:
if left > right:
return [None]
if left == right:
return [TreeNode(left)]
trees = []
for i in range(left, right + 1):
for left_tree in backtrack(left, i - 1):
for right_tree in backtrack(i + 1, right):
root = TreeNode(i)
root.left = left_tree
root.right = right_tree
trees.append(root)
return trees
def test(self):
solution = Solution()
treeNode1 = TreeNode(3)
treeNode1.left = TreeNode(9)
treeNode1.right = TreeNode(20)
treeNode1.right.left = TreeNode(15)
treeNode1.right.right = TreeNode(7)
self.assertEqual(solution.sumOfLeftLeaves(treeNode1), 24)
treeNode2 = TreeNode(1)
treeNode2.left = TreeNode(2)
treeNode2.left.left = TreeNode(4)
treeNode2.left.right = TreeNode(5)
treeNode2.right = TreeNode(3)
self.assertEqual(solution.sumOfLeftLeaves(treeNode2), 4)
def generate_trees_1(self, n: int) -> List[TreeNode]:
"""
recursive
:param n:
:return:
"""
if n == 0:
return []
if n == 1:
return [TreeNode(1)]
def backtrack(left: int, right: int) -> List[TreeNode]:
if left > right:
return [None]
if left == right:
return [TreeNode(left)]
trees = []
for i in range(left, right + 1):
for left_tree in backtrack(left, i - 1):
for right_tree in backtrack(i + 1, right):
root = TreeNode(i)
root.left = left_tree
root.right = right_tree
trees.append(root)
return trees
return backtrack(1, n)
def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
if len(preorder) == 0:
return None
if len(preorder) == 1:
return TreeNode(preorder[0])
ans = TreeNode(preorder[0])
idx = 1
for i in range(1, len(preorder)):
idx = i
if preorder[i] > preorder[0]:
break
if preorder[idx] < preorder[0]:
idx += 1
ans.left = self.bstFromPreorder(preorder[1:idx])
ans.right = self.bstFromPreorder(preorder[idx:])
return ans
def invert_tree(self, root: TreeNode) -> TreeNode:
if not root:
return None
ans = TreeNode(root.val)
ans.left = self.invert_tree(root.right)
ans.right = self.invert_tree(root.left)
return ans
def backtrack(start: int, end: int) -> TreeNode:
"""
Recursively generate TreeNode by sub list of preorder.
:param start: the start index of sub list.
:param end: the end index of sub list.
:return: the generated TreeNode.
"""
val = preorder[start]
root = TreeNode(val)
if start == end:
return root
i = start + 1
split = -1
has_split = False
# find the split num of the sub list if it exists.
while i <= end:
if preorder[i] > val:
has_split = True
split = i
break
i += 1
if has_split:
if start + 1 <= split - 1:
# process the left children TreeNode
root.left = backtrack(start + 1, split - 1)
if split <= end:
# process the right children TreeNode
root.right = backtrack(split, end)
else:
if start + 1 <= end:
# process the left children TreeNode
root.left = backtrack(start + 1, end)
return root
def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode:
if root and val < root.val:
root.right = self.insertIntoMaxTree(root.right, val)
return root
newRoot = TreeNode(val)
newRoot.left = root
return newRoot
def recur(start: int, end: int) -> TreeNode:
if start > end:
return None
mid = start + (end - start) // 2
root = TreeNode(nums[mid])
root.left = recur(start, mid - 1)
root.right = recur(mid + 1, end)
return root
def sorted_list_to_bst_2(self, head: ListNode) -> TreeNode:
"""fast and slow pointer"""
if not head:
return None
if not head.next:
return TreeNode(head.val)
prev, p, q = None, head, head
while q and q.next:
prev = p
p = p.next
q = q.next.next
root = TreeNode(p.val)
right = p.next
prev.next = None
root.left = self.sorted_list_to_bst_2(head)
root.right = self.sorted_list_to_bst_2(right)
return root
def add_node(value, depth, store):
store[depth] = TreeNode(value)
if depth == 0:
return
if not store[depth - 1].left:
store[depth - 1].left = store[depth]
else:
store[depth - 1].right = store[depth]
def recur(start: int, end: int) -> TreeNode:
# [start, end)
if end == start:
return None
mid = (start + end) // 2
root = TreeNode(nums[mid])
root.left = recur(start, mid)
root.right = recur(mid + 1, end)
return root
def recur(node1: TreeNode, node2: TreeNode) -> TreeNode:
if not node1:
return node2
if not node2:
return node1
result = TreeNode(node1.val + node2.val)
result.left = recur(node1.left, node2.left)
result.right = recur(node1.right, node2.right)
return result
def increasing_bst(self, root: TreeNode) -> TreeNode:
def recursive_traversal(node: TreeNode) -> List[int]:
if not node:
return []
ret = []
ret += recursive_traversal(node.left)
ret.append(node.val)
ret += recursive_traversal(node.right)
return ret
if not root:
return root
seq = recursive_traversal(root)
dummy = cur = TreeNode(-1)
for val in seq:
cur.right = TreeNode(val)
cur = cur.right
return dummy.right
def constructFromPrePost(self, pre, post):
"""
:type pre: List[int]
:type post: List[int]
:rtype: TreeNode
"""
stack = [TreeNode(pre[0])]
j = 0
for v in pre[1:]:
node = TreeNode(v)
while stack[-1].val == post[j]:
stack.pop()
j += 1
if not stack[-1].left:
stack[-1].left = node
else:
stack[-1].right = node
stack.append(node)
return stack[0]
def construct_maximum_binary_tree(self, nums: List[int]) -> TreeNode:
if not nums:
return None
max_num = max(nums)
max_index = nums.index(max_num)
root = TreeNode(max(nums))
root.left = self.construct_maximum_binary_tree(nums[:max_index])
root.right = self.construct_maximum_binary_tree(nums[max_index + 1:])
return root
def build_tree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
root = TreeNode(postorder[-1])
pos = inorder.index(root.val)
l_inorder = inorder[:pos]
r_inorder = inorder[pos + 1:]
if l_inorder:
root.left = self.build_tree(l_inorder, postorder[:len(l_inorder)])
if r_inorder:
root.right = self.build_tree(
r_inorder, postorder[len(postorder) - len(r_inorder) - 1:-1])
return root
def build_tree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
root = TreeNode(preorder[0])
index = inorder.index(preorder[0])
left_tree_inorder = inorder[:index]
right_tree_inorder = inorder[index + 1:]
left_tree_preorder = preorder[1:index + 1]
right_tree_preorder = preorder[index + 1:]
root.left = self.build_tree(left_tree_preorder, left_tree_inorder)
root.right = self.build_tree(right_tree_preorder, right_tree_inorder)
return root
def deserialize(self, data: str) -> TreeNode:
nums = (data[1:len(data) - 1])
if nums == '':
return None
nums = nums.split(',')
ans = TreeNode(nums.pop(0))
queue = [ans]
i = 1
while nums:
node = queue.pop(0)
val = nums.pop(0)
if val != 'None':
node.left = TreeNode(val)
queue.append(node.left)
i += 1
if not nums:
break
val = nums.pop(0)
if val != 'None':
node.right = TreeNode(val)
queue.append(node.right)
return ans
