代码随想录算法训练营第十五天（py）| 二叉树 | 层序遍历、226.翻转二叉树、101. 对称二叉树

层序遍历

队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

首先需明确，层序遍历的结果是一个数组数组，每一个元素为每一层的数组，形如

[[15],[9,20],[3,50,6]]

创建一个levels保存所有层的结果，levels[level]保存每一层的结果

思路1 递归法

该方法看起来是前序遍历？不过保存结果的时候是呈现出广度遍历的特性。
模板如下：

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        levels = []
        self.helper(root,0,levels)
        return levels

    def helper(self,node,level,levels):# 节点，当前层，结果
        if node == None:
            return
        if len(levels) == level:# 初始化新层
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level + 1, levels)
        self.helper(node.right, level + 1, levels)

思路2 利用长度

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
    	if root == None:
    		return []
    	queue = collections.deque([root])
    	levels = []
    	while queue:
    		level = []
    		for _ in range(len(queue)):
    			node = queue.popleft()
    			level.append(node.val)
    			if node.left:
    				queue.append(node.left)
    			if node.right:
    				queue.append(node.right)
    		levels.append(level)
    	return levels

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

力扣链接
给定一个二叉树,填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

思路

需要创建一个临时节点prev用以表示上一个左侧节点，这样用prev.next = node即可实现

"""
# 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
"""
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if root == None:
            return root
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            prev = None
            for _ in range(size):
                node = queue.popleft()
                if prev:
                    prev.next = node
                prev = node
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

226.翻转二叉树

力扣链接
给你一棵二叉树的根节点 root ，左右翻转这棵二叉树，并返回其根节点。

思路

可以用前序遍历和后序遍历来交换左右子节点
在此使用前序递归遍历来实现：

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        def dfs(node):
            if node is None:
                return
            temp = node.left
            node.left = node.right
            node.right = temp
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return root

101. 对称二叉树

力扣链接
给你一个二叉树的根节点 root ， 检查它是否轴对称。

思路

比较两个子树的里侧和外侧元素是否相等。使用后序遍历，一个树的顺序是（左右中），另一个是（右左中）。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root == None:
            return True
        return self.compare(root.left, root.right)

    def compare(self,left,right):
        if left == None and right != None:
            return False
        if left != None and right == None:
            return False
        if left == None and right == None:
            return True
        if left.val != right.val:
            return False
        
        # 左右节点非空且数值相同
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return inside and outside