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);
}
}