算法刷题打卡013 | 二叉树相关题目3道

LeetCode 102 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历 - 力扣（Leetcode）

二叉树的层序遍历属于广度优先搜索的范畴，需要借助额外的空间暂存遍历到的节点。利用队列先入先出的特性，每遍历二叉树的一层，就将其左右子节点（如果有）入队。为了确定每一层的节点数，处理前需要先获得当前队列的元素个数n，当前层遍历只需遍历完这n个节点：

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        q = deque()
        result = []
        if not root:
            return result
        q.append(root)
        i = 0
        while q:
            count = len(q)  # 每层遍历次数
            result.append([])
            while count > 0:
                cur = q.popleft()
                result[i].append(cur.val)
                if cur.left:
                    q.append(cur.left)
                if cur.right:
                    q.append(cur.right)
                count -= 1
            i += 1
        return result

每个节点各入队出队一次，总的时间和空间复杂度都是O(n)。

然后一口气做了另外9题二叉树层序遍历相关的题目：107， 199， 637， 429， 515， 116， 117，104，111，题目的基本思路相同，实现上根据题意修改即可。比如107的层序遍历II，只需要在102代码的基础上将结果数组反转；199的二叉树右视图中，只在层序遍历每一层最后一个节点处收集结果；429扩展到N叉树的层序遍历，只需把每个节点的所有子节点依次入队......

LeetCode 226 翻转二叉树

题目链接：226. 翻转二叉树 - 力扣（Leetcode）

这道题注意用前序遍历或后序遍历都可以，之前做的是递归法的前序遍历，直接用题目给定的主函数作为递归函数，先交换当前节点的左右节点，再递归地对左右子树进行操作：

# 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
        # 交换当前节点的左右
        temp = root.left
        root.left = root.right
        root.right = temp
        # 左右子树递归进行
        root.left = self.invertTree(root.left)
        root.right = 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 root
        # 迭代法, preorder
        stack = []
        stack.append(root)
        while stack:
            cur = stack.pop()
            cur.left, cur.right = cur.right, cur.left  # 中，交换节点
            # 栈的特性，先入栈右，之后处理节点时先出栈左
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
        return root

LeetCode 101 对称二叉树

题目链接：101. 对称二叉树 - 力扣（Leetcode）

第一次做这道题用了比较复杂的层序遍历解法，遍历时空节点也要放入队列：

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        # 先做层序遍历，再检查每一层是否对称（前提是空的左右子节点也要填充None）
        if not root:
            return True
        nodes_val = []
        q = deque()
        q.append(root)
        while q:
            count = len(q)
            temp = []
            flag = False
            while count > 0:
                cur = q.popleft()
                if not cur:
                    temp.append(None)
                    count -= 1
                    continue
                flag = True  # 表明当前队列中有不是None的节点（最后一层往下一层全是None，来不到这）
                temp.append(cur.val)
                # if cur.left or cur.right:
                    # 当前节点有其中一个节点就进队，否则cur已是叶节点
                q.append(cur.left)
                q.append(cur.right)
                count -= 1
            if not flag:
                break
            nodes_val.append(temp)
        for i in range(1, len(nodes_val)):
            start, end = 0, len(nodes_val[i])-1
            while start < end:
                if nodes_val[i][start] != nodes_val[i][end]:
                    return False
                start += 1
                end -= 1
        
        return True

但其实更简单的层序比较方法是调整节点的入队顺序，每次比较时取出队列中的两个节点，这两个节点是这一层二叉树最外面的两个节点（最左和最右），节点相同（同时为空或同时不为空且值相等），则这一层的最外面的节点对称，将这两个节点的子节点按顺序入队，然后继续进行里面节点的对称判断（队列下一组两个节点）：

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        q = deque()
        # 根节点不用比较，直接将root左右节点入队，从第2层开始比较
        q.append(root.left)
        q.append(root.right)
        while q:
            left = q.popleft()
            right = q.popleft()
            # 同时为空节点，对称
            if not left and not right:
                continue
            # 其中一个非空，或值不相等，不对称
            if (not left or not right) or left.val != right.val:
                return False
            # 然后每一层从外到内入队，顺序很重要
            # 最左和最右比，左的右和右的左比，无须判断是否为空节点
            q.append(left.left)
            q.append(right.right)
            q.append(left.right)
            q.append(right.left)
        
        return True

递归法思路相同与迭代法类似，实现起来反而更简单：

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        def recur(node1, node2):
            if not node1 and not node2:
                return True
            if not node1 or not node2 or node1.val != node2.val:
                return False
            return recur(node1.left, node2.right) and recur(node1.right, node2.left)
        
        return recur(root.left, root.right)

总的来说，二叉树类题目可以先考虑递归方法，迭代解法有时候会稍微麻烦一些。