:rtype: int """ if not root: return 0 self.table = {0: 1} return self.recur(root, 0, sum) def recur(self, node, curr, sum): if not node: return 0 curr += node.val count = self.table.get(curr - sum, 0) self.table[curr] = self.table.get(curr, 0) + 1 count += self.recur(node.left, curr, sum) count += self.recur(node.right, curr, sum) self.table[curr] -= 1 return count if __name__ == "__main__": try: from utils.TreeNode import createTreeNode root = createTreeNode([10, 5, -3, 3, 2, None, 11, 3, -2, None, 1]) sol = Solution() print(sol.pathSum(root, 8) == 3) except Exception as e: print(e)
size = len(queue) for _ in range(size): node = queue.pop(0) if node.left: queue.append(node.left) if node.right: queue.append(node.right) layer += 1 for node in queue: t1 = node.left t2 = node.right node.left = TreeNode(v) node.right = TreeNode(v) node.left.left = t1 node.right.right = t2 return root if __name__ == "__main__": try: from utils.TreeNode import TreeNode, createTreeNode, printTreeNode sol = Solution() root = createTreeNode([4, 2, 6, 3, 1, 5]) printTreeNode(sol.addOneRow(root, 1, 2)) root = createTreeNode([4, 2, 6, 3, 1, 5]) printTreeNode(sol.addOneRow(root, 1, 1)) except Exception as e: print(e)
:type root: TreeNode :type sum: int :rtype: List[List[int]] """ if not root: return [] ans = [] stack = [(root, sum, [root.val])] while stack: node, sum, arr = stack.pop() if sum == node.val and not node.left and not node.right: ans.append(arr) sum -= node.val if node.left: stack += (node.left, sum, arr + [node.left.val]), if node.right: stack += (node.right, sum, arr + [node.right.val]), return ans if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1]) print(sol.pathSum(root, 22)) except Exception as e: print(e)
# self.val = x # self.left = None # self.right = None class Solution(object): def isSubtree(self, s, t): """ :type s: TreeNode :type t: TreeNode :rtype: bool """ def preorder(node): if not node: return "$" return "#" + str(node.val) + preorder(node.left) + preorder( node.right) return preorder(t) in preorder(s) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() s = createTreeNode([3, 4, 5, 1, 2]) t = createTreeNode([4, 1, 2]) print(sol.isSubtree(s, t) is True) except Exception as e: print(e)
class Solution(object): def findFrequentTreeSum(self, root): """ :type root: TreeNode :rtype: List[int] """ self.table = {} self.maxCount = 0 self.recur(root) return [val for val in self.table if self.table[val] == self.maxCount] def recur(self, node): if not node: return 0 val = node.val + self.recur(node.left) + self.recur(node.right) self.table[val] = self.table.get(val, 0) + 1 self.maxCount = max(self.maxCount, self.table[val]) return val if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([5, 2, -3]) print(sol.findFrequentTreeSum(root) == [2, -3, 4]) root = createTreeNode([5, 2, -5]) print(sol.findFrequentTreeSum(root) == [2]) except Exception as e: print(e)
:type root: TreeNode :rtype: int """ if not root: return 0 ans = 0 stack = [(root, False)] while stack: node, isLeft = stack.pop() if not node.left and not node.right and isLeft: ans += node.val if node.left: stack.append((node.left, True)) if node.right: stack.append((node.right, False)) return ans if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([3, 9, 20, None, None, 15, 7]) print(sol.sumOfLeftLeaves(root) == 24) root = createTreeNode([1]) print(sol.sumOfLeftLeaves(root) == 0) except Exception as e: print(e)
:rtype: void Do not return anything, modify root in-place instead. """ if not root: return self.arr = [] self.preorder(root) pre = TreeNode(0) for node in self.arr: pre.left = None pre.right = node pre = node # printTreeNode(root) def preorder(self, node): self.arr += node, if node.left: self.preorder(node.left) if node.right: self.preorder(node.right) if __name__ == "__main__": try: from utils.TreeNode import TreeNode, createTreeNode, printTreeNode sol = Solution() root = createTreeNode([1, 2, 4, 3]) sol.flatten(root) except Exception as e: print(e)
# def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def isSameTree(self, p, q): """ :type p: TreeNode :type q: TreeNode :rtype: bool """ if not p and not q: return True if not p or not q: return False return (p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root1 = createTreeNode([1, 2, 3]) root2 = createTreeNode([1, None, 2, 3]) print(sol.isSameTree(root1, root2)) except Exception as e: print(e)
:type root: TreeNode :rtype: List[float] """ if not root: return [] queue = [root] ans = [] while queue: size = len(queue) _sum = 0 for _ in range(size): node = queue.pop(0) _sum += node.val if node.left: queue.append(node.left) if node.right: queue.append(node.right) ans.append(_sum * 1.0 / size) return ans if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([3, 9, 20, 15, 7]) print(sol.averageOfLevels(root) == [3, 14.5, 11]) except Exception as e: print(e)
def binaryTreePaths(self, root): """ :type root: TreeNode :rtype: List[str] """ if not root: return [] self.ans = [] self.traverse(root, "") return self.ans def traverse(self, node, path): path += "->{}".format(node.val) if not node.left and not node.right: self.ans += path[2:], return if node.left: self.traverse(node.left, path) if node.right: self.traverse(node.right, path) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([1, 2, 3, None, 5]) print(sol.binaryTreePaths(root)) except Exception as e: print(e)
if not root: return 0 ans = 0 queue = [(1, root)] while queue: size = len(queue) left = right = None for _ in range(size): idx, node = queue.pop(0) if not left: left = right = idx else: right = idx if node.left: queue.append((idx * 2, node.left)) if node.right: queue.append((idx * 2 + 1, node.right)) ans = max(ans, right - left + 1) return ans if __name__ == "__main__": sol = Solution() try: from utils.TreeNode import createTreeNode root = createTreeNode([1, 3, 2, 5, 3, None, 9]) print(sol.widthOfBinaryTree(root) == 4) except Exception as e: print(e)
""" :type root: TreeNode :rtype: bool """ return self.check(root, float('-inf'), float('inf')) def check(self, node, minV, maxV): if not node: return True if node.val < minV or node.val > maxV: return False return (self.check(node.left, minV, node.val - 1) and self.check(node.right, node.val + 1, maxV)) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() print(sol.isValidBST(None)) # True root = createTreeNode([1, 1]) print(sol.isValidBST(root)) # False root = createTreeNode([1, None, 1]) print(sol.isValidBST(root)) # False root = createTreeNode([1, 2, 3]) print(sol.isValidBST(root)) # False root = createTreeNode([2, 1, 3]) print(sol.isValidBST(root)) # True except Exception as e: print(e)
# self.right = None class Solution(object): def convertBST(self, root): """ :type root: TreeNode :rtype: TreeNode """ self.val = 0 def inorder(node): if not node: return inorder(node.right) node.val = self.val = self.val + node.val inorder(node.left) inorder(root) return root if __name__ == "__main__": try: from utils.TreeNode import createTreeNode, printTreeNode sol = Solution() root = createTreeNode([5, 2, 13]) printTreeNode(sol.convertBST(root)) except Exception as e: print(e)
class Solution(object): def mergeTrees(self, t1, t2): """ :type t1: TreeNode :type t2: TreeNode :rtype: TreeNode """ if not t1: return t2 if not t2: return t1 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__": sol = Solution() try: from utils.TreeNode import createTreeNode, printTreeNode root1 = createTreeNode([1, 3, 2, 5]) root2 = createTreeNode([2, 1, 3, None, 4, None, 7]) printTreeNode(sol.mergeTrees(root1, root2)) except Exception as e: print(e)
# self.right = None class Solution(object): def preorderTraversal(self, root): """ :type root: TreeNode :rtype: List[int] """ self.ans = [] self.traverse(root) return self.ans def traverse(self, node): if not node: return self.ans += node.val, self.traverse(node.left) self.traverse(node.right) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() arr = [1, 2, 3, 4, 5, 6, 7] root = createTreeNode(arr) print(sol.preorderTraversal(root)) except Exception as e: print(e)
:type root: TreeNode :type key: int :rtype: TreeNode """ if not root: return None if root.val == key: if root.left: pre = root.left while pre.right: pre = pre.right pre.right = root.right return root.left return root.right elif root.val < key: root.right = self.deleteNode(root.right, key) else: root.left = self.deleteNode(root.left, key) return root if __name__ == "__main__": try: from utils.TreeNode import createTreeNode, printTreeNode sol = Solution() root = createTreeNode([5, 3, 6, 2, 4, None, 7]) printTreeNode(sol.deleteNode(root, 3)) except Exception as e: print(e)
stack = [] while root: stack.append(root) root = root.left while stack and count < k: node = stack.pop() count += 1 node = node.right while node: stack.append(node) node = node.left return stack[-1].val if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([4, 2, 6, 1, 3, 5, 7]) print(sol.kthSmallest(root, 1) == 1) print(sol.kthSmallest(root, 2) == 2) print(sol.kthSmallest(root, 3) == 3) print(sol.kthSmallest(root, 4) == 4) print(sol.kthSmallest(root, 5) == 5) except Exception as e: print(e)
if not node: return inorder(node.left) if node.val == self.val: self.count += 1 else: self.val, self.count = node.val, 1 if self.count == self.maxCount: self.mode += self.val, elif self.count > self.maxCount: self.mode = [self.val] self.maxCount = self.count inorder(node.right) inorder(root) return self.mode if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([1, None, 2, 2]) print(sol.findMode(root) == [2]) except Exception as e: print(e)
# self.left = None # self.right = None class Solution(object): def tree2str(self, t): """ :type t: TreeNode :rtype: str """ if not t: return "" if t.right: return "{}({})({})".format(t.val, self.tree2str(t.left), self.tree2str(t.right)) elif t.left: return "{}({})".format(t.val, self.tree2str(t.left)) return str(t.val) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([1, 2, 3, None, 4]) print(sol.tree2str(root) == "1(2()(4))(3)") root = createTreeNode([1, 2, 3, 4]) print(sol.tree2str(root) == "1(2(4))(3)") except Exception as e: print(e)
size2 = len(stack2) if size1 != size2: return False for _ in range(size1): node1 = stack1.pop() node2 = stack2.pop() if not node1 and not node2: continue if not node1 or not node2: return False if node1.val != node2.val: return False stack1 += [node1.left, node1.right] stack2 += [node2.right, node2.left] return not stack1 or not stack2 if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([1, 2, 2, 3, 4, 4, 3]) # True print(sol.isSymmetric(root)) root = createTreeNode([1, 2, 2, None, 3, None, 3]) # False print(sol.isSymmetric(root)) root = createTreeNode([1, 2, 3, 3, None, 2, None]) # False print(sol.isSymmetric(root)) root = createTreeNode([5, 4, 1, None, 1, None, 4, 2, None, 2, None]) # False print(sol.isSymmetric(root)) except Exception as e: print(e)
class Solution(object): def invertTree(self, root): """ :type root: TreeNode :rtype: TreeNode """ if not root: return stack = [root] while stack: node = stack.pop() node.left, node.right = node.right, node.left if node.left: stack.append(node.left) if node.right: stack.append(node.right) return root if __name__ == "__main__": try: from utils.TreeNode import createTreeNode, printTreeNode sol = Solution() root = createTreeNode([4, 2, 7, 1, 3, 6, 9]) printTreeNode(sol.invertTree(root)) except Exception as e: print(e)
def isBalanced(self, root): """ :type root: TreeNode :rtype: bool """ if not root: return True return self.check(root) >= 0 def check(self, node): if not node: return 0 depth_left = self.check(node.left) depth_right = self.check(node.right) if depth_left < 0 or depth_right < 0 or abs(depth_left - depth_right) > 1: return -1 return 1 + max(depth_left, depth_right) if __name__ == "__main__": try: from utils.TreeNode import createTreeNode sol = Solution() root = createTreeNode([1, 2, 3]) print(sol.isBalanced(root)) root = createTreeNode([1, None, 2, None, 3]) print(sol.isBalanced(root)) except Exception as e: print(e)
:rtype: void Do not return anything, modify root in-place instead. """ self.prev = TreeNode(float('-inf')) self.res = [None, None] self.inorder(root) self.res[0].val, self.res[1].val = self.res[1].val, self.res[0].val # printTreeNode(root) def inorder(self, node): if not node: return self.inorder(node.left) if self.prev.val > node.val: if not self.res[0]: self.res[0] = self.prev self.res[1] = node self.prev = node self.inorder(node.right) if __name__ == "__main__": try: from utils.TreeNode import TreeNode, createTreeNode, printTreeNode sol = Solution() root = createTreeNode([2, 3, 1]) sol.recoverTree(root) except Exception as e: print(e)
class Solution(object): def lowestCommonAncestor(self, root, p, q): """ :type root: TreeNode :type p: TreeNode :type q: TreeNode :rtype: TreeNode """ if p.val < root.val < q.val: return root elif root.val < p.val and root.val < q.val: return self.lowestCommonAncestor(root.right, p, q) elif root.val > p.val and root.val > q.val: return self.lowestCommonAncestor(root.left, p, q) return root if __name__ == "__main__": try: from utils.TreeNode import createTreeNode, TreeNode sol = Solution() root = createTreeNode([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5]) print( sol.lowestCommonAncestor(root, TreeNode(3), TreeNode(5)).val == 4) print( sol.lowestCommonAncestor(root, TreeNode(0), TreeNode(5)).val == 2) print( sol.lowestCommonAncestor(root, TreeNode(2), TreeNode(8)).val == 6) except Exception as e: print(e)