广度优先算法的步骤：

1.选定一个起始节点；

2.以选定节点为中心，所有与该节点相邻节点为备选节点（其中，在之前已经访问过的节点不得再纳入相邻节点），并将这些备选节点放入一个先进先出队列中，；

3.依次取出先进先出队列中的节点，并求得该节点的相邻节点放入先进先出队列中；

4.循环进行2、3步骤；知道先进先出队列为空（搜索结束的标志）；

接下来直接上java代码咯：

package Graph;import java.util.LinkedList;/***** *  * 从左上角到右下角，最短路径； * 广度搜索法； *  * *********/public class BFS {    /*****重要组成-方向******/    int[][] direct={
   {0,1},{0,-1},{-1,0},{1,0}};//四个方向，上下左右    /*****重要组成-标记******/    int[][] arc=new int[4][4];//辅助标记数组    /******输入数组*****/    int[][] array={            {
    1,2,3,4},            {
    5,6,7,8},            {
    9,10,11,12},            {
    13,14,15,16}           };    public static void main(String[] args) throws InterruptedException {        new BFS().BFS();    }    /*****重要组成-封装数组点，用坐标表示位置******/     class Node{         int row;         int column;         int round;         Node(int row,int column,int round) {            this.row=row;            this.column=column;            this.round=round;        }    }    public void BFS(){
   //广度搜索算法        Node start=new Node(0,0,0);        /*****重要组成-待搜索队列的每个对象都是接下来要所搜的值******/        LinkedList
     
       queue=new LinkedList<>();//待搜索队列        queue.offer(start);        arc[0][0]=1;        /*****重要组成-持续搜索的标志。待搜索队列里有东西******/        while(!queue.isEmpty()){            Node temp=queue.poll();            for(int i=0;i<4;i++){
   //尝试搜索四个方向的点，如果满足就加入待搜索队列中                int new_row=temp.row+direct[i][0];                int new_column=temp.column+direct[i][1];                if(new_row<0||new_column<0||new_row>=4||new_column>=4)                    continue;//该方向上出界，考虑下一方向                if(arc[new_row][new_column]==1)continue;                arc[new_row][new_column]=1;                Node next=new Node(new_row, new_column,temp.round+1);                queue.offer(next);                System.out.println("数值："+array[new_row][new_column]+",轮次："+(temp.round+1));            }        }    }}
     

运行结果：

数值：2,轮次：1数值：5,轮次：1数值：3,轮次：2数值：6,轮次：2数值：9,轮次：2数值：4,轮次：3数值：7,轮次：3数值：10,轮次：3数值：13,轮次：3数值：8,轮次：4数值：11,轮次：4数值：14,轮次：4数值：12,轮次：5数值：15,轮次：5数值：16,轮次：6

 

以上代码参考了下列博客：

面试题中经常会遇到，给定一个0,1矩阵，0表示可走，1表示不可走。求出从左上角到右下角的最短路径？

这里我们就可以用广度优先算法来实现（例子中给定的4*4数组）：

import java.util.LinkedList;public class Main {    /*****重要组成-方向******/    int[][] direct={
   {0,1},{0,-1},{-1,0},{1,0}};//四个方向，上下左右    /******输入数组*****/    int[][] array={            {
    0,0,0,0},            {
    0,0,1,0},            {
    0,0,1,0},            {
    0,0,1,0}           };    public static void main(String[] args) throws InterruptedException {        new Main().BFS();    }    /*****重要组成-封装数组点，用坐标表示位置******/     class Node{         int row;         int column;         int round;         Node pre;         Node(int row,int column,int round,Node pre) {            this.row=row;            this.column=column;            this.round=round;            this.pre=pre;        }    }    public void BFS(){
   //广度搜索算法        Node start=new Node(0,0,0,null);        /*****重要组成-待搜索队列的每个对象都是接下来要所搜的值******/        LinkedList
     
       queue=new LinkedList<>();//待搜索队列        queue.offer(start);        /*****重要组成-持续搜索的标志。待搜索队列里有东西******/        while(!queue.isEmpty()){            Node temp=queue.poll();            for(int i=0;i<4;i++){
   //尝试搜索四个方向的点，如果满足就加入待搜索队列中                int new_row=temp.row+direct[i][0];                int new_column=temp.column+direct[i][1];                if(new_row<0||new_column<0||new_row>=4||new_column>=4)                    continue;//该方向上出界，考虑下一方向                if(array[new_row][new_column]==1)continue;                Node next=new Node(new_row, new_column,temp.round+1,temp);                if(new_row==3&&new_column==3)//找到了出口                {                    queue.clear();                    queue.offerFirst(next);                    while(next.pre!=null){                        queue.offerFirst(next.pre);//以前获取父节点                        next=next.pre;                    }                    for(Node node:queue)                    {                        System.out.println("("+node.row+","+node.column+"),");                    }                }                array[new_row][new_column]=1;                queue.offer(next);            }        }    }}
     

执行结果：

(0,0),(0,1),(0,2),(0,3),(1,3),(2,3),(3,3),