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

最新推荐文章于 2024-07-07 12:10:24 发布

Mi_chelle

最新推荐文章于 2024-07-07 12:10:24 发布

阅读量311

点赞数 8

文章标签：算法

本文链接：https://blog.csdn.net/Mi_chelle/article/details/136169938

版权

本文详细介绍了二叉树的层序遍历算法，使用队列数据结构实现，包括Python中的deque操作，以及扩展到N叉树、右视图、层平均值、最大深度、最小深度、翻转二叉树和对称性判断等二叉树相关问题的解决方案。

摘要由CSDN通过智能技术生成

层序遍历

https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html
二叉树本身的结构是无法做到层序遍历的，所以需要借助队列：

根节点进入队列，记录队列大小
第一层：
弹出根节点，左右孩子加入队列，记录当前队列大小
第二层：
弹出一个，加入其左右孩子，队列大小 -=1
重复弹出并加入左右孩子，队列大小-=1，直到队列大小 == 0后更新记录队列大小
第三层：
…

102.二叉树的层序遍历

代码：

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        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

python collections.deque() 是双端队列，可对队列两端append 和 pop，时间O(1)，list也可以但是时间为O(n)

append() 右端加入
appendleft()左端加入
pop() 右端弹出
popleft() 左端弹出
queue = collections.deque([root]) 新建一个deque里面必须是iterable的

107.二叉树的层次遍历 II

自下而上的将result改成deque,每次appendleft最后返回再将result改成list
题解是最后进行翻转：result[::-1]

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        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[::-1]

199.二叉树的右视图

题解：用queue的长度找最后一个元素

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        
        queue = collections.deque([root])
        right_view = []
        
        while queue:
            level_size = len(queue)
            
            for i in range(level_size):
                node = queue.popleft()
                
                if i == level_size - 1:
                    right_view.append(node.val)
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return right_view

637.二叉树的层平均值

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(mean(level))
        return result

429.N叉树的层序遍历

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.children:
                    for child in cur.children:
                        queue.append(child)
            result.append(level)
        return result

515.在每个树行中找最大值

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(max(level))
        return result

116.填充每个节点的下一个右侧节点指针

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            pre = None
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                if pre:
                    pre.next = cur
                pre = cur
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return root

117.填充每个节点的下一个右侧节点指针II

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            pre = None
            for i in range(size):
                cur = queue.popleft()
                if pre:
                    pre.next = cur
                pre = cur
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return root

104.二叉树的最大深度

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        queue = collections.deque([root])
        result = 0
        while queue:
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result += 1
        return result

111.二叉树的最小深度

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        queue = collections.deque([root])
        result = 0
        while queue:
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                if not cur.left and not cur.right:
                    return result + 1
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result += 1
        return result

226.翻转二叉树

题解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC
昨晚上面十个层序遍历现在只会层序了…

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            pre = None
            for i in range(size):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                    temp = cur.left
                    cur.left = cur.right
                else:
                    temp = None
                    cur.left = cur.right
                if cur.right:
                    queue.append(cur.right)
                    cur.right = temp
                else:
                    cur.right = temp
        return root

101.对称二叉树 2

题解https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC
递归真的不简单啊…

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        return self.compare(root.left, root.right)
    def compare(self,left, right) -> bool:
        if left and not right:
            return False
        elif right and not left:
            return False
        elif not left and not right:
            return True
        elif left.val != right.val:
            return False
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        issame = outside and inside
        return issame

Mi_chelle

关注

8
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第十五天 | 层序遍历 10题 226.翻转二叉树 101.对称二叉树 2

python collections.deque() 是双端队列，可对队列两端append 和 pop，时间。自下而上的将result改成deque,每次appendleft最后返回再将result改成list。重复弹出并加入左右孩子，队列大小-=1，直到队列大小 == 0后更新记录队列大小。弹出根节点，左右孩子加入队列，记录当前队列大小。弹出一个，加入其左右孩子，队列大小 -=1。题解：用queue的长度找最后一个元素。昨晚上面十个层序遍历现在只会层序了…根节点进入队列，记录队列大小。
复制链接

扫一扫