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