代码随想录算法训练营day15 | 层序遍历（广度优先搜索）

已于 2022-10-07 13:48:26 修改
阅读量148 收藏
点赞数
文章标签： 宽度优先 深度优先 数据结构
于 2022-10-06 13:45:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzh013/article/details/127179758
版权

层序遍历（level order traversal）：

  • trick：深度优先遍历用栈，层序优先遍历用队列

题目：

  • 102.二叉树的层序遍历（medium）

    • 迭代法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        
        ans = []
        q = deque() #层序遍历（广度优先遍历）用队列
        
        if root is None:
            return ans
        else:
            q.append(root) #传入二叉树
   
        while q:
            size = len(q)
            temp = []
            for _ in range(size):
                node = q.popleft()
                temp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            ans.append(temp) 
        return ans

  • 递归法

# 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]]:
        
        ans = []
        
        def helper(root, depth): #step1
            #step2: 终止条件（base condition）
            if root is None:
                return ans
            #step3: logic
            if len(ans) == depth:
                ans.append([]) #到达一层之后，要新增一个空list来存这一层的元素（指针）
            ans[depth].append(root.val)
            if root.left:
                helper(root.left, depth+1)
            if root.right:
                helper(root.right,depth+1)
        
        helper(root, 0) #从根节点层开始
        return ans

  • 107.二叉树的层次遍历II（medium）

    • 与102一样解法，迭代法 + 递归法, 只是返回ans[::-1]

  • 199.二叉树的右视图（medium）

    • 第一次写错误点如下：
    1. 以为只把右子树加入队列就好了
    2. 以为判断左子树不为空同时右子树为空，这样就能看到左子树的元素
    3. 经过上面两个错误，终于想到了只需要往结果集里加入每层最后一个元素就好。但是写的时候没想到可以直接q[-1]取到这个值
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        q = deque()
        
        if root is None:
            return ans
        else:
            q.append(root)
            
        while q:
            size = len(q)
            for _ in range(size):
                node = q.popleft()
                ans.append(node.val)
                #if node.left and node.right is None:
                #    q.append(node.left)
                if node.right:
                    q.append(node.right)
            
        return ans

  •         迭代法：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        q = deque()
        
        if root is None:
            return ans
        else:
            q.append(root)
            
        while q:
            size = len(q)
            node = q[-1]
            ans.append(node.val)
            for i in range(size):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            
        return ans

  •         递归法：

    • 依旧是取每一层的最后一个元素，那么就在最后增加一个遍历并添加到结果集
# 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]:
        
        ans = []
        temp = []
        def helper(root,depth): #step1
            #step2
            if root is None:
                return ans
            
            #step3
            if len(temp) == depth:
                temp.append([])
            temp[depth].append(root.val)
            if root.left:
                helper(root.left,depth+1)
            if root.right:
                helper(root.right,depth+1)
                
        helper(root,0)
        for i in range(len(temp)):
            ans.append(temp[i][-1])
        return ans

  • 637.二叉树的层平均值

    • 与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

from collections import deque

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        
        ans = []
        q = deque()
        
        if root is None:
            return ans
        else:
            q.append(root)
            
        while q:
            size = len(q)
            temp = []
            for _ in range(size):
                node = q.popleft()
                temp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
                
            ans.append(sum(temp) / len(temp))
                
        return ans

  •         递归法

    • 二刷时可以试试在helper内部是否可以实现求均值，目前这个写法只是非常直观。
# 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]:
        ans = []
        
        def helper(root, depth): #step1
            #step2
            if root is None:
                return ans
            #step3
            if len(ans) == depth:
                ans.append([])
            ans[depth].append(root.val)
            
            if root.left:
                helper(root.left, depth+1)
            if root.right:
                helper(root.right, depth+1)
            
        helper(root, 0)
        
        for i in range(len(ans)):
            ans[i] = sum(ans[i]) / len(ans[i])
        return ans

  • 429.N叉树的层序遍历（medium）

    • 注意N-ary树的定义

    • 错误点：首先完全按照模版来写， 通过打印type(root.children)，知道children是一个list

    • 然后想取到这个list之后对其遍历然后加入temp数组，但结果报错说tree node不支持getitem

    • 参考题解发现只是改动了extend，因为children是一个list

