BFS算法套路框架

BFS问题的本质就是在一副“图”中找到起点 start 到终点 target 的最短距离。

模板框架

//计算从起点start到终点target的最短路径
int BFS(Node start,Node target){
    Queue<Node> q;
    Set<Node> visited; //避免走回头路
    
    q.offer(start);  //将起点加入队列
    visited.add(start);  //记录扩散的步数
    int step = 0;

    while(q not empty){
        int sz = q.size();
        for(int i=0;i<sz;i++){
            Node cur = q.poll();
            if(cur is target){ //这里判断是否到达终点
                return step;
            }
            /* 将cur的相邻节点加入队列 */
            for(Node x : cur.adj()){
                if(x not in visited){
                    q.offer(x);
                    visited.add(x);
                }
            }
            //划重点：在这里更新步数
            step++;
        }
    }
}

例题：二叉树的最小高度

【leetcode111 二叉树的最小深度】

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        int depth = 1;

        while(!q.isEmpty()){
            int sz = q.size();
            for(int i=0;i<sz;i++){
                TreeNode cur = q.poll();
                if(cur.left == null && cur.right==null){
                    return depth;
                }
                if(cur.left != null){
                    q.offer(cur.left);
                }
                if(cur.right != null){
                    q.offer(cur.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

【leetcode 103 二叉树的锯齿形层序遍历】（双端队列）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root==null) return res;

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        boolean isOrderLeft = true;

        while(!q.isEmpty()){
            Deque<Integer> levelList = new LinkedList<Integer>();
            int sz = q.size();
            for(int i=0;i<sz;i++){
                TreeNode cur = q.poll();
                if(isOrderLeft){
                    levelList.offerLast(cur.val);
                }
                else{
                    levelList.offerFirst(cur.val);
                }
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }
            }
            res.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;
        }
        return res;
    }
}

【leetcode107 二叉树的层序遍历II】

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null) return res;
        Deque<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()){
            Deque<Integer> levelList = new LinkedList<Integer>();
            int sz = q.size();
            for(int i=0;i<sz;i++){
                TreeNode cur = q.poll();
                levelList.offerLast(cur.val);
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }
            }
            res.add(new LinkedList<Integer>(levelList));
        }   
        Collections.reverse(res);
        return res;
    }
}

 

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> neighbors;
    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}
*/

class Solution {
    public Node cloneGraph(Node node) {
        if(node == null) return node;
        HashMap<Node,Node> visited = new HashMap();
        LinkedList<Node> queue = new LinkedList<Node>();
        queue.add(node);
        visited.put(node, new Node(node.val, new ArrayList()));
        while(!queue.isEmpty()){
            Node n = queue.remove();
            for(Node neighbor:n.neighbors){
                if(!visited.containsKey(neighbor)){
                    visited.put(neighbor, new Node(neighbor.val,new ArrayList()));
                    queue.add(neighbor);
                }
                visited.get(n).neighbors.add(visited.get(neighbor));
            }
        }
        return visited.get(node);
    }
}