广度优先搜索算法（借助队列实现，存储结构：邻接矩阵）

思想：首先给初始访问点进队，然后判断队列非空，取队顶元素存在node中，出队，访问，visited=true，然后for循环从j=0到j=n-1，g[node][j]=0&&visited[j]=false的进队并visited[j]=false;

核心代码：public static void BFSTravel(int[][] Graph,int n,int i){
       Queue<Integer> queue=new LinkedList<Integer>();
       queue.add(i);
       while(!queue.isEmpty()){
           int node=queue.peek();
           queue.poll();
           visit(node);
           visited[node]=true;
           for(int j=0;j<n;j++){
               if(visited[j]==false&&Graph[node][j]!=0){
                   queue.add(j);
                   visited[j]=true;
               }
           }
       } }

完整代码：

package BFS;

import java.util.LinkedList;
import java.util.Queue;

public class BFS {
public static boolean[] visited=new boolean[20];

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       for (int i = 0; i < visited.length; i++) {
           visited[i] = false;
           }
int[][] Graph={{0,1,1,0,0,0,0,0},
       {1,0,0,1,1,0,0,0},
       {1,0,0,0,0,1,1,0},
       {0,1,0,0,0,0,0,1},
       {0,1,0,0,0,0,0,1},
       {0,0,1,0,0,0,1,0},
       {0,0,1,0,0,1,0,0},
       {0,0,0,1,1,0,0,0}};
int n=8;
int i=2;
BFSTravel(Graph,n,i-1);
   }
   //从顶点i出发开始访问
   public static void BFSTravel(int[][] Graph,int n,int i){
       Queue<Integer> queue=new LinkedList<Integer>();
       queue.add(i);
       while(!queue.isEmpty()){
           int node=queue.peek();
           queue.poll();
           visit(node);
           visited[node]=true;
           for(int j=0;j<n;j++){
               if(visited[j]==false&&Graph[node][j]!=0){
                   queue.add(j);
                   visited[j]=true;
               }
           }
       }

   }
   private static void visit(int i) {
       // TODO Auto-generated method stub
       System.out.print(i+1+" ");
   }

}
测试结果：

2 1 4 5 3 8 6 7

原文链接：https://blog.csdn.net/u014596378/article/details/82109328