extend用法；

# create a list
prime_numbers = [2, 3, 5]

# create another list
numbers = [1, 4]

# add all elements of prime_numbers to numbers
numbers.extend(prime_numbers)


print('List after extend():', numbers)

# Output: List after extend(): [1, 4, 2, 3, 5]

  •         题解：

    • 迭代法

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
from collections import deque

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        
        ans = []
        q = deque()
        
        if root is None:
            return ans
        else:
            q.append(root)
            
        while q:
            size = len(q)
            temp = []
            for _ in range(size):
                node = q.popleft()
                temp.append(node.val)
                if node.children:
                    q.extend(node.children)
                
            ans.append(temp)
            
        return ans

  •         递归法

"""
# 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]]:
        
        ans = []
        
        def helper(root, depth): #step1
            #step2
            if root is None:
                return ans
            #step3
            if len(ans) == depth:
                ans.append([])
            ans[depth].append(root.val)
            
            if root.children:
                for child in root.children:
                    helper(child, depth+1)
            
        helper(root, 0)
        return ans

  • 515.在每个树行中找最大值（medium）

    • 与102实际上是一样的，迭代法 + 递归法, 只需要将每个temp的最大值存到结果集即可。

  • 116.填充每个节点的下一个右侧节点指针（medium）

    • 迭代法

思路：

"""
# 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
"""

from collections import deque

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        
        q = deque()
        
        if root is None:
            return None
        else:
            q.append(root)
            
        while q:
            cur = q.popleft()
            if cur.left: #perfect binary tree, if cur.left is not None, then cur.right is also not None.
                cur.left.next = cur.right
                if cur.next: 
                    cur.right.next = cur.next.left
                    
                q.append(cur.left)
                q.append(cur.right)
        
        return root

  • 递归法

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        
        def helper(root): #step1
            #step2
            if root is None:
                return None
            
            #step3
            if root.left:
                root.left.next = root.right
                if root.next:
                    root.right.next = root.next.left
                    
                helper(root.left)
                helper(root.right)
        
        helper(root)
        return root

  • 117.填充每个节点的下一个右侧节点指针II（medium）

    • 看一下youtube视频

  • 104.二叉树的最大深度

    • 与102实际上是一样的，迭代法 + 递归法, 只是最后需要返回len(ans)

    • 除了上面的解法，也可以与111一样的解法：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        
        q = deque()
        if root is None:
            return 0
        else:
            q.append(root)
        
        depth = 0
        while q:
            size = len(q)
            depth += 1
            for _ in range(size):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
                    
        return depth

  • 111.二叉树的最小深度

    • trick: 只有当左子树和右子树同时为空时，说明遍历到了距离最短的最低点了

    • 因此，为了统一，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

from collections import deque

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        
        q = deque()
        if root is None:
            return 0
        else:
            q.append(root)
        
        depth = 0
        while q:
            size = len(q)
            depth += 1
            for _ in range(size):
                node = q.popleft()
                
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
                
                if (not node.left) and (not node.right):
                    return depth
        # return depth

  • 226.翻转二叉树: 

    • trick：将左右叶子结点互换

    • 需要清楚用的是什么遍历方式

    • 迭代法-广度优先遍历：

# 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

from collections import deque

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        
        q = deque()
        if root is None:
            return None
        else:
            q.append(root)
            
        while q:
            size = len(q)
            for _ in range(size):
                node = q.popleft()
                node.left, node.right = node.right, node.left
                
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
                    
        return root

  • 迭代法-深度优先遍历（前序）：

# 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]:
        
        stack = []
        if root is None:
            return root
        else:
            stack.append(root)
            
        while stack:
            node = stack.pop()
            node.left, node.right = node.right, node.left
            
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
            
        return root

  • 递归法（前序遍历）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    #因为要求返回root，那么就可以直接用题目定义好的函数
    def invertTree(self, root): #step1
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        #step2
        if root is None:
            return root
        #step3
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        
        return root

  • 101. 对称二叉树

    • 思路：对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的。因此要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树（也是函数需要的参数）。

    • 经过分析，本题遍历只能是“后序遍历”，因为要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。只有在比较了左和右之后，并把信息返回给中，这样才能判断左右子树是否可以相互翻转。因此顺序是 左右中-->后序遍历。

    • 递归法：（参考代码随想录）

      • 递归三部曲以及对应分析

  • 100.相同的树

  • 572.另一个树的子树

总结：

  1. 要深刻理解解题思路，很多题只是不同的问法而已，实际上都是一样的，只是最后需要添加到结果集的元素不一样。

  2. 针对二叉树的问题，解题之前一定要想清楚用哪种遍历方式，究竟是前中后序遍历，还是层序遍历。

  3. 深度优先遍历借助栈， 广度优先遍历借助队列。

  4. 回看深度优先遍历的写法，除了借助栈之外，其实逻辑和写法是一样的。

  5. 对于对称二叉树还需继续研究，以及相似的两道题。详细的分析看代码随想录。

jzh013
关注
代码随想录算法训练营Day15|层序遍历，翻转二叉树，对称二叉树
WEnyue4261的博客
01-27 1091
翻转二叉树也可以使用迭代法，但要注意，这里迭代法不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。判断对称二叉树要比较的是哪两个节点，要比较的不是左右节点，而是两个树，这个树是根节点的左右子树，所以在递归遍历的过程中，也要同时遍历两棵树。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。节点为空的情况有：（注意！比较的是左右节点，是节点，不是左右孩子）
代码随想录算法训练营Day13 | 递归遍历、迭代遍历、层序遍历
jiabao0520的博客
09-24 997
训练营第13天：144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历、102.二叉树的层序遍历、107.二叉树的层序遍历Ⅱ、199.二叉树的右视图、637.二叉树的层平均值、429.N叉树的层序遍历、515. 在每个树行中找最大值、116. 填充每个节点的下一个右侧节点指针、117. 填充每个节点的下一个右侧节点指针 Ⅱ、104.二叉树的最大深度、111.二叉树的最小深度。
代码随想录算法训练营day15| 层序遍历 226.翻转二叉树
Anzerwhite的博客
05-23 687
层序遍历，将每个弹出的元素的next指向队列中的front元素，并将每层最后一个元素指向nil。层序遍历，遇到叶子节点（左右子节点均为空）时即返回当前的depth。时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)时间复杂度O(n) 空间复杂度O(n)同理，将原来的遍历两个节点变成遍历n个节点。层序遍历后获取每层最右边的元素即可。层序遍历后，对每层的元素求和即可。层序遍历，记录最大值即可。
代码随想录算法训练营day15 || 二叉树的层序遍历知识学习
旭
01-10 924
二叉树的层次遍历就是图论中的广度优先遍历，是一种规律很足的遍历方式。我们在前一个章节学习了前序、中序、后序的遍历思想，这三种思想为我们完整获取树上各节点的值提供了可行的方法，而广度优先以及深度优先两种遍历方式便是应对树型结构其他问题的有效解题方法。深度遍历的策略非常简单，其与中序遍历思想非常接近，在涉及树的高度等题目中被广泛的使用；而广度优先遍历，是操作节点之间连接、树型结构找规律等题目中被有效的应用。掌握这两类方式对于解二叉树甚至N叉树相关的题目非常关键。
代码随想录算法训练营Day12|递归遍历 、 迭代遍历 、统一迭代 、层序遍历
weixin_44426359的博客
08-13 235
当队列不为空时，记录当前队列的长度（首次只有头节点，长度为一）。当长度大于0时，遍历和长度相等数量的节点，每遍历一个，将其左右孩子节点入队。按照size数量遍历取出当前层的节点，取出一个就将其左右孩子节点入队，并且记录取出的元素。while循环：当节点不为空时，弹出栈顶元素存入临时变量，元素值入栈。创建队列，根节点入队。while循环，队列不为空时，创建一个记录的当前层的一维数组。思路：遍历过程一样，只有当遍历到每一层的最后一个节点时，添加进结果集合。代码框架：定义存结果的数组，如果根节点为空，直接返回。
代码随想录算法训练营day15| 层序遍历、226.翻转二叉树、101. 对称二叉树
weixin_45368277的博客
12-21 1513
二叉树遍历
代码随想录算法训练营 Day15｜层序遍历10, 226.翻转二叉树, 101.对称二叉树 2
Jiahui_0020的博客
03-06 954
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。层序遍历方式就是图论中的广度优先遍历。需要借用一个辅助数据结构即队列来实现，，而用。
代码随想录算法训练营day15| 层序遍历、226. 翻转二叉树、101. 对称二叉树
zwq54argfun的博客
01-25 395
层序遍历是图论中的广度优先搜索在二叉树中的应用，使用队列这种数据结构实现，一共十道题，大同小异，因此只贴这一道题的代码。该题解法和100.相同的树、101.对称二叉树解法类似。迭代法同时迭代左右子树。572、另一棵树的子树。
代码随想录算法训练营Day15 | 层序遍历 | 226. 翻转二叉树 | 101. 对称二叉树
Kolbe_Huang的博客
07-28 243
递归的思路是较为简单的，在单层遍历中，交换当前节点的左右子节点即可。这题和上一题最大的不同在于，递归中的单层逻辑不能仅依靠当前节点的子节点（例如，比较子节点是否相等），还需要子节点的子节点。这里要比较的是外侧与外侧节点，内侧与内侧节点，所以对于左右子树来说，遍历（比较）顺序应该是相反的，即一个子树是“左右中”，一个子树是“右左中”。此题的重点思路是，只有完成了子节点（的子节点）的比较，才能得知当前节点的信息，从而决定是向上传递还是可以直接返回。遍历，即“当前节点的信息依赖于子节点的信息”。
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 412
代码随想录算法训练营Day14|二叉树重点理论基础、递归遍历
m0_60979177的博客
12-20 1312
Day14打卡！今日感想：今天开启二叉树篇章！主要学习了递归法的遍历，之前学的有一点“浮于表面”，要注重学习基本逻辑，尽量把问题的根本理解透彻。
代码随想录算法训练营day39|leetcode62/63
weixin_53153619的博客
11-29 506
第二个路径不太行 第一个题还可以 中等的动态规划几乎 不太会
代码随想录算法训练营day 60 |84.柱状图中最大的矩形
wuhuqifei123的博客
02-08 352
代码随想录算法训练day60
代码随想录算法训练营Day3 | 链表理论基础，203.移除链表元素，707.设计链表，206.反转链表
little__penguin的博客
06-08 397
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5155
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 486
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 335
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
数据结构-4.1.特殊矩阵的压缩存储
ADCvbV的博客
10-01 1041
1.知道一维数组的起始地址，就可以求出任意下标对应的元素所在的地址；2.注：如果数组下标从1开始，上述公式的i就要改为i-1；3.数组里的元素类型相同，因此所占空间也相同。1.注：数组的存储是连续(计算机的存储是线性的)的，针对非线性的二维数组，为了将其拉成线性结构，就有了行优先和列优先两种存储方式；2.将非线性的二维数组整成线性的好处就是可以实现随机存取；3.行优先时计算存储地址：公式中i为行，j为列4.列优先时计算存储地址：公式中i为行，j为列由于对称矩阵关于主对角线对称，因此在存储对称矩阵的数据时只需
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值