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)