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

---

前言

层序遍历打十个没看
226的迭代法没看，要形成体系的话这两个都需要好好消化琢磨
二叉树还有一个总结篇。。。

层序遍历—广度优先算法

看完可以一口气打十个，但是我没空，周日看；迭代法也没高兴看，感觉不如直接写简单
总体思路：使用队列，每弹出一个就把它的左右孩子压入队列；细节：由于需要一层一层输出，所以要注意得到每一层的que的size之后，append到level-list，每个level list再合成一个result

onenote里面也有记录，也可以看教程里面的动图

详细理论：需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

思路

方法一 直接写

看教程里面的也一样，下面是我自己写的

from collections import deque
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        result = []
        que = deque()
        if root:
            que.append(root)
        while que:#不是空
            level = []
            size = len(que)
            for i in range(size):
                curr = que.popleft()
                level.append(curr.val)
                if curr.left:
                    que.append(curr.left)
                if curr.right:
                    que.append(curr.right)
            result.append(level)
        return result

方法二 迭代法

我没看，教程里面也没有讲解了

# 递归法
# 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]]:
        levels = []
        self.helper(root, 0, levels)
        return levels
    
    def helper(self, node, level, levels):
        if not node:
            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)

226.翻转二叉树

思路

总体思路：交换左右节点之后递归进入左右
递归三部曲

注意：中序遍历不行，如果交换先序遍历中swap和self.invertTree(root.left)的位置的话，第一步进入了left，把root.left的整个树交换了之后再交换root的right和left，然后再处理root的right，但是现在的right是之前的left，已经处理过了。

方法一 递归法

先序遍历

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

后序遍历

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        return root
#中序
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

方法二 迭代法

#前序遍历
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()   
            node.left, node.right = node.right, node.left                   
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)  
        return root

101.对称二叉树 2

思路

总体思路：如果一个根节点的两个孩子是对称的话，那么这个根节点是对称的
具体：外侧的和外侧比较，里侧的和里侧的比较

方法一　递归法

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def compare(left,right):
            if left and not right:return False
            elif right and not left: return False
            elif not right and not left: return True
            elif right.val != left.val:return False
            #下面是值相等的情况，就需要进一步向下面的节点比较。
            out = compare(left.left,right.right)#外侧
            inside = compare(left.right,right.left)#里侧
            result = out and inside
            return result

        if not root:return False
        output = compare(root.left,root.right)
        return output
 # 下面是参考代码，copy上，不总结了
 class Solution:
    def isSymmetric(self, root: 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
        

方法二　迭代法（没看呢）

---

总结

今天真的非常难过，不知道为什么自己做工程那么慢；难过地走在马路上都要跪下来。