算法套路九——二叉树广度优先遍历（层序遍历）

算法示例LeetCode102. 二叉树的层序遍历

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

法一：双数组

在层序遍历时采用两个数组来记录，如下图所示，cur记录当前结点，通过遍历cur将cur中的节点的子结点放入nxt中，同时将cur值记录在vlas中，之后令cur=nxt重新遍历cur。


cur为空时即所有结点遍历完成，退出循环。

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        cur=[root]
        ans=[]
        while cur:
            nxt=[]
            vals=[]
            for node in cur:
                vals.append(node.val)
                if node.left: nxt.append(node.left)
                if node.right:nxt.append(node.right)
            cur=nxt
            ans.append(vals)
        return ans

法二：队列

与两个数组类似，队列中首先存当前遍历的节点，之后根据当前队列的长度遍历队列，将每个节点的左右子结点加入队列中，并将队列最左侧元素出队。

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        q=deque([root])
        ans=[]
        while q:
            vals=[]
            for _ in range(len(q)):
                node=q.popleft()
                vals.append(node.val)
                if node.left: q.append(node.left)
                if node.right:q.append(node.right)
            ans.append(vals)
        return ans

这两种方法只有细微的地方有代码的区别，故可以选一种自己认为比较顺手的作为常用解法

算法练习一：LeetCode103. 二叉树的锯齿形层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

本题与上题类似，只是需要增加一个bool变量even记录当前层数是否为偶数，若为偶数，则需要在将值添加进vals进行反向添加，即vals[len(cur)-1-i]=node.Val

法一：双数组

func zigzagLevelOrder(root *TreeNode) (ans [][]int) {
    if root==nil{
        return 
    }
    cur:=[]*TreeNode{root}
    even:=false
    for len(cur)>0{
        nxt:=[]*TreeNode{}
        vals:=make([]int,len(cur))
        for i,node:=range cur{
            if even{vals[len(cur)-1-i]=node.Val}else{vals[i]=node.Val }
            if node.Left != nil {nxt  = append(nxt , node.Left)}
            if node.Right != nil { nxt  = append(nxt , node.Right)}
        }
        cur=nxt
        even = !even
        ans=append(ans,vals)
    }
    return
}

法二：队列

func zigzagLevelOrder(root *TreeNode) (ans [][]int) {
    if root==nil{
        return 
    }
    q:=[]*TreeNode{root}
    even:=false
    for len(q)>0{
        n:=len(q)
        vals:=make([]int,n)
        for i:=0;i<n;i++{//对遍历变量有修改时，不能使用for range遍历
            node:=q[0]
            q=q[1:]
            if even{vals[n-1-i]=node.Val}else{vals[i]=node.Val }
            if node.Left != nil {q = append(q, node.Left)}
            if node.Right != nil { q = append(q, node.Right)}
        }
        ans=append(ans,vals)
        even=!even
    }
    return
}

算法练习二：LeetCode104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

本题在之前使用了递归解决，这里使用广度优先层序遍历队列来解决

法一：双数组

func maxDepth(root *TreeNode)  int {
    if root==nil{
        return 0
    }
    cur:=[]*TreeNode{root}
    maxD:=0
    for len(cur)!=0{
        nxt:=[]*TreeNode{}
        maxD++
        for _,node:=range cur{
            if node.Left!=nil{nxt=append(nxt,node.Left)}
            if node.Right!=nil{nxt=append(nxt,node.Right)}
        }
        cur=nxt 
    }
    return maxD
}

法二：队列

func maxDepth(root *TreeNode)  int {
    if root==nil{
        return 0
    }
    q:=[]*TreeNode{root}
    maxD:=0
    for len(q)!=0{
        maxD++
        n:=len(q)
        for i:=0;i<n;i++{
            node:=q[0]
            q=q[1:]
            if node.Left!=nil{q=append(q,node.Left)}
            if node.Right!=nil{q=append(q,node.Right)}
        }
        
    }
    return maxD
}

算法练习三：LeetCode111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

使用广度优先搜索的方法遍历整棵树。
当我们找到一个叶子节点时，直接返回这个叶子节点的深度。层序遍历的性质保证了最先搜索到的叶子节点的深度一定最小。

func minDepth(root *TreeNode) int {
    if root==nil{
        return 0
    }
    minD:=0
    q:=[]*TreeNode{root}
    for len(q)!=0{
        minD++
        n:=len(q)
        for i:=0;i<n;i++{
            node:=q[0]
            q=q[1:]
            if node.Left==nil&&node.Right==nil{return minD}
            if node.Left!=nil{q=append(q,node.Left)}
            if node.Right!=nil{q=append(q,node.Right)}
            }
        }
        return -1
}

算法进阶一：LeetCode513. 找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。

此题有一定难度，因为是要找到最底层最左边节点的值，想到层序遍历，那么如何得到最左边的节点呢，我们可以在进行层序遍历时每次都从右往左入队，这样每次都是上层、右边的节点先出队，故最底层最左边的节点最后出队

func findBottomLeftValue(root *TreeNode) int {
    q:=[]*TreeNode{root}
    var node *TreeNode
    for len(q)>0{
        node=q[0]
        q=q[1:]
        if node.Right!=nil{
            q=append(q,node.Right)
        }
        if node.Left!=nil{
            q=append(q,node.Left)
        }
    }
    return node.Val
}

算法进阶二：LeetCode199. 二叉树的右视图

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

此题之前使用深度遍历递归时有一定难度，但如果使用广度优先的层序遍历，则很明显，只需要记录队列每一层的最后一个结点即可

func rightSideView(root *TreeNode) []int {
    if root==nil{
        return []int{}
    }
    ans:=[]int{}
    q:=[]*TreeNode{root}
    for len(q)!=0{
        n:=len(q)
        for i:=0;i<n;i++{
            node:=q[0]
            q=q[1:]
            if node.Left!=nil{q=append(q,node.Left)}
            if node.Right!=nil{q=append(q,node.Right)}
            if i==n-1{
                ans=append(ans,node.Val)
            }
        }   
    }
    return ans
}