Leetcode刷题记录（代码随想录day13）

最新推荐文章于 2024-07-04 10:15:20 发布

头发属于稀缺资源

最新推荐文章于 2024-07-04 10:15:20 发布

阅读量114

点赞数

分类专栏： Leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_39831505/article/details/129311671

版权

Leetcode 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Day 13

层序遍历二叉树。
这几天有项目要做，打卡会晚一些……实在是忙到不行

层序遍历

队列先进先出，符合层序遍历一层一层遍历的逻辑。栈先进后出，适合深度优先遍历也就是递归的逻辑。因此用队列进行层序遍历。

102. 二叉树的层序遍历（中等）

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

解：如图。
在这里插入图片描述

# 迭代法，建立双向队列
from collections import deque
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root == None:
            return []
        results = []
        que = deque([root])  # 建立队列
        while que:  # 循环的是队列
            result = []
            size = len(que)  # 这一层要遍历的都在que里
            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
    
# 递归法，定义包含层数的递归函数
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        def traversal(root, depth):  # 和之前的不同，要考虑遍历的层数，循环的是根节点
            if root == None: 
                return
            if len(res) == depth:  # 是否是新的一层
                res.append([])  # 新的一层就新建层列表
            res[depth].append(root.val)  # 节点加入新的这层
            if root.left:
                traversal(root.left, depth+1)
            if root.right:
                traversal(root.right, depth+1)
        traversal(root, 0)
        return res

107.二叉树的层次遍历 II（中等）

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

解：反转一下就行了。注意reverse只反转外部数组不反转内部，所以左右节点不用换顺序

from collections import deque
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root == None:
            return []
        results = []
        que =  deque([root])
        while que:
            result = []
            size = len(que)
            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)

        results.reverse()
        return results

199. 二叉树的右视图（中等）

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

解：只需要把层序遍历中的最后一个点加入数组就行

from collections import deque
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        results = []
        que = deque([root])
        while que:
            size = len(que)
            for _ in range(size):
                node = que.popleft()
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            results.append(node.val)
        return results

637. 二叉树的层平均值

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

解：类似，但这个只适合用迭代而非递归，因为要求和取平均，递归不好加起来

from collections import deque
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        results = []
        que = deque([root])
        while que:
            result = 0
            size = len(que)
            for _ in range(size):
                node = que.popleft()
                result += node.val
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            results.append(result/size)
        return results

429. N叉树的层序遍历（中等）

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔。

解：

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if root == None:
            return []
        res = []

        def order(root, depth):
            if len(res) == depth:
                res.append([])
            res[depth].append(root.val)
            if root.children:
                for i in root.children:
                    order(i, depth+1)
        
        order(root, 0)
        return res

其他题型

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

解：用前序遍历或者后序遍历的时候把左右孩子翻转一下，但注意不要用中序遍历，因为可能会翻转两次。也可以用迭代法写层序遍历或者前序遍历，总之在便利的时候翻转一下就好了。

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

101. 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

解：因为检查轴对称，所以实际上是检查两棵树是否镜像对称。本题只能用后序遍历，因为要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

递归三部曲：1、递归函数的参数和返回值：参数rootLeft, rootRight，返回bool（判断左右子节点是否相等）。2、函数终止情况：要比较两个节点分别为空和不为空的情况。3、确定单层函数逻辑：比较外侧是否对称 1-> 是，传入内测比较 2-> 是，输出 1-> 否，输出

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        def compare(left, right) -> bool:
            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
            # 左右节点都不为空且数值相等，递归
            inside = compare(left.right, right.left)
            outside = compare(left.left, right.right)
            if inside and outside:
                return True
            else:
                return False
        return compare(root.left, root.right)