難度簡單276
給定一個二叉搜索樹（Binary Search Tree），把它轉換成爲累加樹（Greater Tree)，使得每個節點的值是原來的節點值加上所有大於它的節點值之和。
例如：
輸入: 原始二叉搜索樹:
5
/ \
2 13
輸出: 轉換爲累加樹:
18
/ \
20 13
class Solution:
def __init__(self):
self.total = 0
def convertBST(self, root: TreeNode) -> TreeNode:
if root is not None:
self.convertBST(root.right)
self.total+= root.val
root.val = self.total
self.convertBST(root.left)
return root
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def convertBST(self, root: TreeNode) -> TreeNode:
total = 0
node = root
stack = []
while stack or node is not None:
while node is not None:
stack.append(node)
node = node.right
node = stack.pop()
total += node.val
node.val = total
node= node.left
return root
劍指 Offer 32 - II. 從上到下打印二叉樹 II
難度簡單28
從上到下按層打印二叉樹，同一層的節點按從左到右的順序打印，每一層打印到一行。
例如:
給定二叉樹: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其層次遍歷結果：
[
[3],
[9,20],
[15,7]
]
# Definition for a binary tree node.
# 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]]:
if not root:
return []
queue = [root]
res =[]
while queue:
n = len(queue)
tmp = []
for _ in range(n):
if not queue:
break
node = queue.pop(0)
tmp.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
res.append(tmp)
return res
難度簡單56
給出一棵二叉樹，其上每個結點的值都是 0 或 1 。每一條從根到葉的路徑都代表一個從最高有效位開始的二進制數。例如，如果路徑爲 0 -> 1 -> 1 -> 0 -> 1，那麼它表示二進制數 01101，也就是 13 。
對樹上的每一片葉子，我們都要找出從根到該葉子的路徑所表示的數字。
以 10^9 + 7 爲模，返回這些數字之和。
示例：
輸入：[1,0,1,0,1,0,1]
輸出：22
解釋：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sumRootToLeaf(self, root: TreeNode) -> int:
return self.dfs(root,0)
def dfs(self,root,n):
if not root :
return 0
n = n*2 + root.val
if not root.left and not root.right:
return n
return (self.dfs(root.left,n) + self.dfs(root.right,n))%(10**9+7)
難度簡單119
給定一個有相同值的二叉搜索樹（BST），找出 BST 中的所有衆數（出現頻率最高的元素）。
假定 BST 有如下定義：
- 結點左子樹中所含結點的值小於等於當前結點的值
- 結點右子樹中所含結點的值大於等於當前結點的值
- 左子樹和右子樹都是二叉搜索樹
例如：
給定 BST [1,null,2,2],
1
\
2
/
2
返回[2].
提示：如果衆數超過1個，不需考慮輸出順序
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def findMode(self, root: TreeNode) -> List[int]:
if root is None:
return []
queue =[root]
d={}
while queue:
node = queue.pop()
if node.val not in d:
d[node.val]=1
else:
d[node.val]+=1
if node.left is not None:
queue.append(node.left)
if node.right is not None:
queue.append(node.right)
m = max(d.values())
l=[]
for k,v in d.items():
if v==m:
l.append(k)
return l
難度簡單127
你需要採用前序遍歷的方式，將一個二叉樹轉換成一個由括號和整數組成的字符串。
空節點則用一對空括號 "()" 表示。而且你需要省略所有不影響字符串與原始二叉樹之間的一對一映射關係的空括號對。
示例 1:
輸入: 二叉樹: [1,2,3,4]
1
/ \
2 3
/
4
輸出: "1(2(4))(3)"
解釋: 原本將是“1(2(4)())(3())”，
在你省略所有不必要的空括號對之後，
它將是“1(2(4))(3)”。
示例 2:
輸入: 二叉樹: [1,2,3,null,4]
1
/ \
2 3
\
4
輸出: "1(2()(4))(3)"
解釋: 和第一個示例相似，
除了我們不能省略第一個對括號來中斷輸入和輸出之間的一對一映射關係。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def tree2str(self, t: TreeNode) -> str:
def preorder(root):
if not root:
return ''
if not root.left and root.right:
return str(root.val)+"()"+"("+preorder(root.right)+")"
if root.left and not root.right:
return str(root.val)+"("+preorder(root.left)+")"
if not root.left and not root.right:
return str(root.val)
return str(root.val)+"("+preorder(root.left)+")"+"("+preorder(root.right)+")"
return preorder(t)
難度簡單257
給定一個二叉樹，返回其節點值自底向上的層次遍歷。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷）
例如：
給定二叉樹 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其自底向上的層次遍歷爲：
[
[15,7],
[9,20],
[3]
]
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
queue = []
cur =[root]
while cur:
cur_layer_val =[]
next_layer_node=[]
for node in cur:
if node:
cur_layer_val.append(node.val)
next_layer_node.extend([node.left,node.right])
if cur_layer_val:
queue.insert(0,cur_layer_val)
cur = next_layer_node
return queue
難度簡單298
給定一個二叉樹，找到最長的路徑，這個路徑中的每個節點具有相同值。 這條路徑可以經過也可以不經過根節點。
注意：兩個節點之間的路徑長度由它們之間的邊數表示。
示例 1:
輸入:
5
/ \
4 5
/ \ \
1 1 5
輸出:
2
示例 2:
輸入:
1
/ \
4 5
/ \ \
4 4 5
輸出:
2
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def longestUnivaluePath(self, root: TreeNode) -> int:
self.ans = 0
def arrow_length(node):
if not node: return 0
left_length = arrow_length(node.left)
right_length = arrow_length(node.right)
left_arrow = right_arrow = 0
if node.left and node.left.val == node.val:
left_arrow = left_length+1
if node.right and node.right.val == node.val:
right_arrow = right_length+1
self.ans = max(self.ans,left_arrow+right_arrow)
return max(left_arrow,right_arrow)
arrow_length(root)
return self.ans
難度簡單86
給定一個 N 叉樹，返回其節點值的前序遍歷。
例如，給定一個 3叉樹 :
返回其前序遍歷: [1,3,5,6,2,4]。
"""
# Definition for a Node.
class Node:
def __init__(self, val=None, children=None):
self.val = val
self.children = children
"""
class Solution:
def preorder(self, root: 'Node') -> List[int]:
res =[]
self.helper(root,res)
return res
def helper(self,root,res):
if not root:
return
res.append(root.val)
children = root.children
for child in children:
self.helper(child,res)
難度簡單76
給定一個二叉樹，計算整個樹的坡度。
一個樹的節點的坡度定義即爲，該節點左子樹的結點之和和右子樹結點之和的差的絕對值。空結點的的坡度是0。
整個樹的坡度就是其所有節點的坡度之和。
示例：
輸入：
1
/ \
2 3
輸出：1
解釋：
結點 2 的坡度: 0
結點 3 的坡度: 0
結點 1 的坡度: |2-3| = 1
樹的坡度 : 0 + 0 + 1 = 1
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.sum_=0
def findTilt(self, root: TreeNode) -> int:
def find(root):
if not root:
return 0
if root.left:
left = root.left.val+find(root.left)
else:
left=0
if root.right:
right=root.right.val + find(root.right)
else:
right = 0
self.sum_+=(abs(left-right))
return left+right
find(root)
return self.sum_
難度簡單311
給定兩個非空二叉樹 s 和 t，檢驗 s 中是否包含和 t 具有相同結構和節點值的子樹。s 的一個子樹包括 s 的一個節點和這個節點的所有子孫。s 也可以看做它自身的一棵子樹。
示例 1:
給定的樹 s:
3
/ \
4 5
/ \
1 2
給定的樹 t：
4
/ \
1 2
返回 true，因爲 t 與 s 的一個子樹擁有相同的結構和節點值。
示例 2:
給定的樹 s：
3
/ \
4 5
/ \
1 2
/
0
給定的樹 t：
4
/ \
1 2
返回 false。
# 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 isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
if not t:
return True
if not s:
return False
return self.isSame(s,t) or self.isSubtree(s.left,t) or self.isSubtree(s.right,t)
def isSame(self,p,q):
if not p and not q:
return True
if not p or not q:
return False
return p.val == q.val and self.isSame(p.left,q.left) and self.isSame(p.right,q.right)
難度簡單132
給定一個非空二叉樹, 返回一個由每層節點平均值組成的數組。
示例 1：
輸入：
3
/ \
9 20
/ \
15 7
輸出：[3, 14.5, 11]
解釋：
第 0 層的平均值是 3 , 第1層是 14.5 , 第2層是 11 。因此返回 [3, 14.5, 11] 。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
if not root:
return []
next_layer =[root.left,root.right]
result = [float(root.val)]
while (next_layer):
temp_next_layer = list()
layer_value = list()
for node in next_layer:
if not node:
continue
temp_next_layer.append(node.left)
temp_next_layer.append(node.right)
layer_value.append(node.val)
if layer_value:
result.append(sum(layer_value)/float(len(layer_value)))
next_layer = temp_next_layer
return result
難度簡單119
給你一棵所有節點爲非負值的二叉搜索樹，請你計算樹中任意兩節點的差的絕對值的最小值。
示例：
輸入：
1
\
3
/
2
輸出：
1
解釋：
最小絕對差爲 1，其中 2 和 1 的差的絕對值爲 1（或者 2 和 3）。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def getMinimumDifference(self, root: TreeNode) -> int:
vals =[]
def dfs(node):
if node:
vals.append(node.val)
dfs(node.left)
dfs(node.right)
dfs(root)
vals.sort()
return min(vals[i+1]-vals[i] for i in range(len(vals)-1))
難度簡單151
給定一個二叉搜索樹和一個目標結果，如果 BST 中存在兩個元素且它們的和等於給定的目標結果，則返回 true。
案例 1:
輸入:
5
/ \
3 6
/ \ \
2 4 7
Target = 9
輸出: True
案例 2:
輸入:
5
/ \
3 6
/ \ \
2 4 7
Target = 28
輸出: False
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def findTarget(self, root: TreeNode, k: int) -> bool:
def inorder(root):
if not root:
return []
return inorder(root.left)+[root.val]+inorder(root.right)
number = inorder(root)
n=len(number)
i=0
j=n-1
while i<j:
if number[i]+number[j]>k:
j-=1
elif number[i]+number[j]<k:
i+=1
else:
return True
return False