: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)
