right = maxDepth(root.right)
if left < 0 or right < 0 or abs(left - right) > 1:
return -1
return max(left, right) + 1
h = maxDepth(root)
return h >= 0
def isBalanced(root: 'TreeNode') -> bool:
def maxDepth(root):
if not root:
return 0
return max(maxDepth(root.left), maxDepth(root.right)) + 1
if not root:
return True
left = maxDepth(root.left)
right = maxDepth(root.right)
return abs(left - right) <= 1 and isBalanced(root.left) and isBalanced(
root.right)
root1 = lstToTreeNode([3, 9, 20, None, None, 15, 7])
root2 = lstToTreeNode([1, 2, 2, 3, 3, None, None, 4, 4])
root3 = lstToTreeNode([1, 2, 2, 3, None, None, 3, 4, None, None, 4])
# print(isBalanced(root1))
# print(isBalanced(root2))
print(isBalanced(root3))
def isSameTree1(p, q):
if not p and not q:
return True
if (p and not q) or (not p and q):
return False
return p.val == q.val and isSameTree(p.left, q.left) and isSameTree(
p.right, q.right)
def isSameTree(p, q):
stack = [(p, q)]
while stack:
r1, r2 = stack.pop()
if (r1 and not r2) or (not r1 and r2) or (r1 and r2
and r1.val != r2.val):
return False
if r1 and r2:
stack.append((r1.left, r2.left))
stack.append((r1.right, r2.right))
return True
r1 = lstToTreeNode([1, 2])
r2 = lstToTreeNode([1, None, 2])
r3 = lstToTreeNode([1, 2, 3])
r4 = lstToTreeNode([1, 2, 3])
print(isSameTree(r1, r2))
print(isSameTree(r3, r4))
# 1 2
# / \ / \
# 3 2 1 3
# / \ \
# 5 4 7
# Output:
# Merged tree:
# 3
# / \
# 4 5
# / \ \
# 5 4 7
from leetcode.tree import TreeNode, lstToTreeNode, treeNodeToLst
def mergeTrees(t1: TreeNode, t2: TreeNode) -> TreeNode:
if t1 is None or t2 is None:
return t1 or t2
t1.val += t2.val
t1.left = mergeTrees(t1.left, t2.left)
t1.right = mergeTrees(t1.right, t2.right)
return t1
root = mergeTrees(lstToTreeNode([1, 3, 2, 5]),
lstToTreeNode([2, 1, 3, None, 4, None, 7]))
print(root)
print(treeNodeToLst(root))
import collections
from leetcode.tree import lstToTreeNode
def maxDepth(root: 'TreeNode') -> int:
if not root:
return 0
return max(maxDepth(root.left), maxDepth(root.right)) + 1
def maxDepth2(root: 'TreeNode') -> int:
if not root:
return 0
dq = collections.deque([root])
depth = 0
while dq:
n = len(dq)
for i in range(n):
node = dq.popleft()
if node.left:
dq.append(node.left)
if node.right:
dq.append(node.right)
depth += 1
return depth
root = lstToTreeNode([3, 9, 20, None, None, 15, 7])
print(maxDepth(root))
print(maxDepth2(root))
cache = {}
return search(root, True)
# def rob(self, root):
# """
# :type root: TreeNode
# :rtype: int
# """
# def robSub(root):
# if not root:
# return [0, 0]
#
# left = robSub(root.left);
# right = robSub(root.right);
# res = [0, 0]
#
# res[0] = max(left[0], left[1]) + max(right[0], right[1])
# res[1] = root.val + left[0] + right[0] # left[0] 表示left节点没有被rob，left[1] 表示left节点被rob
# return res
#
# res = robSub(root)
# return max(res[0], res[1])
# lst = [53, 2, 3, 4, 3, 1, None, 67]
lst = [3, 2, 3, None, 3, None, 1]
lst2 = [3, 4, 5, 1, 3, None, 1]
tree = lstToTreeNode(lst2)
print(rob(tree))
# 5
# \
# 6
from leetcode.tree import lstToTreeNode, treeNodeToLst
# from leetcode.listnode import link2Lst
class Solution:
def __init__(self):
self.prev = None
def flatten(self, root: 'TreeNode') -> None:
"""
Do not return anything, modify root in-place instead.
"""
if not root:
return
self.flatten(root.right)
self.flatten(root.left)
root.right = self.prev
root.left = None
self.prev = root
s = Solution()
root = lstToTreeNode([1, 2, 5, 3, 4, None, 6])
s.flatten(root)
print(treeNodeToLst(root))
# print("ok")
# not success
def hasPathSum(root: 'TreeNode', n: int) -> bool:
if root is None:
return False
if root.left is None and root.right is None and root.val == n:
return True
return hasPathSum(root.left, n - root.val) or hasPathSum(root.right, n - root.val)
def hasPathSum1(root: 'TreeNode', n: int) -> bool:
if not root:
return False
stack = [(root, n)]
while stack:
r, s = stack.pop()
if r.left is None and r.right is None and r.val == s:
return True
if r.left:
stack.append((r.left, s - r.val))
if r.right:
stack.append((r.right, s - r.val))
return False
# root1 = lstToTreeNode([5,4,8,11,None,13,4,7,2,None,None,None,1])
root = lstToTreeNode([5,4,8,None,11])
print(hasPathSum1(root, 9))
print(treeNodeToLst(root))
def preorderTraversal2(root: 'TreeNode') -> 'List[int]':
result = []
stack = []
cur = root
while cur or stack:
while cur:
result.append(cur.val)
stack.append(cur)
cur = cur.left
cur = stack.pop()
cur = cur.right
return result
def preorderTraversal3(root: 'TreeNode') -> 'List[int]':
result = []
stack = [root]
while stack:
cur = stack.pop()
if cur:
result.append(cur.val)
stack.append(cur.right)
stack.append(cur.left)
return result
root = lstToTreeNode([1, None, 2, 3])
print(preorderTraversal(root))
print(preorderTraversal2(root))
print(preorderTraversal3(root))
def isSymmetric2(root: 'TreeNode') -> bool:
def isMirror(p, q):
if p is None and q is None:
return True
if p is None or q is None:
return False
return p.val == q.val and isMirror(p.left, q.right) and isMirror(
p.right, q.left)
return isMirror(root, root)
def isSymmetric(root: 'TreeNode') -> bool:
stack = [(root, root)]
while stack:
r1, r2 = stack.pop()
if (r1 and not r2) or (not r1 and r2) or (r1 and r2
and r1.val != r2.val):
return False
if r1 and r2:
stack.append((r1.left, r2.right))
stack.append((r1.right, r2.left))
return True
r1 = lstToTreeNode([1, 2, 2, 3, 4, 4, 3])
print(isSymmetric(r1))
r2 = lstToTreeNode([1, 2, 2, None, 3, None, 3])
print(isSymmetric(r2))
if cur:
if visited:
result.append(cur.val)
else:
stack.append((cur, True))
stack.append((cur.right, False))
stack.append((cur.left, False))
return result
# The 3rd uses modified preorder (right subtree first). Then reverse the result.
def postorderTraversal3(root: 'TreeNode') -> 'List[int]':
result = []
stack = [root]
while stack:
cur = stack.pop()
if cur:
result.append(cur.val)
stack.append(cur.left)
stack.append(cur.right)
return result[::-1]
root = lstToTreeNode([1, 2, 3, None, None, 4])
print(postorderTraversal(root))
print(postorderTraversal2(root))
print(postorderTraversal3(root))
import numpy as np
import matplotlib.pyplot as plt
# limits if they are available. Then one repeats the same step recursively for left and right subtrees.
from leetcode.tree import lstToTreeNode
def isValidBST(root: 'TreeNode') -> bool:
if root is None:
return True
def isValid(node, lo, hi):
if lo is not None and node.val <= lo:
return False
if hi is not None and node.val >= hi:
return False
left = isValid(node.left, lo, node.val) if node.left else True
if left:
right = isValid(node.right, node.val, hi) if node.right else True
return right
else:
return False
return isValid(root, None, None)
#
# print(isValidBST(lstToTreeNode([2, 1, 3])))
# print(isValidBST(lstToTreeNode([5, 1, 4, None, None, 3, 6])))
# print(isValidBST(lstToTreeNode([10, 5, 15, None, None, 6, 20])))
print(isValidBST(lstToTreeNode([0, None, -1])))
def isSameTree(p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
if p is None and q is None:
return True
elif p is None or q is None:
return False
if p.val == q.val:
left = isSameTree(p.left, q.left)
right = isSameTree(p.right, q.right)
return left and right
return False
# stack = [(p, q)]
# while stack:
# r1, r2 = stack.pop()
# if (r1 and not r2) or (not r1 and r2) or (r1 and r2 and r1.val != r2.val):
# return False
# if r1 and r2:
# stack.append((r1.left, r2.left))
# stack.append((r1.right, r2.right))
# return True
p = lstToTreeNode([1, 2, 3, 4])
q = lstToTreeNode([1, 2, 3, 5])
print(isSameTree(p, q))
