class Solution:
def isBalanced(self, root: TreeNode) -> bool:
res = 0
def helper(root):
if not root:
return 0
left_h = helper(root.left)
if left_h == -1:
return -1
right_h = helper(root.right)
if right_h == -1:
return -1
if abs(left_h - right_h) > 1:
return -1
return max(left_h, right_h) + 1
if root:
res = helper(root)
return res != -1
if __name__ == '__main__':
nums1 = "1,2,2,3,3,null,null,4,4"
root = stringToTreeNode(nums1)
sol = Solution()
result = sol.isBalanced(root)
print(result)
# level.
prev, curr = None, leftmost
# We reset this so that we can re-assign it to the leftmost
# node of the next level. Also, if there isn't one, this
# would help break us out of the outermost loop.
leftmost = None
# Iterate on the nodes in the current level using
# the next pointers already established.
while curr:
# Process both the children and update the prev
# and leftmost pointers as necessary.
prev, leftmost = self.processChild(curr.left, prev, leftmost)
prev, leftmost = self.processChild(curr.right, prev, leftmost)
# Move onto the next node.
curr = curr.next
return root
if __name__ == '__main__':
inorder = "1,2,3,4,5,null,7"
from Tree import stringToTreeNode
root = stringToTreeNode(inorder)
sol = Solution()
result = sol.connect2(root)
print(result)
给定的两棵树可能会有 1 到 200 个结点。
给定的两棵树上的值介于 0 到 200 之间。
'''
from Tree import TreeNode, stringToTreeNode
class Solution:
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
def dfs(node: TreeNode, ans: list):
if not node:
return
if node.left or node.right:
dfs(node.left, ans)
dfs(node.right, ans)
else:
ans.append(node.val)
res1, res2 = [], []
dfs(root1, res1)
dfs(root2, res2)
return res1 == res2
if __name__ == '__main__':
nums1 = "3, 5, 1, 6, 2, 9, 8, null, null, 7, 4"
nums2 = "3, 5, 1, 6, 7, 4, 2, null, null, null, null, null, null,9, 8"
root1 = stringToTreeNode(nums1)
root2 = stringToTreeNode(nums2)
sol = Solution()
print(sol.leafSimilar(root1, root2))
4
/ \
1 2
返回 false。
"""
from Tree import TreeNode, stringToTreeNode
class Solution:
def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
def isSameTree(p, q):
return (p == q) or (p and q and p.val == q.val and isSameTree(
p.left, q.left) and isSameTree(p.right, q.right))
if s is None:
return False
elif s.val == t.val and isSameTree(s, t):
return True
else:
return self.isSubtree(s.left, t) or self.isSubtree(s.right, t)
if __name__ == '__main__':
s1 = "3,4,5,1,2,null,null"
t1 = "4,1,2"
s = stringToTreeNode(s1)
t = stringToTreeNode(t1)
sol = Solution()
result = sol.isSubtree(s, t)
print(result)
from Tree import TreeNode, stringToTreeNode
class Solution:
def getMinimumDifference(self, root: TreeNode) -> int:
self.minminus = 99999
minuslist = []
def middle(node: TreeNode):
if node.left:
# minuslist.append(node.left.val)
middle(node.left)
minuslist.append(node.val)
if len(minuslist) >= 2:
temp = abs(minuslist[-1] - minuslist[-2])
if self.minminus > temp:
self.minminus = temp
if node.right:
# minuslist.append(node.right.val)
middle(node.right)
middle(root)
return self.minminus
input = "[1,null,3,2]"
root = stringToTreeNode(input)
Solution().getMinimumDifference(root)
/ \ / \
2 1 1 2
[1,2,1], [1,1,2]
输出: false
"""
from Tree import TreeNode, stringToTreeNode
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if not p and not q:
return True
elif not p or not q:
return False
elif p.val != q.val:
return False
else:
return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
if __name__ == '__main__':
nums1 = "1,2,3"
nums2 = "1,2,3"
p = stringToTreeNode(nums1)
q = stringToTreeNode(nums2)
sol = Solution()
result = sol.isSameTree(p, q)
print(result)
2 3
\
4
输出: "1(2()(4))(3)"
解释: 和第一个示例相似，
除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。
"""
from Tree import TreeNode, stringToTreeNode
class Solution:
def tree2str(self, t: TreeNode) -> str:
if t is None:
return ''
if t.left is None and t.right is None:
return str(t.val)
ans = str(t.val)
ans += '(' + self.tree2str(t.left) + ')'
if t.right is not None:
ans += '(' + self.tree2str(t.right) + ')'
return ans
if __name__ == '__main__':
nums = "1,null,3,null,4,5,null,6"
t = stringToTreeNode(nums)
sol = Solution()
print(sol.tree2str(t))
根节点的值为 5 ，但是其右子节点值为 4 。
"""
from Tree import TreeNode, stringToTreeNode
class Solution:
def isValidBST(self, root: TreeNode) -> bool:
def helper(node, lower=float('-inf'), upper=float('inf')):
if not node:
return True
val = node.val
if val <= lower or val >= upper:
return False
if not helper(node.right, val, upper):
return False
if not helper(node.left, lower, val):
return False
return True
return helper(root)
if __name__ == '__main__':
trees = "1,1"
root = stringToTreeNode(trees)
sol = Solution()
result = sol.isValidBST(root)
print(result)
from Tree import TreeNode, stringToTreeNode
class Solution:
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if not t1:
return t2
if not t2:
return t1
merged = TreeNode(t1.val + t2.val)
merged.left = self.mergeTrees(t1.left, t2.left)
merged.right = self.mergeTrees(t1.right, t2.right)
return merged
t1 = "[1,3,2,5]"
t2 = "[2,1,3,null,4,null,7]"
s = Solution()
t1 = stringToTreeNode(t1)
t2 = stringToTreeNode(t2)
print(s.mergeTrees(t1, t2))
/ \
4 5
/ \ \
5 4 7
注意: 合并必须从两个树的根节点开始。
"""
from Tree import TreeNode, stringToTreeNode
class Solution:
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if t1 is None:
return t2
if t2 is None:
return t1
merged = TreeNode(t1.val + t2.val)
merged.left = self.mergeTrees(t1.left, t2.left)
merged.right = self.mergeTrees(t1.right, t2.right)
return merged
if __name__ == '__main__':
nums1 = "1,3,2,5"
nums2 = "2,1,3,null,4,null,7"
t1 = stringToTreeNode(nums1)
t2 = stringToTreeNode(nums2)
sol = Solution()
sol.mergeTrees(t1, t2)
