层序遍历 10
- 102.二叉树的层序遍历
注意一开始要定义一个二维数组,一个个一维数组组成二维数组
# 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]]:
results = [] #二维数组
if not root:
return results
from collections import deque
que = deque([root]) #把根节点加入队列里
#开始遍历,终止条件是队列空
while que:
size = len(que)
result = [] #一维数组
for _ in range(size):
cur = que.popleft()
result.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
results.append(result)
return results
- 107.二叉树的层次遍历II
# 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]]:
results = []
if not root:
return results
from collections import deque
que = deque([root])
while que:
result = []
size = len(que)
for _ in range(size):
cur = que.popleft()
result.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
results.append(result)
results.reverse()
return results
- 199.二叉树的右视图
每次都取最后一个node
# 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 []
from collections import deque
que = deque([root])
result = []
while que:
node = que[-1]
result.append(node.val)
size = len(que)
for _ in range(size):
node = que.popleft()
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
return result
- 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]:
result = []
if not root:
return result
from collections import deque
que = deque([root])
while que:
size = len(que)
sum = 0
for _ in range(size):
cur = que.popleft()
sum += cur.val
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
result.append(sum/size)
return result
- 429.N叉树的层序遍历
list.extend(L) 通过添加指定列表的所有元素来扩充列表,相当于 a[len(a):]= L
"""
# 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]]:
results = []
if not root:
return results
from collections import deque
que = deque([root])
while que:
result = []
size = len(que)
for _ in range(size):
cur = que.popleft()
result.append(cur.val)
if cur.children:
que.extend(cur.children)
results.append(result)
return results
- 515.在每个树行中找最大值
class Solution:
def largestValues(self, root: TreeNode) -> List[int]:
if root is None:
return []
queue = [root]
out_list = []
while queue:
length = len(queue)
in_list = []
for _ in range(length):
curnode = queue.pop(0)
in_list.append(curnode.val)
if curnode.left: queue.append(curnode.left)
if curnode.right: queue.append(curnode.right)
out_list.append(max(in_list))
return out_list
- 116.填充每个节点的下一个右侧节点指针
class Solution:
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return
que = [root]
while que:
size = len(que)
for i in range(size):
node = que.pop(0)
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
if i == size - 1:
break
node.next = que[0]
return root
- 117.填充每个节点的下一个右侧节点指针II
class Solution:
def connect(self, root: 'Node') -> 'Node':
if not root:
return
que = [root]
while que:
size = len(que)
tail = None
for i in range(size):
cur = que.pop(0)
if tail:
tail.next = cur
tail = cur
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.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 root == None:
return 0
que = [root]
depth = 0
while que:
size = len(que)
for i in range(size):
node = que.pop(0)
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
depth += 1
return depth
- 111.二叉树的最小深度
# 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 minDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
que = [root]
res = 1 #初始值为1
while que:
size = len(que)
for _ in range(size):
node = que.pop(0)
if not node.left and not node.right:
return res
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
res += 1
class Solution:
def minDepth(self, root: TreeNode) -> int:
if root == None:
return 0
#根节点的深度为1
queue_ = [(root,1)]
while queue_:
cur, depth = queue_.pop(0)
if cur.left == None and cur.right == None:
return depth
#先左子节点,由于左子节点没有孩子,则就是这一层了
if cur.left:
queue_.append((cur.left,depth + 1))
if cur.right:
queue_.append((cur.right,depth + 1))
return 0
226.翻转二叉树
注意只要把每一个节点的左右孩子翻转一下,就可以达到整体翻转的效果
使用前序遍历和后序遍历都比较方便,唯独中序遍历,因为中序遍历会把某些节点的左右孩子翻转了两次,所以中序遍历需要处理两边左孩子
# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
#递归法
# if not root:
# return None
#前序
# root.left,root.right = root.right,root.left
# self.invertTree(root.left)
# self.invertTree(root.right)
# return root
#后序
# self.invertTree(root.left)
# self.invertTree(root.right)
# root.left,root.right = root.right,root.left
# return root
#中序
# self.invertTree(root.left)
# root.left,root.right = root.right,root.left
# self.invertTree(root.left)
# return root
#迭代法
#深度优先遍历(前序遍历)
# if not root:
# return None
# que = [root]
# while que:
# node = que.pop()
# node.left,node.right = node.right,node.left #中
# if node.right:
# que.append(node.right) #右
# if node.left:
# que.append(node.left) #左
# return root
#迭代法
#广度优先遍历(层序遍历)
# if not root:
# return None
# que = [root]
# while que:
# size = len(que)
# for i in range(size):
# node = que.pop(0)
# node.left,node.right = node.right,node.left
# if node.left:
# que.append(node.left)
# if node.right:
# que.append(node.right)
# return root
101.对称二叉树 2
难点一:为什么要用后序遍历
因为要从下往上,才能告诉父节点,下面两个可以互相翻转,也就是左右中,后序
难点二:如何比较,用左孩子的左孩子和右孩子的右孩子比较
# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
return self.compare(root.left,root.right)
def compare(self,left,right):
#排除空节点的情况
if left == None and right != None: return False
elif left != None and right == None: return False
elif left == None and right == None: return True
#排除排除数值不相同的情况
elif left.val != right.val: return False
#此时就是:左右节点都不为空,且数值相同的情况
#此时才做递归,做下一层的判断
outside = self.compare(left.left,right.right)#左子树:左、 右子树:右
inside = self.compare(left.right,right.left) #左子树:右、 右子树:左
isSame = outside and inside #左子树:中、 右子树:中 (逻辑处理)
return isSame
迭代法 使用队列
import collections
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
queue = collections.deque()
queue.append(root.left) #将左子树头结点加入队列
queue.append(root.right) #将右子树头结点加入队列
while queue: #接下来就要判断这这两个树是否相互翻转
leftNode = queue.popleft()
rightNode = queue.popleft()
if not leftNode and not rightNode: #左节点为空、右节点为空,此时说明是对称的
continue
#左右一个节点不为空,或者都不为空但数值不相同,返回false
if not leftNode or not rightNode or leftNode.val != rightNode.val:
return False
queue.append(leftNode.left) #加入左节点左孩子
queue.append(rightNode.right) #加入右节点右孩子
queue.append(leftNode.right) #加入左节点右孩子
queue.append(rightNode.left) #加入右节点左孩子
return True
迭代法:使用栈
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
st = [] #这里改成了栈
st.append(root.left)
st.append(root.right)
while st:
rightNode = st.pop()
leftNode = st.pop()
if not leftNode and not rightNode:
continue
if not leftNode or not rightNode or leftNode.val != rightNode.val:
return False
st.append(leftNode.left)
st.append(rightNode.right)
st.append(leftNode.right)
st.append(rightNode.left)
return True
层序遍历
class Solution:
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
que = [root]
while que:
this_level_length = len(que)
for i in range(this_level_length // 2):
# 要么其中一个是None但另外一个不是
if (not que[i] and que[this_level_length - 1 - i]) or (que[i] and not que[this_level_length - 1 - i]):
return False
# 要么两个都不是None
if que[i] and que[i].val != que[this_level_length - 1 - i].val:
return False
for i in range(this_level_length):
if not que[i]: continue
que.append(que[i].left)
que.append(que[i].right)
que = que[this_level_length:]
return True
- 今日学习的文章链接
- 自己看到题目的第一想法
毫无头绪
- 看完代码随想录之后的想法
- 自己实现过程中遇到哪些困难
- 今日收获,记录一下自己的学习时长