数据结构之广度优先搜索

广度优先搜索呈现出一层一层向外扩张的特点，先看到的结点先遍历，后看到的结点后遍历，因此广度优先搜索可以借助**队列**实现。当遍历到一个结点时，若这个结点有左（右）孩子结点，依次入队即可。结合队列实现思路如下图所示：

BFS模板代码

int BFS(Node root, Node target){
    Queue<Node> queue = new ArrayDeque<>();
    int step = 0;
    //添加根节点到队列
    queue.add(root);
    //BFS
    while(queue is not empty){
        step++;
        int size = queue.size();
        for(int i = 0; i < size; i++){
            //获取队头元素
            Node curr = this first node in queue;
            //若curr == target,返回step
            if(curr == target) return setp;
            for(Node next : the neighbors of curr){
                add next to queue;
            }
            remove the first node from queue;
        }
    }
    return -1;
}

如代码所示，在每一轮中，队列中的结点是等待处理的结点。在每个更外一层的 while 循环之后，我们距离根结点更远一步。变量 step 指示从根结点到我们正在访问的当前结点的距离。

二叉树的层序遍历

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

示例：

二叉树：[3,9,20,null,null,15,7]

输出结果：

[   
  [3],   
  [20,9],   
  [15,7]
] 

代码实现：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if(root != null){
            deque.offer(root);
        }
        while(!deque.isEmpty()){
            //遍历的层数
            int n = deque.size();
            //保存每一层的节点值
            List<Integer> nodes = new ArrayList<>();
            for(int i = 0; i < n; i++){
                //出队
                TreeNode node = deque.poll();
                //添加元素
                nodes.add(node.val);
                // 若根节点的左节点不为空，入队
                if(node.left != null){
                    deque.offer(node.left);
                }
                // 若根节点的右节点不为空，入队
                if(node.right != null){
                    deque.offer(node.right);
                }
            }
            res.add(nodes);
        }
        return res;
    }
}

二叉树的Z字形层序遍历

给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）
例如： 给定的二叉树是{3,9,20,#,#,15,7},

输出结果：

[   
  [3],   
  [20,9],   
  [15,7]
] 

代码实现：

public class Solution {
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        boolean isLeft = true;//true从左往右，false从右往左
        if(root != null){
            queue.offer(root);
        }
        while(!queue.isEmpty()){
            int n = queue.size();
            ArrayList<Integer> temp = new ArrayList<>();//保存每层的节点
            for(int i = 0; i < n; i++){
                TreeNode node = queue.poll();
                //判断是向左添加还是向右添加节点值
                if(isLeft){
                    temp.add(node.val);//尾部添加值
                }else{
                    temp.add(0, node.val);//向头部添加值
                }
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            isLeft = !isLeft;
            res.add(temp);
        }
        return res;        
    }
}