4.6 图的邻接矩阵存储及DFS和BFS

介绍

1. DFS：深度优先搜索
2. BFS：广度优先搜索

代码

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;

/**
 * 1. 图的存储
 * 2. dfs: 深度优先搜索， 递归实现
 * 3. bfs: 广度优先搜索
 * @author dxt
 *
 */
public class Graph {
	private ArrayList<String> vertexList;	//存储顶点集合
	private int[][] edges;		//存储图对应的邻接矩阵
	private int numOfEdges; 	//边的树目
	
	//构造器
	public Graph(int n) {
		vertexList = new ArrayList<>(n);
		edges = new int[n][n];
		numOfEdges = 0;
	}
	//插入节点
	public void insertVertex(String vertex) {
		vertexList.add(vertex);
	}
	//添加一条边
	public void insertEdge(int v1, int v2, int weight) {
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numOfEdges++;
	}
	
	//返回节点数目
	public int getNumOfVertex() {
		return vertexList.size();
	}
	
	//返回边的数目
	public int getNumOfEdges() {
		return numOfEdges;
	}
	
	//返回第i个加入的节点
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}
	
	//返回节点的索引编号,-1表示图中没有节点
	public int getIndexOfNode(String s) {
		//判断图是否为空
		if(vertexList.size() <= 0) {
			return -1;
		}
		//返回对应节点的编号
		for(int i=0; i<vertexList.size(); i++) {
			if(vertexList.get(i).equals(s)) {
				return i;
			}
		}
		return -1;
	}
	
	//返回边(v1,v2)的权重
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}
	
	//输出邻接矩阵
	public void showEdges() {
		for(int[] link : edges) {
			System.out.println(Arrays.toString(link));
		}
	}
	
	//深度优先搜索，递归部分
	private void dfs(int index, boolean[] readList) {
		//1. 先输出第i个节点的值, 并设置此节点已经被访问
		System.out.print(this.getValueByIndex(index) + "\t");
		readList[index] = true;
		
		//2. 找第i个节点指向的一个节点
		for(int i = 0; i<vertexList.size(); i++) {
			if(edges[index][i] != 0 && readList[i] == false) {
				dfs(i, readList);
			}
		}
	}
	
	//深度优先搜索，递归实现，从节点n开始
	public void dfs(String n) {
		//判断图是否合法
		if(vertexList.size() == 0) {
			System.out.println("图为空");
			return;
		}
		
		//1. 得出节点n的索引值
		int index = this.getIndexOfNode(n);
		if(index == -1) {
			System.out.println("图中不包含对应节点");
			return;
		}
		//2. 获得图中点的个数
		int size = vertexList.size();
		//3. 声明一个boolean数组readArr， readArr数组用于判断节点是否已被访问过
		boolean[] readArr = new boolean[size];
		for(int i=0; i<size; i++) {	//readArr[i]==false 表示第i个节点没有被访问过
			readArr[i] = false;
		}
		
		//4. 进行深度优先搜索，当图是连通图时，所有点才能都被访问到
		System.out.println("DFS:");
		dfs(index, readArr);	//从节点index开始进行深度优先搜索
		
		//当图为非连通图时，也可以访问所有节点，但此时readArr数组应是一个全局变量，下面代码提供思路，不能正确运行
//		for(int i = 0; i<size; i++) {
//			int j = (index + i) % size;
//			if(!readArr[j]) {
//				dfs(j, readArr);	//从节点index开始进行深度优先搜索
//			}
//		}
		
		System.out.println();
	}
	
	//广度优先搜索
	public void bfs(String n) {
		//判断图是否合法
		if(vertexList.size() == 0) {
			System.out.println("图为空");
			return;
		}
				
		//1. 得出节点n的索引值
		int index = this.getIndexOfNode(n);
		if(index == -1) {
			System.out.println("图中不包含对应节点");
			return;
		}	
		
		//2. 获得图中点的个数
		int size = vertexList.size();
		//3. 声明一个boolean数组readArr， readArr数组用于判断节点是否已被访问过
		boolean[] readArr = new boolean[size];
		for(int i=0; i<size; i++) {	//readArr[i]==false 表示第i个节点没有被访问过
			readArr[i] = false;
		} 
		
		//4. 开始进行BFS
		System.out.println("BFS:");
		//4.1 声明一个队列
		Queue<Integer> q = new ArrayDeque<>();
		//4.2 起始节点入队列
		q.add(index);
		readArr[index] = true;
		//4.3 当队列不为空时，始终获取队列中的第一个节点，然后将此节点的相邻节点入队列，然后输出此节点
		// 注意： 当图为连通图时，可以输出所有节点;当图不连通时，只能输出包含参数节点的那个连通图
		while(!q.isEmpty()) {
			//4.3.1 获取此节点,并删除此节点
			int i = q.poll();	//poll() 返回队列中第一个节点元素，并删除此节点
			//4.3.2 向队列中添加此节点的相邻节点
			for(int j = 0; j<size; j++) {
				//如果相邻节点没有被访问过，则将其添加到队列中，否则不对此相邻节点进行操作
				if(edges[i][j] != 0 && readArr[j] == false) {
					q.add(j);
					readArr[j] = true;	//添加到队列中，就相当于被访问了
				}
			}
			//4.3.3 输出此节点
			System.out.print(this.getValueByIndex(i) + "\t");
		}
		System.out.println();
	}
	
	
	//测试
	public static void main(String[] args) {
		int n = 6;	//图中顶点个数
		String[] vertexs = {"A", "B", "C", "D", "E", "F"};
		//1. 创建图对象
		Graph g = new Graph(n);
		//1.1 构建点集
		
		for(String v : vertexs) {
			g.insertVertex(v);
		}
		//1.2 构建边集 A-B A-C B-C B-D B-E
		g.insertEdge(0, 1, 1);
		g.insertEdge(0, 2, 1);
		g.insertEdge(1, 2, 1);
		g.insertEdge(1, 3, 1);
		g.insertEdge(1, 4, 1);
		g.insertEdge(4, 5, 1);
		
		//2.1 显示图的邻接矩阵
		g.showEdges();
		
		//2.2 测试深度优先搜索
		g.dfs("A");
		g.dfs("E");
		
		//2.3 测试广度优先搜索
		g.bfs("A");
		g.bfs("B");
		g.bfs("E");
	}
}

结果