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

层序遍历  10 

题目：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

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

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

代码如下：

class Solution(object):
    def levelOrder(self, root):
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result

再来一道：

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

从下到上加一句取反代码就可以：

return result[::-1]

再来一道：

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

class Solution(object):
    def rightSideView(self, root):
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = len(queue)
            for i in range(level):
                cur = queue.popleft()
                if cur.left: #要先添加左节点
                    queue.append(cur.left)
                if cur.right: #只考虑右节点会错过某些层
                    queue.append(cur.right)
                if i == level - 1: # 如果是当前层的最后一个节点
                    result.append(cur.val) #result输出不能是列表，是数值
        return result

再来一道：

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

class Solution(object):
    def averageOfLevels(self, root):
        if not root:
            return 0
        queue = collections.deque([root])
        result = []
        while queue:
            sum_ = 0
            size = len(queue)
            for _ in range(len(queue)):
                cur = queue.popleft()
                sum_ += cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(float(sum_) / size) #不能用len(queue)，此时已经为下一层
            # 要把一个转化为浮点，两个整数默认整除
        return result

226.翻转二叉树

题目：翻转一棵二叉树。

如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转

可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。关键在于遍历顺序，前中后序应该选哪一种遍历顺序？ 

遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！

那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

主要看递归法：

1. 确定递归函数的参数和返回值：

参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。

返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数

2. 确定终止条件：

当前节点为空的时候，就返回

3. 确定单层递归的逻辑：

因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树

代码如下（前序遍历）：

class Solution(object):
    def invertTree(self, root):
        if not root:
            return None
        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):
        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

迭代法（层序遍历）：

class Solution(object):
    def invertTree(self, root):
        if not root:
            return None
        queue = collections.deque([root])
        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

101.对称二叉树 2

题目：给定一个二叉树，检查它是否是镜像对称的。

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么如何比较呢？比较的是两个子树的里侧和外侧的元素是否相等。

那么遍历的顺序应该是什么样的呢？

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

递归法：

1. 确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

2. 确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

• 左节点为空，右节点不为空，不对称，return false
• 左不为空，右为空，不对称 return false
• 左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

• 左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。

3. 确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。

比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。

如果左右都对称就返回true ，有一侧不对称就返回false 。

我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

代码如下：

class Solution(object):
    def isSymmetric(self, root):
        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) #左子树：右、 右子树：左
        insame = outside and inside #左子树：中、 右子树：中 （逻辑处理）
        return insame