代码随想录Day12 二叉树层序遍历| Leetcode十题

小叶陈陈

已于 2024-01-20 00:18:34 修改

阅读量390

点赞数 8

文章标签： leetcode 算法 python

于 2024-01-17 01:36:10 首次发布

本文链接：https://blog.csdn.net/qq_41502639/article/details/135638685

版权

代码随想录系列

上题

10题一晚上应该刷不完，逐步补充

102. 二叉树的层序遍历 - 力扣（LeetCode）

107. 二叉树的层序遍历 II - 力扣（LeetCode）

199. 二叉树的右视图 - 力扣（LeetCode）

637. 二叉树的层平均值 - 力扣（LeetCode）

429. N 叉树的层序遍历 - 力扣（LeetCode）

515. 在每个树行中找最大值 - 力扣（LeetCode）

116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

104. 二叉树的最大深度 - 力扣（LeetCode）

111. 二叉树的最小深度 - 力扣（LeetCode）

226. 翻转二叉树 - 力扣（LeetCode）

第一题

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

    示例 1：
    输入：root = [3,9,20,null,null,15,7]
    输出：[[3],[9,20],[15,7]]

    示例 2：
    输入：root = [1]
    输出：[[1]]

    示例 3：
    输入：root = []
    输出：[]

    提示：
    树中节点数目在范围 [0, 2000] 内
    -1000 <= Node.val <= 1000

思路

定义一个队列re=[root]，存储结果的列表result=[]，每层遍历存储结果的tem=[]
访问第一个结点，出队，存入tem[]，tem.append(node.val)
结点存在左子树：re.append(node.left)
结点存在右子树：re.append(node.right)
本层循环存入的结点数即为下一层节点数目
队列可以直接使用列表，出队使用pop(0)，出队的时间复杂度为O(n)
队列可以使用collections.deque()，双端队列，出队时间复杂度为O(1)

代码

import collections


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """
    有一个二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

    示例 1：
    输入：root = [3,9,20,null,null,15,7]
    输出：[[3],[9,20],[15,7]]

    示例 2：
    输入：root = [1]
    输出：[[1]]

    示例 3：
    输入：root = []
    输出：[]

    提示：
    树中节点数目在范围 [0, 2000] 内
    -1000 <= Node.val <= 1000
    """

    def createtree(self, root):
        if not root:
            return None
        n = len(root)
        i = 0
        result = TreeNode(root[0])
        queue = [result]
        i += 1

        while queue and i < n:
            root_node = queue.pop(0)
            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.left = node
                queue.append(node)
            i += 1

            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.right = node
                queue.append(node)
            i += 1
        return result

    def levelOrder(self, root: TreeNode) -> list:
        if not root:
            return []
        result = []
        # root = [root]
        re = root
        root = collections.deque()
        root.append(re)
        while root:
            tem = []
            for _ in range(len(root)):
                # node = root.pop(0)
                node = root.popleft()
                tem.append(node.val)
                if node.left:
                    root.append(node.left)
                if node.right:
                    root.append(node.right)
            result.append(tem)
            #print(tem)
        return result


