算法学习|Day15-二叉树|Leetcode102二叉树的层序遍历，Leetcode226翻转二叉树，Leetcode101对称二叉树-CSDN博客

本文链接：https://blog.csdn.net/WR_mmc/article/details/135586926

本文介绍了LeetCode中的三个二叉树相关问题：层序遍历算法实现、翻转二叉树两种方法（递归和层序）以及对称二叉树的判断。作者分享了解题思路和关键代码片段，强调了递归在这些问题中的应用。

摘要由CSDN通过智能技术生成

一、Leetcode102二叉树的层序遍历

题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

输入：root = [1]
输出：[[1]]

输入：root = []
输出：[]

题目链接：力扣题目链接

解题思路

层序遍历
使用队列
控制每层的数量，用size记录

方法:长度法

第一个while循环：当队列que不为空时继续下一层遍历(因为上一层的每个根节点都加入了它们的左右节点)
第二个for循环：完成一层的遍历，用size控制

# 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 []
        que = collections.deque([root])
        res = []
        while que:
            # save the elements in each layer
            level = []
            # record the number of elements in each layer!!
            size = len(que)

            for _ in range(size):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(level)

        return res

总结

用size控制每一层的大小
用level记录每一层的数值
建立队列que=collections.deque([root])

二、Leetcode226翻转二叉树

题目描述

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
在这里插入图片描述

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

在这里插入图片描述

输入：root = [2,1,3]
输出：[2,3,1]

输入：root = []
输出：[]

题目链接：力扣题目链接

解题思路

将每个根节点的左右孩子翻转就可以了
使用前序遍历和后序遍历都可以(中序遍历需要变成左中左，头结点翻转后没处理的子树变回到了左边，容易错尽量不使用)

方法一:递归

确定递归函数的参数和返回值
确定终止条件：root==None时，返回None

        if not root:
            return None

确定单层递归的逻辑：使用前序遍历，先翻转根节点的左右孩子，再翻转左子树，再翻转右子树

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

总代码：

# 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

方法二:层序遍历

将每一层根节点的左右孩子交换
使用层序遍历的思路

# 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
        que = collections.deque([root])
        while que:
            for _ in range(len(que)):
                cur = que.popleft()
                cur.left, cur.right = cur.right, cur.left
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return root

总结

翻转二叉树选择前序和后序遍历，层序遍历
递归三部曲：确定递归函数的参数和返回值，确定终止条件，确定单层递归逻辑！！！

三、Leetcode101对称二叉树

题目描述

给你一个二叉树的根节点 root ，检查它是否轴对称。
在这里插入图片描述

输入：root = [1,2,2,3,4,4,3]
输出：true

在这里插入图片描述

输入：root = [1,2,2,null,3,null,3]
输出：false

题目链接：力扣题目链接

解题思路

比较根节点的左右子树是否相互翻转
所以是比较两棵子树内侧和外侧元素是否相等
使用后序遍历

方法:递归

确定递归的参数和返回值：左子树节点和右子树节点，bool类型

		outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)

确定终止条件：
空节点情况：
1.都为空，返回true
2.左为空，右不为空，返回false
3.左不为空，有为空，返回false
非空节点情况：
4.左右值不相等，返回false

		# 排除空节点的情况
        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

确定单层递归的逻辑：先比较外侧是否对称，再比较内侧是否对称，都对称返回true，有一侧不对称就返回false

		# 左右节点都不为空，且数值相同，才做递归
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        issame = outside and inside

总代码：

# 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

总结

对称二叉树使用后续遍历
递归三部曲：确定递归函数的参数和返回值，确定终止条件，确定单层递归逻辑！！！

心得：硕士完美毕业了，顺利发了文章，开始安心准备春招，从day15继续做了，递归还没有完全领悟，慢慢培养题感啦~ 加油啦~