if not node.left and not node.right: f[node] = node.val g[node] = 0 return postorder(node.left) postorder(node.right) f[node] = node.val + g[node.left] + g[node.right] g[node] = max(f[node.left], g[node.left]) + max(f[node.right], g[node.right]) postorder(root) return max(f[root], g[root]) # 精妙递归 class Solution: def rob(self, root: TreeNode) -> int: def postorder(node): if not node: return (0, 0) l = postorder(node.left) r = postorder(node.right) selected = node.val + l[1] + r[1] notselected = max(l) + max(r) return (selected, notselected) return max(postorder(root)) a = stringToTreeNode('[3,4,5,1,3,null,1]') Solution().rob(a)
return node.val def delete(node, key): if not node: return None if node.val == key: if not node.left and not node.right: node = None elif node.right: node.val = successor(node) node.right = delete(node.right, node.val) elif node.left: node.val = predecessor(node) node.left = delete(node.left, node.val) elif node.val > key: node.left = delete(node.left, key) elif node.val < key: node.right = delete(node.right, key) return node root = delete(root, key) return root from leetcode.trick.treenode.T import stringToTreeNode a = '[2,1]' root = stringToTreeNode(a) key = 0 Solution().deleteNode(root, 2)
class Solution: def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': s = {} st = [] node = root s[root.val]=None while node or st: while node: st.append(node.right) if node.left: s[node.left.val] = node if node.right: s[node.right.val] = node node = node.left node = st.pop() m =set() while p: m.add(p) p = s[p.val] while q not in m: q=s[q.val] return q root = stringToTreeNode('[3,5,1,6,2,0,8,null,null,7,4]') p = 5; q = 4 Solution().lowestCommonAncestor(root, TreeNode(p), TreeNode(q))
stack.append(node) node = node.left node = stack.pop() count += 1 if count == k: return node.val node = node.right return # 递归 简洁 中序遍历 class Solution: def kthSmallest(self, root, k): """ :type root: TreeNode :type k: int :rtype: int """ def inorder(r): return inorder(r.left) + [r.val] + inorder(r.right) if r else [] return inorder(root)[k - 1] # 作者:LeetCode # 链接:https: // leetcode - cn.com / problems / kth - smallest - element - in -a - bst / solution / er - cha - sou - suo - shu - zhong - di - kxiao - de - yuan - su - by - le / # 来源:力扣(LeetCode) # 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 a = stringToTreeNode('[3,1,4,null,2]') Solution().kthSmallest(a, 1)
# Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: ans = 0 def diameterOfBinaryTree(self, root: TreeNode) -> int: if not root: return 0 def rec(node): a = 1 + rec(node.left) if node.left else 0 b = 1 + rec(node.right) if node.right else 0 self.ans = max(self.ans, a + b) return max(a, b) rec(root) return self.ans from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[1,2,3,4,5]') Solution().diameterOfBinaryTree(a)
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def levelOrder(self, root: TreeNode) -> List[List[int]]: deq = [[root]] res = [] while deq: trees = [] ans = [] for root in deq.pop(): if not root: continue trees.append(root.left) trees.append(root.right) ans.append(root.val) if not trees: break deq.append(trees) res.append(ans) return res a = stringToTreeNode('[3,9,20,null,null,15,7]') Solution().levelOrder(a)
ans = float('inf') if len(self.li) == 1: return 2 ** 31 - 1 for i in range(1, len(self.li)): ans = min(ans, self.li[i] - self.li[i - 1]) return ans # 2递归 class Solution: ans = 2 ** 31 - 1 pre = 2 ** 31 - 1 def getMinimumDifference(self, root: TreeNode) -> int: def rec(node): if not node: return rec(node.left) self.ans = min(abs(self.pre - node.val), self.ans) self.pre = node.val rec(node.right) rec(root) return self.ans from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[236,104,701,null,227,null,911]') Solution().getMinimumDifference(a)
m = t return ans # 2深度优先遍历 dfs class Solution: def widthOfBinaryTree(self, root: TreeNode) -> int: if not root: return 0 self.ans = 1 left = {} def dfs(node, level, pos): if not node: return left.setdefault(level, pos) self.ans = max(self.ans, pos - left[level] + 1) dfs(node.left, level + 1, 2 * pos) dfs(node.right, level + 1, 2 * pos + 1) dfs(root, 0, 0) return self.ans from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode( '[1,1,1,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,null,1,1,null,1,null,1,null,1,null,1,null]' ) Solution().widthOfBinaryTree(a)
elif not node.left: x = node.val + rec(node.right) m[x] += 1 return x elif not node.right: x = node.val + rec(node.left) m[x] += 1 return x else: x = node.val + rec(node.left) + rec(node.right) m[x] += 1 return x if not root: return [] rec(root) ans = [] a = sorted(m.items(), reverse=True, key=lambda x: x[1]) ans.append(a[0][0]) for i in range(1, len(a)): if a[i][1] == a[i - 1][1]: ans.append(a[i][0]) else: break return ans from leetcode.trick.treenode.T import stringToTreeNode x = stringToTreeNode('[5,2,-3]') Solution().findFrequentTreeSum(x)
self.val = x self.left = None self.right = None class Solution: def __init__(self): self.mlevel = 0 def minDepth(self, root: TreeNode) -> int: def minlevel(root): if not root: return 0 elif root.left and root.right: self.mlevel = 1 + min(minlevel(root.left), minlevel( root.right)) return self.mlevel elif not root.left and not root.right: return 1 elif not root.left: return 1 + minlevel(root.right) else: return 1 + minlevel(root.left) return minlevel(root) from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[1,2]') Solution().minDepth(a)
self.val = val self.left = left self.right = right class Solution: def __init__(self): self.dummynode = TreeNode(-1) self.resnode = self.dummynode def increasingBST(self, root: TreeNode) -> TreeNode: def inorder(node): if not node: return inorder(node.left) self.resnode.right = node self.resnode = node node.left = None inorder(node.right) inorder(root) return self.dummynode.right from leetcode.trick.treenode.T import stringToTreeNode from leetcode.trick.treenode.T import treeNodeToString a = stringToTreeNode('[4,1,7,0,2,5,8,null,null,null,3,null,6,null,9]') b = Solution().increasingBST(a) treeNodeToString(b)
来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/second-minimum-node-in-a-binary-tree 著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。''' # 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: ans = float('inf') def findSecondMinimumValue(self, root: TreeNode) -> int: m1 = root.val def rec(node): if node: if node.val > m1: self.ans = min(self.ans, node.val) elif node.val==m1: rec(node.left) rec(node.right) rec(root) return self.ans if self.ans!=float('inf') else -1 from leetcode.trick.treenode.T import stringToTreeNode a=stringToTreeNode('[2,2,2]') Solution().findSecondMinimumValue(a)
ans = [] def dfs(node, cur): if not node: return cur if node.val != voyage[cur]: return False a = dfs(node.left, cur + 1) if a: return dfs(node.right, a) else: node.left, node.right = node.right, node.left a = dfs(node.left, cur + 1) ans.append(voyage[cur]) if a: return dfs(node.right, a) else: ans.pop() node.left, node.right = node.right, node.left return False if dfs(root, 0): return ans else: return [-1] {} from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[1,2,3]') Solution().flipMatchVoyage(a, [1, 3, 2])
class Solution: def binaryTreePaths(self, root): """ :type root: TreeNode :rtype: List[str] """ if not root: return [] paths = [] stack = [(root, str(root.val))] while stack: node, path = stack.pop() if not node.left and not node.right: paths.append(path) if node.left: stack.append((node.left, path + '->' + str(node.left.val))) if node.right: stack.append((node.right, path + '->' + str(node.right.val))) return paths # 作者:LeetCode # 链接:https: // leetcode - cn.com / problems / binary - tree - paths / solution / er - cha - shu - de - suo - you - lu - jing - by - leetcode / # 来源:力扣(LeetCode) # 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 a = stringToTreeNode('[1,2,3,null,5]') Solution().binaryTreePaths(a)
def addOneRow(self, root: TreeNode, v: int, d: int) -> TreeNode: if d == 1: node = TreeNode(v) node.left = root return node m = [root] level = 1 while True: if level == d - 1: for p in m: a = p.left b = p.right p.left, p.right = TreeNode(v), TreeNode(v) p.left.left = a p.right.right = b return root tree = [] for node in m: if node.left: tree.append(node.left) if node.right: tree.append(node.right) m = tree level += 1 from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[4,2,6,3,1,5]') Solution().addOneRow(a, 1, 2)
return rec(node.left) rec(node.right) res.append(node.val) rec(root) return res class Solution: def postorderTraversal(self, root: TreeNode) -> List[int]: node = root stack = [] res = [] while stack or node: while node: stack.append(node) node = node.left if node.left else node.right node = stack.pop() res.append(node.val) if stack and stack[-1].left == node: node = stack[-1].right else: node = None return res a = stringToTreeNode('[1,null,2,3]') Solution().postorderTraversal(a)
dfs(root) return ans # 2标识符 # default_factory class Solution: def findDuplicateSubtrees(self, root: TreeNode) -> List[TreeNode]: trees = collections.defaultdict() trees.default_factory = trees.__len__ ans = [] m = collections.Counter() def lookup(node): if node: uid = trees[node.val, lookup(node.left), lookup(node.right)] m[uid] += 1 if m[uid] == 2: ans.append(node) return uid lookup(root) return ans from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[1,2,3,4,null,2,4,null,null,4]') Solution().findDuplicateSubtrees(a)
# Value of q q_val = q.val # Start from the root node of the tree node = root # Traverse the tree while node: # Value of current node or parent node. parent_val = node.val if p_val > parent_val and q_val > parent_val: # If both p and q are greater than parent node = node.right elif p_val < parent_val and q_val < parent_val: # If both p and q are lesser than parent node = node.left else: # We have found the split point, i.e. the LCA node. return node # 作者:LeetCode # 链接:https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/solution/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian--2/ # 来源:力扣(LeetCode) # 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 a = stringToTreeNode('[6,2,8,0,4,7,9,null,null,3,5]') Solution().lowestCommonAncestor(a, TreeNode(2), TreeNode(4))
def exist(idx, root, d): left, right = 0, 2**d - 1 for _ in range(d): pivot = (left + right) // 2 if idx <= pivot: root = root.left right = pivot else: root = root.right left = pivot return root is not None d = depth(root) if d == -1: return 0 elif d == 0: return 1 left, right = 0, 2**d - 1 while left <= right: pivot = (left + right) // 2 if exist(pivot, root, d): left = pivot + 1 else: right = pivot - 1 return 2**d - 1 + left a = '[1,2,3]' b = stringToTreeNode(a) Solution().countNodes(b)
y = root if x is None: x = pred pred = root predecessor.right = None root = root.right # If there is no left child # then just go right. else: # check for the swapped nodes if pred and root.val < pred.val: y = root if x is None: x = pred pred = root root = root.right x.val, y.val = y.val, x.val # 作者:LeetCode # 链接:https://leetcode-cn.com/problems/recover-binary-search-tree/solution/hui-fu-er-cha-sou-suo-shu-by-leetcode/ # 来源:力扣(LeetCode) # 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 a = stringToTreeNode('[146,71,-13,55,null,231,399,321,null,null,null,null,null,-33]') Solution().recoverTree(a)
# Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def smallestFromLeaf(self, root: TreeNode) -> str: self.ans = '~' def dfs(node, pre): if node: p = chr(97 + node.val) + pre if not node.left and not node.right: self.ans = min(self.ans, p) return dfs(node.left, p) dfs(node.right, p) dfs(root, '') return self.ans from leetcode.trick.treenode.T import stringToTreeNode a = stringToTreeNode('[0,null,1]') Solution().smallestFromLeaf(a)
#中序遍历 二叉搜索树中序遍历一定是升序的 class Solution: def isValidBST(self, root): """ :type root: TreeNode :rtype: bool """ stack, inorder = [], float('-inf') while stack or root: while root: stack.append(root) root = root.left root = stack.pop() # 如果中序遍历得到的节点的值小于等于前一个 inorder,说明不是二叉搜索树 if root.val <= inorder: return False inorder = root.val root = root.right return True # 作者:LeetCode - Solution # 链接:https: // leetcode - cn.com / problems / validate - binary - search - tree / solution / yan - zheng - er - cha - sou - suo - shu - by - leetcode - solution / # 来源:力扣(LeetCode) # 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 a = stringToTreeNode('[10,5,15,null,null,6,20]') Solution().isValidBST(a)
if node1.val == node2.val: if check(node1.left, node2.left) and check( node1.right, node2.right): return True if rec(node1.left, node2): return True if rec(node1.right, node2): return True return False def check(node1, node2): if not node1: return not node2 if not node2: return not node1 if node1.val != node2.val: return False if check(node1.left, node2.left) and check(node1.right, node2.right): return True return False return rec(s, t) from leetcode.trick.treenode.T import stringToTreeNode s = stringToTreeNode('[3,4,5,1,null,2]') t = stringToTreeNode('[3,1,2]') Solution().isSubtree(s, t)
提示: 树中节点数目的范围在 [0, 104] 内 -1000 <= Node.val <= 1000 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/binary-tree-tilt 著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。''' # 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: tilt=0 def findTilt(self, root: TreeNode) -> int: def cal(node): if not node: return 0 a=cal(node.left) b=cal(node.right) self.tilt+=abs(a-b) return node.val+a+b cal(root) return self.tilt from leetcode.trick.treenode.T import stringToTreeNode a=stringToTreeNode('[4,2,9,3,5,null,7]') Solution().findTilt(a)
from leetcode.trick.treenode.T import stringToTreeNode class Solution: def pruneTree(self, root: TreeNode) -> TreeNode: def rec(node): if not node: return False if node.val == 0: if not rec(node.left) and not rec(node.right): return False if not rec(node.left): node.left = None if not rec(node.right): node.right = None return True if not root: return elif root.val == 0: if not rec(root.left) and not rec(root.right): return rec(root) return root a = stringToTreeNode('[1,null,0,0,1]') Solution().pruneTree(a)