图的广度优先遍历(BFS)

图的相关概念先省略，对于广度优先遍历（BFS）：

1、从第一个顶点开始，每走一步依次遍历与此相连的顶点。

2、然后输出第一个顶点，再依次遍历与第二个顶点相连的所有顶点

3、重复第二步，直到遍历完所有顶点。

直接说一个例子：对于一个图，邻接表与邻接矩阵如下

BFS实现流程：

（1）实例化一个队列，从邻接矩阵中的第一个顶点，依次放入与此相连的顶点

（2）遍历完与第一个顶点相连的所有顶点后，弹出第一个顶点，然后遍历与第二个顶点相连的顶点（除去前面已经进队的顶点）。

（3）按照上一步操作，依次执行

（4）依次进队

（5）弹出队列中所有元素

实现代码：

//用来定义顶点的JavaBean
public class Vertex {
	 private String value;
	public boolean visited;
	 
	 public Vertex(String value) {
		 this.setValue(value);
	 }
	 public Vertex() {
		 
	 }

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}	  
}

//生成图以及定义各种方法的类
public class Graph {
	Vertex[] vertex;
	public int[][] adjMat;
	int currentSize;
	
	
	//构造方法，传入顶点的数量
	public Graph(int size) {
		vertex = new Vertex[size];
		adjMat = new int[size][size];
		//初始化邻接矩阵的对角线元素为1
		for(int i=0;i<vertex.length;i++) {
			for(int j=0;j<vertex.length;j++) {
				if(i ==j) {
					adjMat[i][j] =1;
				}
			}
		}
	}
	//把顶点加入到顶点数组中
	public void addVertex(Vertex v) {
		vertex[currentSize++] = v;
	}
	//把边加入到图中
	public void addEdge(String v1, String v2) {
		//定义一个变量，用来记录数组中值与v1相等的索引
		int index1 = 0;
		//在数组中找与v1相等的值的索引值
		for(int i=0; i<vertex.length;i++) {
			if(vertex[i].getValue().contentEquals(v1)) {
				index1 = i;
				break;
			}			
		}
		//记录与v2相等的索引
		int index2 = 0;
		for(int i=0;i<vertex.length;i++) {
			if(vertex[i].getValue().contentEquals(v2)) {
				index2 = i;
				break;
			}
		}
		//把矩阵中的数置为1表示有链接
		adjMat[index1][index2] =1;
		adjMat[index2][index1] =1; 	
	}
	
   //广度优先搜索遍历
   public void bfs() {
       //初始化顶点矩阵的访问标志
	   for(int i=0;i<vertex.length;i++)
		   vertex[i].visited = false;
       //定义队列
	   Queue<String>queue = new LinkedList<String>();
       //把第一个顶点的访问标志置为true
	   vertex[0].visited =true;
      //把第一个顶点的值放入队列中
	   queue.add(vertex[0].getValue());
      //记录邻接矩阵的行
	   int currentIndex = 0;
	   //循环
       while(!queue.isEmpty()){
           for(int i=currentIndex+1;i<vertex.length;i++){
               //如果存在和前一个顶点的连接，且尚未加入队列中
               if(adjMat[currentIndex][i]==1&&vertex[i].visited==false){
            	  //置访问标志为true 
                      vertex[i].visited =true;
                      //把顶点值加入队列
            	   queue.add(vertex[i].getValue());
               }
           }         
           //弹出队头元素
           System.out.println(queue.remove());
           //判断栈是否为空，
           if(queue.isEmpty() ==false){ 
               //行自增     	 
               currentIndex++;
           }          
       }
   }
   //测试
   public static void main(String[] args){	
		String[] arr = new String[] {"A","B","C","D","E"};
		
		Vertex v1 = new Vertex(arr[0]);
		Vertex v2 = new Vertex(arr[1]);
		Vertex v3 = new Vertex(arr[2]);
		Vertex v4 = new Vertex(arr[3]);
		Vertex v5 = new Vertex(arr[4]);

		//实例化一个图对象
		Graph g = new Graph(5);
		//把顶点加入图中
		g.addVertex(v1);
		g.addVertex(v2);
		g.addVertex(v3);
		g.addVertex(v4);
		g.addVertex(v5);
		//把边加入到图中
	    g.addEdge("A","B");
	    g.addEdge("A","C");
	    g.addEdge("B","C");
	    g.addEdge("B","D");
	    g.addEdge("B","E");
		
	    //遍历邻接矩阵
	    for(int[] s:g.adjMat) {
	    	System.out.println(Arrays.toString(s));
	    }
        //深度优先搜索算法
	    g.dfs();   
   }
}