代码随想录Day14笔记-二叉树遍历方法层序遍历

层序遍历

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。
队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历。

Python：

方法一：

使用队列

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: 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

方法二：递归法

自身调用自身函数

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        levels=[]
        self.helper(root,0,levels)
        return levels
    def helper(self, node, level, levels):
        if not node:
            return
        if len(levels) == level:
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level + 1, levels)
        self.helper(node.right, level + 1, levels)

107.二叉树的层次遍历 II

方法一

使用队列，迭代解法

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: 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.二叉树的右视图

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

637.二叉树的层平均值

class Solution:
    def averageOfLevels(self, root) :
        if not root:
            return []
        queue=collections.deque([root])
        result=[]            
        while queue:
            size=len(queue)
            sum_=0
            for i in range(size):
                cur=queue.popleft()
                sum_+=cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(sum_ / size)
        return result

429.N叉树的层序遍历

N叉数有多个子节点，用node.children

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        queue=collections.deque([root])
        result=[]
        while queue:
            size=len(queue)
            level=[]
            for _ in range(size):
                node = queue.popleft()
                level.append(node.val)
                for child in node.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:
            size=len(queue)
            # max_value=float('-inf')
            level=[]
            for _ in range(size):
                cur=queue.popleft()
                level.append(cur.val)
                # max_value=max(max_value,cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            # result.append(max_value)
            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:
            size=len(queue)
            pret=None
            for i in range(size):
                cur=queue.popleft()
                if pret:
                    pret.next=cur
                pret=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)
            pret=None     
            for i in range(size):
                cur=queue.popleft()
                if pret:
                    pret.next=cur
                pret=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])
        path=0
        while queue:
            size=len(queue)
            path+=1
            for i in range(size):
                cur=queue.popleft()

                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return path

111.二叉树的最小深度

当没有左右节点是，就返回path

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