算法训练第十五天 | 二叉树 层序遍历10 226.翻转二叉树 101.对称二叉树 2

层序遍历

共十题：
102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

102代码

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        #用队列来解决层序遍历
        results = []
        if root is None:
            return []
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            results.append(result)
        return results

以下只是上面的模板换了最多两三行代码：
107代码：

def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        results = []
        if root is None:
            return []
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            results.append(result)
        return results[::-1]

199代码：每次取数只取最后一个

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        #results = []
        result = []
        if root is None:
            return []
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            node = que[-1]
            result.append(node.val)
            #result = []
            for _ in range(size):
                node = que.popleft()
                #result.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            #results.append(result)
        return result

637代码：for里面的内容用来存数到队列

def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        result = []
        if root is None:
            return []
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            sum_ = 0
            for _ in range(size):
                node = que.popleft()
                sum_ += node.val
                #result.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            ave = sum_/size
            result.append(ave)
        return result

226.翻转二叉树

题目链接

226翻转二叉树

思路

根节点，左右指针交换，该方法使用递归法，前序遍历：

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

101.对称二叉树

题目链接

101.对称二叉树

思路

递归法：后序遍历

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

    def compare(self, left, right):
        #排除几种可能的情况
        if left == None and right == None: return True
        elif left == None and right != None: return False
        elif left != None and right == None: return False
        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