day15，python算法打卡，二叉树3

最新推荐文章于 2024-07-15 22:10:26 发布

是小狐蝶呀~

最新推荐文章于 2024-07-15 22:10:26 发布

阅读量927

点赞数 20

文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_54082087/article/details/140192575

版权

今日任务：

1）102.二叉树层序遍历

2）107.二叉树的层次遍历 II

3）二叉树的右视图

4）429.N叉树的层序遍历

5）一些其他可以用层序遍历的题目

6）翻转二叉树

102.二叉树层序遍历

题目链接：102. 二叉树的层序遍历 - 力扣（LeetCode）

文字及视频讲解：代码随想录 (programmercarl.com)

思路：

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

具体实现：

1，首先我们需要一个size记录每一层的节点数量

2，循环size把每一层所有元素左边pop出来的同时，在右边加入下一层的元素，并记录下一层的节点数量

from collections import deque
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        queue = deque()
        queue.append(root)
        result = []
        

        if not root:
            return []

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

感想：

有个代码错误认知：对于for _ in range(size):函数，range 函数在调用时就确定了序列的长度，函数内部size大小的变化并不会影响循环的次数。

107.二叉树的层次遍历 II

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode）

思路：

简单，在上一道题的基础上面反转列表就可以

from collections import deque
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = deque()
        queue.append(root)
        size = 1
        result= []

        while queue:
            layer_result = []
            for _ in range(size):
                node = queue.popleft()
                size -= 1
                layer_result.append(node.val)

                if node.left:
                    queue.append(node.left)
                    size += 1
                if node.right:
                    queue.append(node.right)
                    size +=1
            result.append(layer_result)

        return result[::-1]

199.二叉树的右视图

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
from collections import deque
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        # 不可以用递归法，因为例子虽然都是右边节点，但是如果左边节点超出了，也会看到左边节点
        # 方法采用层序遍历后，取出每一层最后一个值

        if not root:
            return []
        
        result = []
        queue = deque()
        queue.append(root)
        size = 1

        while queue:
            layer_result = []
            for _ in range(size):
                node = queue.popleft()
                size -= 1
                layer_result.append(node.val)

                if node.left:
                    queue.append(node.left)
                    size += 1
                if node.right:
                    queue.append(node.right)
                    size +=1
            result.append(layer_result[-1])

        return result

感想：

一样的套路，不过给的例子有迷惑性，给的例子一开始觉得只需要所有的右子树的节点，写了递归，提交后发现，如果左子树数量大于右子树的话，也会被看到。

429.N叉树的层序遍历

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode）

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        result = []
        queue = deque()
        queue.append(root)
        size = 1

        while queue:
            layer_result = []
            for _ in range(size):
                node = queue.popleft()
                size -= 1
                layer_result.append(node.val)

                for child in node.children:
                    queue.append(child)
                    size += 1
            result.append(layer_result)

        return result

102.二叉树层序遍历

大致看了一眼基本都是算法变体，就不一一都做了

102.二叉树层序遍历

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

文字及视频讲解：代码随想录 (programmercarl.com)

思路：

首先需要判断使用哪一种遍历方式：前序遍历，后序遍历，层序遍历，递归遍历都可以，但是中序遍历不可以，因为中序遍历会把某些节点的左右孩子翻转了两次！

我写的是层序遍历：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None
        
        queue = deque()
        queue.append(root)
        size = 1

        while queue:
            for _ in range(size):
                node = queue.popleft()
                size -= 1
                if node.left:
                    queue.append(node.left)
                    size += 1
                if node.right:
                    queue.append(node.right)
                    size += 1
                node.left, node.right = node.right, node.left
            
        return root