代码随想录算法训练营Day 15|二叉树Part02|层序遍历10题、226.翻转二叉树 、101.对称二叉树 2

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量347 收藏 6
点赞数 5
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51759998/article/details/137378916
版权

代码随想录算法训练营Day 15|二叉树Part02|层序遍历10题、226.翻转二叉树 、101.对称二叉树 2

文章目录

层序遍历

102. 二叉树的层序遍历

题目链接

# 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):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level.append(node.val)
                size -=1
            result.append(level)
        return result

107. 二叉树的层序遍历 II

题目链接

# 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):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if node.left :
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level.append(node.val)
                size -=1
            result.append(level)
        return result[::-1]

199. 二叉树的右视图

题目链接

# 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):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        queue=collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level.append(node.val)
                size -=1
            result.append(level[-1])
        return result

637. 二叉树的层平均值

题目链接

# 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):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if not root:
            return []
        queue=collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                size -=1
            result.append(float(sum(level))/float(len(level)))
        return result

429. N 叉树的层序遍历

题目链接

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                level.append(node.val)
                for child in node.children:
                    queue.append(child)
                size -=1
            result.append(level)
        return result

515. 在每个树行中找最大值

题目链接

# 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):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        queue = collections.deque()
        queue.append(root)
        result = []
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level.append(node.val)
                size -=1
            result.append(max(level))
        return result

116. 填充每个节点的下一个右侧节点指针

题目链接

"""
# 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
        """
        if not root:
            return None
        queue = collections.deque()
        queue.append(root)
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if size>1:
                    node.next = queue[0]
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right) 
                size -=1
        return root

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

题目链接
与116题完全一样的代码

"""
# 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
        """
        if not root:
            return None
        queue = collections.deque()
        queue.append(root)
        while queue:
            size = len(queue)
            level = []
            while size:
                node = queue.popleft()
                if size>1:
                    node.next = queue[0]
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right) 
                size -=1
        return root

104. 二叉树的最大深度

题目链接

递归遍历

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 递归遍历
        if not root:
            return 0
        leftheight = self.maxDepth(root.left)
        rightheight = self.maxDepth(root.right)
        return max(leftheight,rightheight)+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
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        #层序遍历
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        result = 0
        while queue:
            size = len(queue)
            while size:
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                size -=1
            result += 1
        return result

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
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        #层序遍历
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        result = 1
        while queue:
            size = len(queue)
            while size:
                node = queue.popleft()
                if not node.left and not node.right:
                    return result
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                size -=1
            result += 1
        return result

递归遍历

# 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):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 递归遍历
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        min_depth = float('inf')
        if root.left:
            min_depth = min(self.minDepth(root.left),min_depth)
        if root.right:
            min_depth = min(self.minDepth(root.right),min_depth)
        return min_depth+1

226.翻转二叉树

题目链接

一、前序遍历

递归法

# 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):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        # 前序遍历
        if not root:
            return None
        root.left,root.right = root.right,root.left #中
        self.invertTree(root.left)                  #左
        self.invertTree(root.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: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        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: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        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: TreeNode) -> TreeNode:
        if not root: 
            return None

        queue = collections.deque([root])    
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root

101.对称二叉树

题目链接

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树）

一、递归

# 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):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: 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: TreeNode) -> bool:
        if not root:
            return True
        # 直接加入left和right 若无left和right或不对称，则直接会在while循环return
        queue = collections.deque([root.left, root.right])
        
        while queue:
            level_size = len(queue)
            
            if level_size % 2 != 0:
                return False
            
            level_vals = []
            for i in range(level_size):
                node = queue.popleft()
                if node:
                    level_vals.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    level_vals.append(None)
            # 若正序和倒序不同      
            if level_vals != level_vals[::-1]:
                return False
            
        return True

三、本题总结

