广度优先遍历(BFS)

广度优先遍历基本思想

图的广度优先搜索(Broad First Search) 。

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

1)访问初始结点v并标记结点v为已访问。

2)结点v入队列

3)当队列非空时，继续执行，否则算法结束。

4)出队列，取得队头结点u。

5)查找结点u的第一个邻接结点w。

6)若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：

6.1 若结点w尚未被访问，则访问结点w并标记为已访问。

6.2 结点w入队列

6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

package com.zhen;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {
	//存放顶点
	private ArrayList<String> dot;
	//存放邻接矩阵
	private int[][] edge;
	//边的数量
	private int count=0;
	//节点的访问标识
	private boolean[] mark;
	
	public static void main(String[] args) {
		int n=5;
		String[] dot= {"A","B","C","D","E"};
		Graph graph = new Graph(5);
		//添加点
		for(String s:dot) {
			graph.addDot(s);
		}
		//添加边
		graph.adddEdge(0, 1, 1);
		graph.adddEdge(0, 2, 1);
		graph.adddEdge(1, 2, 1);
		graph.adddEdge(1, 3, 1);
		graph.adddEdge(1, 4, 1);
		
		graph.show();
		System.out.println("BFS");
		graph.bfs();
	}
	
	//初始化
	public Graph(int n) {
		edge=new int[n][n];
		dot = new ArrayList<String>(n);
		mark = new boolean[n];
	}
	//插入节点
	public void addDot(String s) {
		dot.add(s);
	}
	/**
	 * 添加边
	 * @param row  行节点的下标
	 * @param col  列节点的下标
	 * @param value  权值
	 */
	public void adddEdge(int row,int col,int value) {
		edge[row][col]=value;
		edge[col][row]=value;
		count++;
	}
	//获取节点个数
	public int getDotNum() {
		return dot.size();
	}
	//获取边的数目
	public int getEdgeNum() {
		return count;
	}
	//返回节点i(下标)对应的点名称  0->A,1->B,2->C...
	public String getS(int i) {
		return dot.get(i);
	}
	//返回权值
	public int getValue(int row,int col) {
		return edge[row][col];
	}
	//显示图对应的矩阵
	public void show() {
		for(int[] link:edge) {
			System.out.println(Arrays.toString(link));
		}
	}
	//得到第一个邻接节点的下标
	public int getFindex(int index) {
		for (int i = 0; i < dot.size(); i++) {
			if (edge[index][i]>0) {
				return i;
			}
		}
		return -1;
	}
	//根据前一个邻接节点的下标获取下一个邻接节点
	public int getNext(int row,int col) {
		for(int j=col+1;j<dot.size(); j++) {
			if (edge[row][j]>0) {
				return j;
			}
		}
		return -1;
	}
	//广度优先遍历
	public void bfs(boolean[] mark,int i) {
		//队列头节点对应的下标
		int head;
		//邻接节点w
		int w;
		//队列，记录节点的访问顺序
		LinkedList<Integer> queue= new LinkedList<>();
		//访问节点输出节点信息
		System.out.print(getS(i)+"->");
		//标记已访问
		mark[i]=true;
		//将节点加入队列
		queue.addLast(i);
		while(!queue.isEmpty()) {
			//取出队列的头结点下标
			head=queue.removeFirst();
			//得到第一个邻接节点的下标
			w=getFindex(head);
			//找到
			while(w!=-1) {
				//未访问过
				if (!mark[w]) {
					System.out.print(getS(w)+"->");
					//标记已访问
					mark[w] = true;
					//入队列
					queue.addLast(w);
				}
				//访问过,以head为前驱节点，找w后面的一个邻接点
				w=getNext(head, w);
			}
		}
	}
	//重载BFS遍历所有节点
	public void bfs() {
		for (int i = 0; i <getDotNum();i++) {
			if (!mark[i]) {
				bfs(mark, i);
			}
		}
	}
}