代码随想录算法训练营第十五天

10. 层序遍历

题目链接：层序遍历
广度优先搜索（bfs）可以借助一个队列保存每一层遍历过得元素，设立一个队列，设立一个size，每一层的元素进去队列，size+=1，然后每次出去size-=1。

• 列队：[1]；size=1；l=[]；res=[]
• 1出队，4,2入队；列队：[4,2]；size=2，res=[[1]]
• 4出队，3,5入队；列队：[2,3,5]；size=1，res=[[1],[4]]
• 2出队，2入队；列队：[3,5,2]；size=3，res=[[1],[4,2]]
• 3出队，列队：[5,2]；size=2，res=[[1],[4,2],[3]]
• 5出队，1入队；列队：[2,1]；size=1，res=[[1],[4,2],[3,5]]
• 2出队，列队：[1]；size=1，res=[[1],[4,2],[3,5,2]]
• 2出队，列队：[]；size=1，res=[[1],[4,2],[3,5,2],[1]]，结束

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root == None:
            return []
        queue = collections.deque()
        res = []
        queue.append(root)
        size = 1
        while queue:
            l = []
            while size > 0:
                cur = queue.popleft()
                l.append(cur.val)
                size-=1
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(l)
            size = len(queue)
        return res

226.翻转二叉树

题目链接：翻转二叉树
交换的是节点不是数值

前序遍历（左中右）

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

后序遍历（左右中）

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

中序遍历（左中右）

递归完左子树，反转过后，左子树到右子树，所以再递归右子树就重复了，应该还是左子树。

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

101.对称二叉树

题目链接：对称二叉树
顶一个函数来看左子树和右子树是不是对称的，这里的对称的意思并不是完全相等的意思，而是左.left==右.right，左.right==右.left。是外侧的子树等于外侧的子树，内侧的子树等于内侧的子树的意思。
这个子函数的重点其实是，当走到None Node的时候，可以直接输出True，因为只有在None上面的节点（最后一排）对得上的情况下才会走到None去，这个时候已经是所有都对上了，所以输出True就可以。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        def isSy(p,q):
            if (p and not q) or (not p and q):
                return False
            elif not p and not q:
                return True
            if p.val == q.val:
                return isSy(p.left,q.right) and isSy(p.right,q.left)
            else:
                return False
        return isSy(root.left,root.right)