m0_51759998
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
代码随想录算法训练营DAY15|C++二叉树Part.2|102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树
糖炒栗子
04-03 1317
状态：对于二叉树的题，往往会涉及到遍历顺序，此题要求反转二叉树，也就每个结点的左右孩子进行反转，最直观的应该当属前序遍历或者后序遍历。返回值本来是不需要的，但是题目中要求给出返回root结点的指针，我们就直接使用题目定义好的函数。由于其并不是把当前层遍历完再去遍历下一层的规则，所以层序遍历的递归法总体还是比较难懂的。这样遍历主要是因为，左子树的左侧对应右子树的右侧，左子树的右侧对应右子树的左侧。左右都不空，但是结点数值不相等；二叉树类的题目，确定遍历深度是非常重要的，决定了我们对题目理解的深度。
代码随想录算法训练营Day15|二叉树Part02|层序遍历||226翻转二叉树||101对称二叉树
luyimin87的博客
04-07 894
层序遍历看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。226.翻转二叉树 （优先掌握递归）这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。101. 对称二叉树 （优先掌握递归）先看视频讲解，会更容易一些。
代码随想录算法训练营day15||二叉树part02、102.二叉树的层序遍历、 226.翻转二叉树（优先掌握递归）、101. 对称二叉树 （优先掌握递归）
qq_40222433的博客
02-09 793
二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。102.二叉树的层序遍历(opens new window)107.二叉树的层次遍历II(opens new window)199.二叉树的右视图(opens new window)637.二叉树的层平均值(opens new window)429.N叉树的层序遍历(opens new window)515.在每个树行中找最大值(opens new window)
代码随想录算法训练营day15 | 102.层序遍历 、226.翻转二叉树 、101.对称二叉树
m0_56522407的博客
01-10 839
'NoneType' object has no attribute 'val' ^^^^^^^ level.append(cur.val) 这是因为没有在最开始考虑到二叉树为空的情况。原代码版本上每层只放最右的节点（level的最后一个数）：result.append(level[-1])先独立做题，然后看视频讲解，然后看文章讲解，然后再重新做一遍题，把题目AC，最后整理成今日当天的博客。遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。，这是不必要的，因为在创建。
【代码随想录算法训练营Day15】●102.二叉树的层序遍历；● 226.翻转二叉树；● 101.对称二叉树 2
Tammy2001的博客
02-09 392
【代码】【代码随想录算法训练营Day15】●102.二叉树的层序遍历；● 226.翻转二叉树；● 101.对称二叉树 2。
代码随想录训练营 Day15 二叉树 part02 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
gfxgu的博客
05-24 67
中序（左中右）为什么不行，我们思考一下，我们一开始对左子树进行反转，接着通过中，将左右子树反转，那我这个右反转的不还是原来的左子树吗？记录每一层的元素，由于经过for里的删减增加 que.siz()会随之改变。这道题我觉得难度并不大，也并没有运用到啥算法，主要还是对二叉树的理解。再解决这道题之前，我们要了解swap函数可以实现一个节点左右孩子的交换。二叉树的层序遍历：即逐层地，从左到右访问所有节点。3.两边都不为空，且值不同，返回false。1.一边为空，一边不为空，返回false。这道题可以用递归解决。
代码随想录算法训练营Day15|LC226 翻转二叉树&LC101 对称二叉树（二叉树part2）
qq_62428331的博客
03-06 208
一句话总结，虽然递归很方便很容易理解但真的不会写啊orz。
代码随想录-算法训练营day15【二叉树02：层序遍历、翻转二叉树、对称二叉树】
upward
04-17 352
代码随想录-算法训练营day15【二叉树02：层序遍历、翻转二叉树、对称二叉树】
代码随想录算法训练营Day15| 二叉树part02
weixin_57654532的博客
09-06 60
用迭代的方式写比较容易理解。
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
C++数据结构与算法二叉树的层序遍历代码及注释
04-02
C++数据结构与算法二叉树的层序遍历代码及注释
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 255
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 332
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 462
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 593
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值