class Solution:
def convertBST(self, root: TreeNode) -> TreeNode:
if root:
stack = [] # 中序遍历，所有节点入栈
def midorder(node: TreeNode):
if node.left:
midorder(node.left)
stack.append(node)
if node.right:
midorder(node.right)
midorder(root)
sum = 0
while stack:
node = stack.pop()
node.val += sum
sum = node.val
return root
# @lc code=end
if __name__ == "__main__":
solution = Solution()
root = solution.convertBST(TreeNode.createBFSTree([5, 2, 13]))
print(root.serialize())
while stack:
node = stack.pop()
if node.val in valSet:
return 0
else:
valSet.add(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
vals = list(valSet)
vals.sort()
prev = float("inf")
delta = prev
for val in vals:
newDelta = abs(val - prev)
if newDelta < delta:
delta = newDelta
prev = val
return delta
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.getMinimumDifference(TreeNode.createBFSTree([1, None, 3, 2])))
node = root
while node or stack:
while node:
stack.append(node)
node = node.left
if stack:
node = stack.pop()
queue.append(node)
node = node.right
# 重新组织树
prevNode = None
for node in queue:
if prevNode:
prevNode.left = None
prevNode.right = node
prevNode = node
prevNode.left = prevNode.right = None
return queue[0]
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.increasingBST(TreeNode.createBFSTree(
[2, 1, 4, None, None, 3])).serialize())
print(solution.increasingBST(TreeNode.createBFSTree(
[5, 3, 6, 2, 4, None, 8, 1, None, None, None, 7, 9])).serialize())
print(solution.increasingBST(TreeNode.createBFSTree(
[5, 1, 7])).serialize())
class Solution:
def binaryTreePaths(self, root: TreeNode) -> List[str]:
if not root:
return []
res = []
stack = []
def dfs(node: TreeNode):
stack.append(node)
if not node.left and not node.right:
res.append("->".join([str(n.val) for n in stack]))
else:
if node.left:
dfs(node.left)
if node.right:
dfs(node.right)
stack.pop()
dfs(root)
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.binaryTreePaths(
TreeNode.createBFSTree([10, 5, 15, None, None, 6, 20])))
from treenode import TreeNode
# @lc code=start
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if not t1:
return t2
elif not t2:
return t1
t = TreeNode(t1.val + t2.val)
t.left = self.mergeTrees(t1.left, t2.left)
t.right = self.mergeTrees(t1.right, t2.right)
return t
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.mergeTrees(TreeNode.createBFSTree([1, 3, 2, 5]), \
TreeNode.createBFSTree([2, 1, 3, None, 4, None, 7])).serialize())
class Solution:
def flatten(self, root: TreeNode) -> None:
"""
Do not return anything, modify root in-place instead.
"""
if root:
stack = [root]
prev = None
while stack:
node = stack.pop()
if prev:
prev.right = node
prev.left = None
prev = node
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return root
# @lc code=end
if __name__ == "__main__":
solution = Solution()
node = TreeNode.createBFSTree([1, 2, 5, 3, 4, None, 6])
solution.flatten(node)
print(node.serialize())
res = []
stack = []
def dfs(node: TreeNode, target: int):
stack.append(node.val)
target -= node.val
if not node.left and not node.right and target == 0:
res.append(stack[:])
else:
if node.left:
dfs(node.left, target)
if node.right:
dfs(node.right, target)
stack.pop()
dfs(root, sum)
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.pathSum(TreeNode.createBFSTree([-2, None, -3]), -5))
print(
solution.pathSum(
TreeNode.createBFSTree(
[5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1]), 22))
class Solution:
def findSecondMinimumValue(self, root: TreeNode) -> int:
# 根节点就是最小值
minVal = root.val
res = -1
# BFS遍历树，找到严格大于根节点值的最小值，就是答案
stack = deque([root])
while stack:
node = stack.popleft()
val = node.val
if val > minVal:
res = val
if node.left and (res == -1 or res >= node.left.val):
stack.append(node.left)
if node.right and (res == -1 or res >= node.right.val):
stack.append(node.right)
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
# root = TreeNode.createBFSTree(
# [1, 1, 3, 1, 1, 3, 4, 3, 1, 1, 1, 3, 8, 4, 8, 3, 3, 1, 6, 2, 1])
# print(solution.findSecondMinimumValue(root))
print(solution.findSecondMinimumValue(
TreeNode.createBFSTree([2, 2, 5, None, None, 5, 7])))
from treenode import TreeNode
# @lc code=start
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if p is None and q is None:
return True
elif p is None or q is None:
return False
else:
# 递归法
return p.val == q.val and self.isSameTree(
p.left, q.left) and self.isSameTree(p.right, q.right)
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.isSameTree(TreeNode.createBFSTree([1, 2, 3]),
TreeNode.createBFSTree([1, 2, 3])))
# 谷歌：我们90％的工程师使用您编写的软件(Homebrew)，
# 但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了。
from treenode import TreeNode
# @lc code=start
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if root:
left = self.invertTree(root.right)
right = self.invertTree(root.left)
root.left = left
root.right = right
return root
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.invertTree(TreeNode.createBFSTree([4, 2, 7, 1, 3, 6,
9])).serialize())
return 1 # has camera
elif left == 1 or right == 1:
return -1 # no need
return 0 # cover by parent
if dfs(root) == 0:
minRequirement += 1
return minRequirement
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.minCameraCover(
TreeNode.createBFSTree([0, 0, None, None, 0, 0, None, None, 0,
0])))
print(
solution.minCameraCover(
TreeNode.createBFSTree([0, None, 0, 0, 0, None, None, 0, 0])))
print(
solution.minCameraCover(
TreeNode.createBFSTree([
0, None, 0, None, 0, None, 0, None, 0, 0, 0, None, None, 0, 0
])))
print(solution.minCameraCover(TreeNode.createBFSTree([0, 0, None, 0, 0])))
print(
solution.minCameraCover(
TreeNode.createBFSTree([0, 0, None, 0, None, 0, None, None, 0])))
def inOrder(node: TreeNode):
if node.left:
inOrder(node.left)
nonlocal preVal, maxCount, curCount
if preVal == node.val:
curCount += 1
else:
curCount = 1
preVal = node.val
if curCount >= maxCount:
if curCount > maxCount:
res.clear()
maxCount = curCount
res.append(preVal)
if node.right:
inOrder(node.right)
inOrder(root)
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.findMode(TreeNode.createBFSTree([1, None, 2, 2])))
# self.right = right
class Solution:
def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
sum = 0
stack = [root]
while stack:
node = stack.pop()
if low <= node.val <= high:
sum += node.val
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
elif node.val > high:
if node.left:
stack.append(node.left)
elif node.right:
stack.append(node.right)
return sum
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.rangeSumBST(
TreeNode.createBFSTree([10, 5, 15, 3, 7, None, 18]), 7, 15))
print(solution.rangeSumBST(
TreeNode.createBFSTree([10, 5, 15, 3, 7, 13, 18, 1, None, 6]), 6, 10))
p1 = (node, level)
elif node.left.val == y:
p2 = (node, level)
stack.append((node.left, level + 1))
if node.right:
if node.right.val == x:
p1 = (node, level)
elif node.right.val == y:
p2 = (node, level)
stack.append((node.right, level + 1))
if p1 and p2:
break
return (p1 is not None) and (
p2 is not None) and p1[0] != p2[0] and p1[1] == p2[1]
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.isCousins(
TreeNode.createBFSTree([1, None, 2, 3, None, None, 4, None, 5]), 1,
3))
print(solution.isCousins(TreeNode.createBFSTree([1, 2, 3, 4]), 4, 3))
print(
solution.isCousins(TreeNode.createBFSTree([1, 2, 3, None, 4, None, 5]),
5, 4))
print(solution.isCousins(TreeNode.createBFSTree([1, 2, 3, None, 4]), 2, 3))
root = tmp.pop()
self.stack.append(root.val)
root = root.right
self.stack.reverse()
def next(self) -> int:
return self.stack.pop()
def hasNext(self) -> bool:
return len(self.stack) > 0
# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()
# @lc code=end
if __name__ == "__main__":
tree = TreeNode.createBFSTree([7, 3, 15, None, None, 9, 20])
bSTIterator = BSTIterator(tree)
print(bSTIterator.next()) # // 返回 3
print(bSTIterator.next()) # // 返回 7
print(bSTIterator.hasNext()) # // 返回 True
print(bSTIterator.next()) # // 返回 9
print(bSTIterator.hasNext()) # // 返回 True
print(bSTIterator.next()) # // 返回 15
print(bSTIterator.hasNext()) # // 返回 True
print(bSTIterator.next()) # // 返回 20
print(bSTIterator.hasNext()) # // 返回 False
cache[node.right.val] = node
recordParent(node.right)
recordParent(root)
res = []
def findNode(node: TreeNode, fromNode: TreeNode, step: int):
if node is None:
return
if step == k:
res.append(node.val)
return
if node.left and node.left != fromNode:
findNode(node.left, node, step + 1)
if node.right and node.right != fromNode:
findNode(node.right, node, step + 1)
if node.val in cache and cache[node.val] != fromNode:
findNode(cache[node.val], node, step + 1)
findNode(target, None, 0)
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
root = TreeNode.createBFSTree(
[3, 5, 1, 6, 2, 0, 8, None, None, 7, 4])
target = root.left
print(solution.distanceK(root, target, 2))
if not root:
return res
# 方法1：递归
# def postOrder(node: TreeNode, arr: List):
# if node.left:
# postOrder(node.left, arr)
# if node.right:
# postOrder(node.right, arr)
# arr.append(node.val)
# postOrder(root, res)
# 方法2：迭代
stack = [root]
while stack:
node = stack.pop()
res.append(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
res.reverse() #这个很重要，翻转后返回
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.postorderTraversal(TreeNode.createBFSTree([1, None, 2, 3])))
Args:
node (TreeNode): 根节点
Returns:
int: 🌲深度
"""
leftDepth = getBalancedDepth(node.left) if node.left else 0
if leftDepth == -1:
return -1
rightDepth = getBalancedDepth(node.right) if node.right else 0
if rightDepth == -1:
return -1
return max(leftDepth, rightDepth) + 1 if abs(
leftDepth - rightDepth) < 2 else -1
return getBalancedDepth(root) != -1
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.isBalanced(
TreeNode.createBFSTree([3, 9, 20, None, None, 15, 7])))
print(
solution.isBalanced(
TreeNode.createBFSTree([1, 2, 2, 3, 3, None, None, 4, 4])))
for node in depth:
left = nodeList[i]
if left:
node.left = left
newDepth.append(left)
i += 1
if i >= l:
break
right = nodeList[i]
if right:
node.right = right
newDepth.append(right)
i += 1
if i >= l:
break
depth = newDepth
return nodeList[0]
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))
if __name__ == "__main__":
codec = Codec()
codec.deserialize(codec.serialize(TreeNode.createBFSTree([2, 3, 1])))
node2 = node
if not node1:
node1 = preNode
else:
break
preNode = node
node = node.right
# 2. Morris 中序遍历
if node1 and node2:
node1.val, node2.val = node2.val, node1.val
return
# @lc code=end
if __name__ == "__main__":
solution = Solution()
root = TreeNode.createBFSTree([0, 1])
solution.recoverTree(root)
print(root.serialize())
root = TreeNode.createBFSTree([2, 3, 1])
solution.recoverTree(root)
print(root.serialize())
root = TreeNode.createPreOrderTree([3, None, 2, None, 1])
solution.recoverTree(root)
print(root.serialize())
# @lc code=start
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
node = root
while node:
if node.val == val:
break
elif node.val < val:
node = node.right
else:
node = node.left
return node
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.searchBST(TreeNode.createBFSTree([4, 2, 7, 1, 3]),
2).serialize())
# nodeIndex (int): 节点索引
# Returns:
# bool: 存在与否
# """
# n = root
# bit = 1 << (depth - 2)
# while n and bit > 0:
# if bit & nodeIndex == 0:
# n = n.left
# else:
# n = n.right
# bit >>= 1
# return n is not None
# low, high = 1 << (depth - 1), (1 << depth) - 1
# while low < high:
# mid = (high + low + 1) >> 1
# if exists(mid):
# low = mid
# else:
# high = mid - 1
# return low
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.countNodes(TreeNode.createBFSTree([1, 2, 3, 4, 5, 6])))
class Solution:
def pathSum(self, root: TreeNode, targetSum: int) -> int:
prefixSumDict = defaultdict(int) # 保存前缀和的字典
prefixSumDict[0] = 1 # 前缀和为0有一种情况，就是路径为空（初始情况）
def dfs(node: TreeNode, prefixSum: int) -> int:
if node is None:
return 0
cnt = 0
prefixSum += node.val
cnt += prefixSumDict[prefixSum - targetSum]
prefixSumDict[prefixSum] += 1
if node.left:
cnt += dfs(node.left, prefixSum)
if node.right:
cnt += dfs(node.right, prefixSum)
prefixSumDict[prefixSum] -= 1
return cnt
return dfs(root, 0)
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.pathSum(TreeNode.createBFSTree(
[10, 5, -3, 3, 2, None, 11, 3, -2, None, 1]), 8)) # 3
print(solution.pathSum(TreeNode.createBFSTree(
[5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1]), 22)) # 3
# self.left = None
# self.right = None
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if not root:
return 0
stack = [(root, 1)]
maxDepth = 1
while stack:
node, depth = stack.pop()
if depth > maxDepth:
maxDepth = depth
if node.right:
stack.append((node.right, depth + 1))
if node.left:
stack.append((node.left, depth + 1))
return maxDepth
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.maxDepth(TreeNode.createBFSTree([3, 9, 20, None, None, 15,
7])))
return l
leaf1 = leaf(root1)
leaf2 = leaf(root2)
return leaf1 == leaf2
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.leafSimilar(
TreeNode.createBFSTree([
3, 5, 1, 6, 7, 4, 2, None, None, None, None, None, None, 9, 11,
None, None, 8, 10
]), TreeNode.createBFSTree([3, 5, 1, 6, 2, 9, 8, None, None, 7,
4])))
print(
solution.leafSimilar(
TreeNode.createBFSTree([3, 5, 1, 6, 2, 9, 8, None, None, 7, 4]),
TreeNode.createBFSTree([
3, 5, 1, 6, 7, 4, 2, None, None, None, None, None, None, 9, 8
])))
print(
solution.leafSimilar(TreeNode.createBFSTree([1]),
TreeNode.createBFSTree([1])))
print(
solution.leafSimilar(TreeNode.createBFSTree([1]),
TreeNode.createBFSTree([2])))
print(
class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
if not root:
return None
lvl = [root]
avg = []
while lvl:
nextLvl = []
size = len(lvl)
sum = 0
for node in lvl:
sum += node.val
if node.left:
nextLvl.append(node.left)
if node.right:
nextLvl.append(node.right)
avg.append(sum / size)
lvl = nextLvl
return avg
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.averageOfLevels(
TreeNode.createBFSTree([3, 9, 20, None, None, 15, 7])))
# return isMirror(n1.left, n2.right) and isMirror(n1.right, n2.left)
# return isMirror(root.left, root.right)
# 迭代
# 层序遍历
queue = [root]
symmetric = True
while queue:
value = [n.val if n else None for n in queue]
if value != value[::-1]: # 不对称的话
symmetric = False
break
nextLevel = []
for n in queue:
if n:
nextLevel.append(n.left)
nextLevel.append(n.right)
queue = nextLevel
return symmetric
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.isSymmetric(TreeNode.createBFSTree([1, 2, 2, 3, 4, 4, 3])))
print(
solution.isSymmetric(
TreeNode.createBFSTree([1, 2, 2, None, 3, None, 3])))
prev = n
return True
siblings = [root]
level = 0
while siblings:
next = []
v = valid(siblings, level, next)
if not v:
return False
level += 1
siblings = next
return True
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[13, 34, 32, 23, 25, 27, 29, 44, 40, 36, 34, 30, 30, 28, 26, 3, 7, 9, 11, 15, 17, 21, 25, None, None, 27, 31, 35, None, 37, None, 30, None, 26, None, None, None, 24, None, 20, 16, 12, 10, None, None, 8, None, None, None, None, None, 6, None, None, None, None, None, 15, 19, None, None, None, None, 23, None, 27, 29, 33, 37, None, None, None, None, None, None, 48, None, None, None, 46, None, None, None, 42, 38, 34, 32, None, None, None, None, 19]))) # False
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[5, 9, 1, 3, 5, 7]))) # False
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[1, 10, 4, 3, None, 7, 9, 12, 8, 6, None, None, 2]))) # True
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[5, 4, 2, 3, 3, 7]))) # False
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[1]))) # True
print(solution.isEvenOddTree(TreeNode.createBFSTree(
[11, 8, 6, 1, 3, 9, 11, 30, 20, 18, 16, 12, 10, 4, 2, 17]))) # True
if not root:
return TreeNode(val)
node = root
prev = None
dir = 0
while node:
prev = node
if node.val > val:
node = node.left
dir = 0
elif node.val < val:
node = node.right
dir = 1
if dir:
prev.right = TreeNode(val)
else:
prev.left = TreeNode(val)
return root
# @lc code=end
if __name__ == "__main__":
solution = Solution()
root = TreeNode.createBFSTree([4, 2, 7, 1, 3])
solution.insertIntoBST(root, 5)
print(root.serialize())
while stack:
node, col, row = stack.popleft()
temp[col].append((row, node.val))
if node.left:
stack.append((node.left, col - 1, row + 1))
if node.right:
stack.append((node.right, col + 1, row + 1))
res = []
for col in sorted(temp.keys()):
nodeList = temp[col]
nodeList.sort()
res.append([x for _, x in nodeList])
return res
# @lc code=end
if __name__ == "__main__":
solution = Solution()
print(
solution.verticalTraversal(
TreeNode.createBFSTree([3, 9, 20, None, None, 15, 7])))
print(
solution.verticalTraversal(
TreeNode.createBFSTree([1, 2, 3, 4, 5, 6, 7])))
print(
solution.verticalTraversal(
TreeNode.createBFSTree([1, 2, 3, 4, 6, 5, 7])))
