代码随想录算法训练营day15| 层序遍历、226. 翻转二叉树、101. 对称二叉树

102、二叉树的层序遍历：

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        from collections import deque
        res = []
        que = deque()
        if not root:
            return res
        que.append(root)
        while que:
            nodes = []
            size = len(que)
            while size:
                node = que.popleft()
                nodes.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                size -= 1
            res.append(nodes)
        return res

层序遍历是图论中的广度优先搜索在二叉树中的应用，使用队列这种数据结构实现，一共十道题，大同小异，因此只贴这一道题的代码

226、翻转二叉树：

迭代法(前序遍历)：

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        from collections import deque
        que = deque()
        if not root:
            return root
        que.append(root)
        while que:
            size = len(que)
            while size:
                node = que.popleft()
                node.left, node.right = node.right, node.left
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                size -= 1
        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

101、对称二叉树：

递归法（后序遍历）：

class Solution(object):
    def isSame(self, left, right):
        if not left and right:
            return False
        elif not right and left:
            return False
        elif not left and not right:
            return True
        elif left.val != right.val:
            return False
        outside = self.isSame(left.left, right.right)
        inside = self.isSame(left.right, right.left)
        res = outside and inside
        return res

    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.isSame(root.left, root.right)

迭代法：

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        from collections import deque
        que = deque()
        que.append(root.left)
        que.append(root.right)
        while que:
            left = que.popleft()
            right = que.popleft()
            if not left and not right:  # 确定终止条件
                continue
            elif not right or not left or left.val != right.val:
                return False
            que.append(left.left)
            que.append(right.right)
            que.append(left.right)
            que.append(right.left)
        return True  # 返回布尔值

迭代法同时迭代左右子树

572、另一棵树的子树

class Solution(object):
    def isSameTree(self, p, q):
        if not p and not q:
            return True
        elif not q or not p:
            return False
        left = self.isSameTree(p.left, q.left)
        right = self.isSameTree(p.right, q.right)
        res = left and right and p.val == q.val
        return res

    def isSubtree(self, root, subRoot):
        """
        :type root: TreeNode
        :type subRoot: TreeNode
        :rtype: bool
        """
        if not root and not subRoot:
            return True
        elif not root or not subRoot:
            return False
        left = self.isSubtree(root.left, subRoot)
        right = self.isSubtree(root.right, subRoot)
        res = left or right or self.isSameTree(root, subRoot)
        return res

该题解法和100.相同的树、101.对称二叉树解法类似