代码随想录算法训练营第十四天｜ 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

PixcelPrincess

于 2024-07-31 15:59:05 发布

阅读量562

点赞数 9

文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_39981702/article/details/140800861

版权

写在前边的话

今天是二叉树开始的第二天，经过前边的训练，已经对二叉树有了一定的了解，同时也熟悉了通过递归、迭代以及层序遍历二叉树。今天四道题目，看看能不能自己先解决吧，要加油哦！

二叉树基础知识

226.翻转二叉树

题目链接

力扣题目链接

题目难度

简单

看到题目的第一想法

看到这道题目，第一想法是想到了递归的，但是对于单层递归的逻辑没有认识的特别清楚，第二层很容易想到了翻转是交换左右孩子，但是到了第三层就有点懵了，感觉不是简单的交换节点的左右孩子，产生这种想法是我忽略了，第二层其实已经翻转过了，翻转的是指针，这样对二层每个节点的左右孩子也跟着节点一起移动了，所以到了第三层翻转其实也是翻转每个节点的左右孩子就可以了。想明白了这一点代码就很容易写出来了。

python

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

        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

看完代码随想录以后的总结

解题思路

首先，自己写代码的话，仅仅想到用的是递归，但是没具体想是要用前中后序遍历，就糊里糊涂的把代码写出来了，虽然写对了，但是缺乏了进一步的思考。

1.递归法

前序、后序都是比较好写的，回看了下我上边的是前序的递归写法。

中序的话，由于在翻转完左孩子以后，翻转中节点，这样左孩子其实就变成了右孩子，所以后边就不能再对右孩子翻转了，继续要进行的操作是还要翻转左孩子。

2. 迭代法（借助栈）

3. 层序遍历（借助队列）

文章讲解

代码随想录翻转二叉树文章讲解

视频讲解

代码随想录翻转二叉树视频讲解

代码编写

python

递归法

