难度简单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