def helper(preIndex, postSt, postEnd):
if preIndex == len(pre):
return None
if postSt == postEnd:
return TreeNode(post[postEnd])
node = TreeNode(pre[preIndex])
if preIndex == len(pre) - 1:
return node
childNum = pre[preIndex + 1]
index = postSt
while index < postEnd:
if post[index] == childNum:
break
index += 1
if index == postEnd:
print("wrong!")
if index == postEnd - 1:
node.right = None
node.left = helper(preIndex + 1, postSt, postEnd - 1)
else:
node.left = helper(preIndex + 1, postSt, index)
node.right = helper(preIndex + 2 + index - postSt, index + 1,
postEnd - 1)
return node
def addOneRow(self, root, v, d):
"""
:type root: TreeNode
:type v: int
:type d: int
:rtype: TreeNode
"""
if d == 1:
newRoot = TreeNode(v)
newRoot.left = root
return newRoot
curRowNodes = [root]
while d != 2:
childNodes = []
for node in curRowNodes:
if node.left:
childNodes.append(node.left)
if node.right:
childNodes.append(node.right)
d -= 1
curRowNodes = childNodes
for node in curRowNodes:
left = TreeNode(v)
right = TreeNode(v)
left.left = node.left
right.right = node.right
node.left = left
node.right = right
return root
def allPossibleFBT(self, N):
"""
:type N: int
:rtype: List[TreeNode]
"""
results = []
if N <= 0 or N == 2:
return results
if N == 1:
results.append(TreeNode(0))
return results
if N == 3:
root = TreeNode(0)
root.left = TreeNode(0)
root.right = TreeNode(0)
results.append(root)
return results
n = N
for i in range(1, n // 2 + 1):
leftNodes = i
rightNodes = n - 1 - i
leftResult = self.allPossibleFBT(leftNodes)
if not leftResult:
continue
rightResult = self.allPossibleFBT(rightNodes)
if not rightResult:
continue
for left in leftResult:
for right in rightResult:
root = TreeNode(0)
root.left = left
root.right = right
results.append(root)
if leftNodes == rightNodes:
continue
root = TreeNode(0)
root.left = right
root.right = left
results.append(root)
return results
def dfs(left, right):
if left < 0 or left >= len(nums) or left > right:
return
index = left
maxIndex = left
while index <= right:
if nums[index] > nums[maxIndex]:
maxIndex = index
index += 1
node = TreeNode(nums[maxIndex])
node.left = dfs(left, maxIndex - 1)
node.right = dfs(maxIndex + 1, right)
return node
def flatten(self, root: TreeNode) -> None:
"""
Do not return anything, modify root in-place instead.
"""
if not root:
return
if root.right:
self.flatten(root.right)
if root.left:
self.flatten(root.left)
curNode = root.left
while curNode.right:
curNode = curNode.right
curNode.right = root.right
root.right = root.left
root.left = None
else:
if visitedNodeDict[curStr] == 1:
visitedNodeDict[curStr] = 2
results.append(node)
return curStr
dfs(root)
return results
if __name__ == '__main__':
root = TreeNode(1)
left = TreeNode(2)
right = TreeNode(3)
root.left = left
root.right = right
leftleft = TreeNode(4)
rightleft = TreeNode(2)
rightright = TreeNode(4)
left.left = leftleft
right.left = rightleft
right.right = rightright
rightleftleft = TreeNode(4)
rightleft.left = rightleftleft
result = Solution().findDuplicateSubtrees(root)
print(len(result))
for node in result:
print(node.val)
print('************')
root = TreeNode(0)
if right:
last = right[1]
root.right = right[0]
else:
last = root
return [first, last]
return helper(root)[0]
if __name__ == '__main__':
root = TreeNode(5)
left = TreeNode(3)
right = TreeNode(6)
root.left = left
root.right = right
leftleft = TreeNode(2)
leftright = TreeNode(4)
left.left = leftleft
left.right = leftright
leftleftleft = TreeNode(1)
leftleft.left = leftleftleft
rightright = TreeNode(8)
right.right = rightright
rightrightleft = TreeNode(7)
rightrightright = TreeNode(9)
rightright.left = rightrightleft
rightright.right = rightrightright
midOrder(root)
root = Solution().increasingBST(root)
midOrder(root)
rightResult[1], rightResult[2]), rightResult[0], rightResult[1]
leftResult = self.dfs(node.left)
rightResult = self.dfs(node.right)
return node.val + max(leftResult[1], leftResult[2]) + max(
rightResult[1],
rightResult[2]), max(leftResult[0], leftResult[1]) + max(
rightResult[0], rightResult[1]), leftResult[1] + rightResult[1]
if __name__ == '__main__':
root = TreeNode(3)
left = TreeNode(4)
right = TreeNode(5)
root.left = left
root.right = right
leftleft = TreeNode(1) ####
leftright = TreeNode(3)
rightright = TreeNode(1)
left.left = leftleft
left.right = leftright
right.right = rightright
print(Solution().rob(root))
root = TreeNode(3)
left = TreeNode(2)
right = TreeNode(3)
root.left = left
root.right = right
leftright = TreeNode(3)
left.right = leftright
:type root: TreeNode
:rtype: List[int]
"""
subTreeSum = {}
def dfs(node):
if not node:
return 0
leftSum = dfs(node.left)
rightSum = dfs(node.right)
curSum = node.val + leftSum + rightSum
if curSum not in subTreeSum:
subTreeSum[curSum] = 0
subTreeSum[curSum] += 1
return curSum
dfs(root)
mostFreqSum = 0
for _,freq in subTreeSum.items():
if freq > mostFreqSum:
mostFreqSum = freq
results = []
for subSum,freq in subTreeSum.items():
if freq == mostFreqSum:
results.append(subSum)
return results
if __name__ == '__main__':
root = TreeNode(5)
root.left = TreeNode(2)
root.right = TreeNode(-3)
print(Solution().findFrequentTreeSum(root))
if nodes and not nodet:
return False
if not nodes and nodet:
return False
if nodes.val != nodet.val:
return False
return self.helper(nodes.left, nodet.left) and self.helper(nodes.right, nodet.right)
if __name__ == '__main__':
s = TreeNode(3)
left = TreeNode(4)
right = TreeNode(5)
s.left = left
s.right = right
leftleft = TreeNode(1)
leftright = TreeNode(2)
left.left = leftleft
left.right = leftright
leftrightleft = TreeNode(0)
# leftright.left = leftrightleft
t = TreeNode(4)
t.left = TreeNode(1)
t.right = TreeNode(2)
print(Solution().isSubtree(s,t))
s = TreeNode(1)
s.left = TreeNode(1)
t = TreeNode(1)
print(Solution().isSubtree(s,t))
return self.seq
def _update_tree_vals(self, subtree):
if subtree.right:
self._update_tree_vals(subtree.right)
if subtree.left:
self.current_sum += subtree.val
subtree.val = self.current_sum
self._update_tree_vals(subtree.left)
print(self.current_sum, subtree.val)
# Defining the example 1 tree
# tree = TreeNode()._deserialize("[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]")
# Another way of defining the tree
tree = TreeNode(val=4)
tree.left = TreeNode(val=1)
tree.left.left = TreeNode(val=0)
tree.left.right = TreeNode(val=2)
tree.left.right.right = TreeNode(val=3)
tree.right = TreeNode(val=6)
tree.right.left = TreeNode(val=5)
tree.right.right = TreeNode(val=7)
tree.right.right.right = TreeNode(val=8)
print(tree.__repr__())
# print(tree.height)
# sol = Solution().bstToGst(root=tree)
if not t2:
return t1
t1.val = t1.val + t2.val
t1.left = self.mergeTrees(t1.left, t2.left)
t1.right = self.mergeTrees(t1.right, t2.right)
return t1
if __name__ == '__main__':
t1root = TreeNode(1)
t1left = TreeNode(3)
t1right = TreeNode(2)
t1root.left = t1left
t1root.right = t1right
t1leftleft = TreeNode(5)
t1left.left = t1leftleft
t2root = TreeNode(2)
t2left = TreeNode(1)
t2right = TreeNode(3)
t2root.left = t2left
t2root.right = t2right
t2leftright = TreeNode(4)
t2rightright = TreeNode(7)
t2left.right = t2leftright
t2right.right = t2rightright
t = Solution().mergeTrees(t1root, t2root)
midOrder(t)
