102.二叉树层序遍历
对队列中弹出的元素加以控制
最终结果用二维数组保存
类似于广度优先
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
levels = []
self.helper(root, 0, levels)
return levels
def helper(self, node, level, levels):
if not node:
return
if len(levels) == level:
levels.append([])
levels[level].append(node.val)
self.helper(node.left, level + 1, levels)
self.helper(node.right, level + 1, levels)
好的,我们以输入 [3, 9, 20, null, null, 15, 7]
为例,使用递归的隐式栈来描述整个过程。这里的树结构如下:
以下是递归的隐式栈过程:
-
调用
levelOrder(root)
:root
是根节点3
。- 创建一个空列表
levels
,然后调用helper(root, 0, levels)
。
-
调用
helper(node=3, level=0, levels)
:- 将节点值
3
添加到levels[0]
,现在levels = [[3]]
。 - 递归调用
helper(node=9, level=1, levels)
。
- 将节点值
-
调用
helper(node=9, level=1, levels)
:- 将节点值
9
添加到levels[1]
,现在levels = [[3], [9]]
。 - 递归调用
helper(node=20, level=1, levels)
。
- 将节点值
-
调用
helper(node=20, level=1, levels)
:- 将节点值
20
添加到levels[1]
,现在levels = [[3], [9, 20]]
。 - 递归调用
helper(node=15, level=2, levels)
。
- 将节点值
-
调用
helper(node=15, level=2, levels)
:- 将节点值
15
添加到levels[2]
,现在levels = [[3], [9, 20], [15]]
。 - 递归调用
helper(node=7, level=2, levels)
。
- 将节点值
-
调用
helper(node=7, level=2, levels)
:- 将节点值
7
添加到levels[2]
,现在levels = [[3], [9, 20], [15, 7]]
。 - 递归调用
helper(node=None, level=3, levels)
(因为节点7
的左右子节点都为None
)。
- 将节点值
-
递归返回到上一层
helper(node=15, level=2, levels)
:- 递归调用结束,返回到上一层。
-
递归返回到上一层
helper(node=20, level=1, levels)
:- 递归调用结束,返回到上一层。
-
递归返回到上一层
helper(node=9, level=1, levels)
:- 递归调用结束,返回到上一层。
-
递归返回到上一层
levelOrder(root)
:- 递归调用结束,最终返回
levels = [[3], [9, 20], [15, 7]]
。
- 递归调用结束,最终返回
这就是使用递归的隐式栈来描述输入 [3, 9, 20, null, null, 15, 7]
的层序遍历过程。
# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root:
return []
queue=collections.deque([root])#构建对列
result=[]
while queue:
level=[]
for _ in range(len(queue)):
cur=queue.popleft()
level.append(cur.val)
if cur.left:
queue.append(cur.left)
if cur.right:
queue.append(cur.right)
result.append(level)
return result
107.二叉树的遍历(自底向上)
# 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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root:#如果为空,返回空数组
return []
queue=collections.deque([root])
result=[]
while queue:
level=[]
for _ in range(len(queue)):
cur=queue.popleft()
level.append(cur.val)
if cur.left:
queue.append(cur.left)
if cur.right:
queue.append(cur.right)
result.append(level)
return result[::-1]
199.二叉树的右视图
层次遍历找到每一层最后节点
# 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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
if not root:
return []
queue=collections.deque([root])
right_review=[]
while queue:
level_size=len(queue)#要存储每一层开始的队列长度
for i in range(len(queue)):
node=queue.popleft()
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
if i==level_size-1:
right_review.append(node.val)
return right_review
637.二叉树的层平均值
# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
if not root:
return []
queue=collections.deque([root])
averages=[]
while queue:
size=len(queue)
level_sum=0
for i in range(size):
node=queue.popleft()
level_sum+=node.val
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
averages.append(level_sum/size)
return averages
429.N叉树的层序遍历
"""
# Definition for a Node.
class Node:
def __init__(self, val=None, children=None):
self.val = val
self.children = children
"""
class Solution:
def levelOrder(self, root: 'Node') -> List[List[int]]:
if not root:
return []
result = []
queue = collections.deque([root])
while queue:
level_size=len(queue)
level=[]
for _ in range(level_size):
node=queue.popleft()
level.append(node.val)
for child in node.children:
queue.append(child)
result.append(level)
return result
515.在每个树行中找最大值
# 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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
if not root:
return []
result = []
queue = collections.deque([root])
while queue:
level_size = len(queue)
max_val = float('-inf')#将一开始的最大值定义为最小
for _ in range(level_size):
node = queue.popleft()
max_val = max(max_val, node.val)#遍历每个点时更新
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
result.append(max_val)
return result
116.填充每个节点的下一个右侧节点指针
本题依然是层序遍历,只不过在单层遍历的时候记录一下本层的头部节点,然后在遍历的时候让前一个节点指向本节点就可以了
"""
# Definition for a Node.
class Node:
def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
self.val = val
self.left = left
self.right = right
self.next = next
"""
class Solution:
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return root
queue = collections.deque([root])
while queue:
level_size=len(queue)
prev=None
for i in range(level_size):
node=queue.popleft()#
if prev:
prev.next=node
prev=node
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return root
104.二叉树的最大深度
# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
#用层序遍历来解决
if not root:
return 0
depth=0
queue=collections.deque([root])
while queue:
depth+=1
for _ in range(len(queue)):
node=queue.popleft()
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return depth
111.二叉树的最小深度
相对于 104.二叉树的最大深度 ,本题还也可以使用层序遍历的方式来解决,思路是一样的。
需要注意的是,只有当左右孩子都为空的时候,才说明遍历的最低点了。如果其中一个孩子为空则不是最低点
class Solution:
def minDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
depth=0
queue=collections.deque([root])
while queue:
depth+=1
for _ in range(len(queue)):
node=queue.popleft()
if not node.left and not node.right:
return depth
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return depth
111.二叉树的最小深度
if not root:
return 0
depth=0
queue=collections.deque([root])
while queue:
depth+=1
for _ in range(len(queue)):
node=queue.popleft()
if not node.left and not node.right:
return depth
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return depth