if __name__ == '__main__':
    root = [[3, 9, 20, 'null', 'null', 15, 7], [1], [], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
    test = Solution()
    for i in root:
        tree = test.createtree(i)
        print(test.levelOrder(tree))

第二题

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


示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：
输入：root = [1]
输出：[[1]]

示例 3：
输入：root = []
输出：[]
 

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

思路

其实就是第一题反序即可

代码

import collections


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """
    有一个二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

    示例 1：
    输入：root = [3,9,20,null,null,15,7]
    输出：[[3],[9,20],[15,7]]

    示例 2：
    输入：root = [1]
    输出：[[1]]

    示例 3：
    输入：root = []
    输出：[]

    提示：
    树中节点数目在范围 [0, 2000] 内
    -1000 <= Node.val <= 1000
    """

    def createtree(self, root):
        if not root:
            return None
        n = len(root)
        i = 0
        result = TreeNode(root[0])
        queue = [result]
        i += 1

        while queue and i < n:
            root_node = queue.pop(0)
            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.left = node
                queue.append(node)
            i += 1

            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.right = node
                queue.append(node)
            i += 1
        return result

    def levelOrder(self, root: TreeNode) -> list:
        if not root:
            return []
        result = []
        # root = [root]
        re = root
        root = collections.deque()
        root.append(re)
        while root:
            tem = []
            for _ in range(len(root)):
                # node = root.pop(0)
                node = root.popleft()
                tem.append(node.val)
                if node.left:
                    root.append(node.left)
                if node.right:
                    root.append(node.right)
            result.append(tem)
            #print(tem)
        return result[::-1]


if __name__ == '__main__':
    root = [[3, 9, 20, 'null', 'null', 15, 7], [1], [], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
    test = Solution()
    for i in root:
        tree = test.createtree(i)
        print(test.levelOrder(tree))

第三题

    给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
    
    示例 1:
    输入: [1,2,3,null,5,null,4]
    输出: [1,3,4]
    
    示例 2:
    输入: [1,null,3]
    输出: [1,3]
    
    示例 3:
    输入: []
    输出: []
    
    提示:
    二叉树的节点个数的范围是 [0,100]
    -100 <= Node.val <= 100

思路

递归深度==结果列表长度时，把当前节点加入答案队列，能发现这个规律的真不是一般人，当然，我是抄别人的思路。。。。

代码

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


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

    示例 1:
    输入: [1,2,3,null,5,null,4]
    输出: [1,3,4]

    示例 2:
    输入: [1,null,3]
    输出: [1,3]

    示例 3:
    输入: []
    输出: []

    提示:
    二叉树的节点个数的范围是 [0,100]
    -100 <= Node.val <= 100
    """
    def createTree(self, root):
        if not root:
            return None
        n = len(root)
        i = 0
        result = TreeNode(root[0])
        queue = [result]
        i += 1

        while queue and i < n:
            root_node = queue.pop(0)
            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.left = node
                queue.append(node)
            i += 1

            if i < n and root[i] != 'null':
                node = TreeNode(root[i])
                root_node.right = node
                queue.append(node)
            i += 1
        return result

    def rightSideView(self, root):
        # 递归深度==结果列表长度时，把当前节点加入答案队列
        result = []

        def dfs(node, depth):
            if node is None:
                return
            if len(result) == depth:
                result.append(node.val)
            dfs(node.right, depth + 1)
            dfs(node.left, depth + 1)

        dfs(root, 0)
        return result


if __name__ == '__main__':
    test = Solution()
    root = [[1, 2, 3, 'null', 5, 'null', 4], [1, 'null', 2, 3, 4, 5, 6]]
    for i in root:
        tree = test.createTree(i)
        print(test.rightSideView(tree))

第十一题

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

示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：
输入：root = [2,1,3]
输出：[2,3,1]

示例 3：
输入：root = []
输出：[]

思路

前序、后序遍历的时候把两个值交换即可

代码

class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:

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

    示例 1：
    输入：root = [4,2,7,1,3,6,9]
    输出：[4,7,2,9,6,3,1]

    示例 2：
    输入：root = [2,1,3]
    输出：[2,3,1]

    示例 3：
    输入：root = []
    输出：[]
    """

    def create_tree(self, root):
        if not root:
            return None
        n = len(root)
        i = 0
        result = TreeNode(root[i])
        queue = [result]
        i += 1

        while queue and i < n:
            node = queue.pop(0)
            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.left = root_node
            i += 1

            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.right = root_node
            i += 1
        return result

    def invertTree(self, root):
        if not root:
            return
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

    def preOrder(self, root, re):
        if root is None:
            return
        re.append(root.val)
        self.preOrder(root.left, re)
        self.preOrder(root.right, re)


if __name__ == '__main__':
    test = Solution()
    root = [[4, 2, 7, 1, 3, 6, 9], [2, 1, 3], []]
    for i in root:
        tree = test.create_tree(i)
        re_tree = test.invertTree(tree)
        result = []
        test.preOrder(re_tree, result)
        print(result)

十二题

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

示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：
树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

思路

遍历时做相应的判断即可

代码

class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:

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

    示例 1：
    输入：root = [1,2,2,3,4,4,3]
    输出：true

    示例 2：
    输入：root = [1,2,2,null,3,null,3]
    输出：false

    提示：
    树中节点数目在范围 [1, 1000] 内
    -100 <= Node.val <= 100

    进阶：你可以运用递归和迭代两种方法解决这个问题吗？
    """

    def create_tree(self, root):
        if not root:
            return None
        n = len(root)
        i = 0
        result = TreeNode(root[i])
        queue = [result]
        i += 1

        while queue and i < n:
            node = queue.pop(0)
            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.left = root_node
            i += 1

            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.right = root_node
            i += 1
        return result

    def isSymmetric(self, root):
        if not root:
            return
        def symmetry(left, right):
            if not left and not right:
                return True
            if not left or not right or left.val != right.val:
                return False
            return symmetry(left.left, right.right) and symmetry(left.right, right.left)
        return symmetry(root.left, root.right)


if __name__ == '__main__':
    test = Solution()
    root = [[1, 2, 2, 3, 4, 4, 3], [1, 2, 2, 'null', 3, 'null', 3], []]
    for i in root:
        tree = test.create_tree(i)
        print(test.isSymmetric(tree))

持续更新....

今天复盘的时候才发现自己写的创建二叉树的代码是错的。。。。