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)