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

文档讲解：代码随想录

视频讲解：代码随想录B站账号

状态：看了视频题解和文章解析后做出来了

代码随想录文章链接：

层序遍历

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        que = deque()
        result = []
        if root:
            que.append(root)

        while que:
            size = len(que)
            res_cur = []
            for i in range(size):
                cur = que.popleft()
                res_cur.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(res_cur)

        return result

思路：

1. 将第一层的第一个root节点加入到队列中
2. 将当前队列的节点数量赋值给size，用于记录循环次数
3. 建立for循环，首先将队列的最左弹出，记录值
4. 如果cur有左节点则入队列，如果有右节点则入队列

226. 翻转二叉树

1. 递归

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

        return root

思路：首先确定终止条件，如果root为空则返回。

每次不为空的node，都要直接调转他们的左右子树，然后再递归他们的左右子树，最后返回结果root。

值得注意的是，return root会被执行n次，而n就是树的节点数量，只有最后一次return的root，也就是全部递归完的结果，才会被当作最终的结果返回。

2. 迭代

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None

        stack = [root]
        while stack:
            cur = stack.pop()
            cur.left, cur.right = cur.right, cur.left
            if cur.left:
                stack.append(cur.left)
            if cur.right:
                stack.append(cur.right)
            
        return root

思路：就是遍历了一遍所有节点，用栈来维护，确保每个节点都正确遍历。

3. 层序遍历

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None

        que = deque([root])

        while que:
            for i 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

 思路：用队列维护需要操作的节点。

101. 对称二叉树

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return None

        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)

        return outside and inside

细节：最后一个elif需要判断两个节点的值不相等，返回False。如果判断两个值相等返回True的话就会造成一个问题，当前节点会直接停止递归并返回True，但这并不意味着它的子节点就都是True了，所以这样会造成剪枝。

思路：思路写起来太复杂了，看文章吧。