代码随想录 - Day20 - 二叉树

代码随想录 - Day20 - 二叉树

二叉树的层序遍历

用队列来做这道题，思路不难

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

107. 二叉树的层序遍历 II

和上一题思路一致，最后返回倒过来的结果就可以了

class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        res = []
        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)
            res.append(level)
        return res[::-1]

199. 二叉树的右视图

注意在本题中，不能直接在if判断中用len(queue)

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

637. 二叉树的层平均值

基础层序遍历，加上平均值的计算就好了

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

429. N 叉树的层序遍历

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

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

基础层序遍历+找每个level的最大值

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        queue = collections.deque([root])
        res = []
        while queue:
            size = len(queue)
            level = []
            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)
            level.sort(key=None, reverse=True)
            res.append(level[0])
        return res

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

原本所有的都指向NULL，所以不用管指向NULL的，只需要把不该指向NULL的改到它本该指向的节点就行。

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            prev = None
            for i in range(size):
                cur = queue.popleft()
                if prev:
                    prev.next = cur
                prev = 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)
            prev = None
            for i in range(size):
                cur = queue.popleft()
                if prev:
                    prev.next = cur
                prev = 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])
        cnt = 0
        while queue:
            size = len(queue)
            for _ in range(size):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            cnt += 1
        return cnt

111. 二叉树的最小深度

注意一下cnt += 1的位置

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

总结

做层序遍历的时候没有看递归法，只看了基础的模板
层序遍历比较好理解，多敲一敲，手熟了就写的快了
相关题目基本是在原代码基础上修改即可做出来