# 后序遍历
# 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 root

        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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        stack = [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:
#     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 root

        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:  # 先入栈左孩子再入栈右孩子
                stack.append(node.left)
            if node.right:
                stack.append(node.right)  
            node.left, node.right = node.right, node.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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:  # 先入栈左孩子再入栈右孩子
                stack.append(node.left)
            node.left, node.right = node.right, node.left
            if node.left:
                stack.append(node.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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        queue = collections.deque([root])
        while queue:
            n = len(queue)
            for i in range(n):
                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

java

101. 对称二叉树

题目链接

力扣101.对称二叉树

题目难度

简单

看到题目的第一想法

看到题目的第一想法想用层序遍历使用队列实现，但是在写代码的过程中，发现我的思路是比较的左右节点，这样就导致最终是没办法完成这道题目的。

看完代码随想录以后的总结

解题思路

1. 整体思路：我们要比较的其实不是左右节点，而是二叉树的两个左右子树，更明确一点是比较这两个子树的里侧和外侧的元素是否相等。

2. 遍历顺序：

递归法（只能使用后序）。

注意：什么样的题目用后序遍历呢？就是需要先收集孩子的信息向上一层返回

递归三部曲：1）入参根节点的左右子节点，返回值布尔值；2）终止条件：左空右不空返回false、左不空右空返回false、左空并且右空返回false、左右都不空但val不相等返回false；3）单层递归逻辑：外侧节点和内侧节点比较（左节点的左孩子和右节点的右孩子比较、左节点的右孩子和右孩子的左节点比较，并以两者与的结果作为最终的结果）。

迭代法（注意不是层序遍历）

可以使用队列、栈或者数组，条件判断和递归是一样的。

文章讲解

代码随想录101. 对称二叉树文章讲解

视频讲解

代码随想录101. 对称二叉树视频讲解

代码编写

python

递归法

# 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 False
        return self.compare(root.left, root.right)
        


    def compare(self, left, right):
        if not left and right:
            return False
        elif left and not right:
            return False
        elif not left and not right:
            return True
        elif left.val != right.val:
            return False

        out_res = self.compare(left.left, right.right)
        in_res = self.compare(left.right, right.left)
        return out_res and in_res

迭代法

# 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 False
        
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            left_node = queue.popleft()
            right_node = queue.popleft()
            if not left_node and not right_node:
                continue
            
            if not left_node or not right_node or left_node.val != right_node.val:
                return False
            
            queue.append(left_node.left) # 左节点左孩子
            queue.append(right_node.right) # 要和左节点左孩子比较的右节点右孩子

            queue.append(left_node.right) # 左节点右孩子
            queue.append(right_node.left) # 要和左节点右孩子比较的右节点左孩子
        
        return True

java

104.二叉树的最大深度

题目链接

力扣104. 二叉树的最大深度

题目难度

简单

看到题目的第一想法

昨天联系层序遍历的时候做过这道题目了，所以第一想法当然是层序遍历啦。

python

# 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

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

看完代码随想录以后的总结

解题思路

深度：二叉树中任意一个节点到根结点的距离 (一般采用前序遍历)

高度：二叉树中任意一个节点到叶子结点的距离（一般采用后序遍历）

根节点的高度即为二叉树的最大深度。

1. 递归法（后序遍历）

递归三部曲：1）入参：二叉树结点；返回值：整数。2）终止条件：节点为空，返回0。3）单次递归逻辑：分别计算左右节点的高度，返回给父亲节点，父亲节点的高度加一。

文章讲解

代码随想录二叉树最大深度文章讲解

视频讲解

代码随想录二叉树最大深度视频讲解

代码编写

python

# 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

        left_height = self.maxDepth(root.left)   # 左
        right_heigth = self.maxDepth(root.right  # 右

        height = 1 + max(left_height, right_heigth)  # 中
        return height

java

111.二叉树的最小深度

题目链接

力扣题目链接

题目难度

简单

看到题目的第一想法

由于昨天刷过，所以看到题目想到的是层序遍历。

python

# 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

        res = 0
        queue = collections.deque([root])
        while queue:
            res += 1
            n = len(queue)
            for i in range(n):
                node = queue.popleft()
                if not node.left and not node.right:
                    return res
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return res

看完代码随想录以后的总结

解题思路

1.使用递归法(后序遍历)

递归三部曲：1）入参：二叉树节点，返回值：整数。2）终止条件：节点为空，返回0。3）单次递归逻辑：后序，分别计算左右孩子的高度返回给父亲节点，注意坑点：根据题目要求，如果左孩子为空右孩子不为空，则父亲节点高度为1+右孩子的高度；如果左孩子不为空右孩子为空，则父亲节点高度为1+左孩子的高度；如果左右孩子均不为空，那么父亲节点的高度为1+min(左孩子的高度，右孩子的高度)。

文章讲解

代码随想录111. 二叉树的最小深度文章讲解

视频讲解

代码随想录111. 二叉树的最小深度视频讲解

代码编写

python

# 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

        left_heigth = self.minDepth(root.left)
        right_heigth = self.minDepth(root.right)

        if left_heigth == 0 and right_heigth != 0:
            return 1+right_heigth
        if left_heigth != 0 and right_heigth == 0:
            return 1+left_heigth
        
        return 1+min(left_heigth, right_heigth)

java

今日总结

今天是二叉树训练的第二天，也是前边学到的递归方法的应用，做二叉树的题目的时候确定遍历顺序很重要，因此解题之前我们一定要清楚是前中后中的哪种，或者还是用层序遍历。今天的题目多数应用的是后序遍历的递归方法，这类题目的共同点是必须要先收集孩子的信息返回到上一层父亲节点。在后边的题目练习中也要有意识的先确定好遍历顺序。

PixcelPrincess

关注

9
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十四天｜ 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

首先，自己写代码的话，仅仅想到用的是递归，但是没具体想是要用前中后序遍历，就糊里糊涂的把代码写出来了，虽然写对了，但是缺乏了进一步的思考。1.递归法前序、后序都是比较好写的，回看了下我上边的是前序的递归写法。中序的话，由于在翻转完左孩子以后，翻转中节点，这样左孩子其实就变成了右孩子，所以后边就不能再对右孩子翻转了，继续要进行的操作是还要翻转左孩子。2. 迭代法（借助栈）3. 层序遍历（借助队列）1. 整体思路：我们要比较的其实不是左右节点而是二叉树的两个左右子树，更明确一点是比较这两个子树的。
复制链接

扫一扫