package DataStructures.graph;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
public class Graph {
private ArrayList<String> vertexList; //存储顶点集合
private int[][] edges; //存储图对应的邻接矩阵
private int numOfEdges; //表示边的数目
//定义数组boolean[],记录某个节点是否被访问
private boolean[] isVisited;
public static void main(String[] args) {
int n = 5;
String[] Vertexs = {"A","B","C","D","E"};
Graph graph = new Graph(n);
//循环添加顶点
for( String vertex: Vertexs ) {
graph.insertVertex(vertex);
}
//添加边
graph.insertEdge(0,1,1);
graph.insertEdge(0,2,1);
graph.insertEdge(1,2,1);
graph.insertEdge(1,3,1);
graph.insertEdge(1,4,1);
graph.showGraph();
// System.out.println("深度优先搜索:");
// graph.dfs();
System.out.println();
System.out.println("广度优先搜索:");
graph.bfs();
}
/**
* 构造器
* @param n
*/
public Graph(int n) {
//初始化矩阵和vertexList
edges = new int[n][n];
vertexList = new ArrayList<String>(n);
numOfEdges = 0;
isVisited = new boolean[n];
}
/**
*
* @param index
* @return 返回第一个邻接节点的下标
*/
public int getFirstNeighbor(int index) {
for( int j = 0; j < vertexList.size(); j++ ) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
/**
* 根据前一个邻接节点的下标来获取下一个邻接节点
* @param v1
* @param v2
* @return
*/
public int getNextNeighbor(int v1, int v2) {
for ( int j = v2 + 1; j < vertexList.size(); j++ ) {
if (edges[v1][j] > 0) {
return j;
}
}
return -1;
}
/**
* 深度优先遍历算法
* @param isVisited
* @param i
*/
public void dfs(boolean[] isVisited, int i) {
System.out.print(getValueByIndex(i)+"->");
isVisited[i] = true;
int w = getFirstNeighbor(i);
while ( w != -1 ) {
if ( !isVisited[w] ) {
dfs(isVisited,w);
}
w = getNextNeighbor(i,w);
}
}
/**
* 对dfs进行重载,遍历所有的节点,并进行dfs
*/
public void dfs() {
for ( int i = 0; i < getNumOfVertex(); i++ ) {
if ( !isVisited[i] ) {
dfs(isVisited,i);
}
}
}
/**
* 对一个节点进行广度优先遍历
* @param isVisited
* @param i
*/
public void bfs(boolean[] isVisited, int i) {
int u; //表示队列的头节点对应下标
int w; //邻接节点w
//队列,节点访问顺序
LinkedList queue = new LinkedList();
System.out.print(getValueByIndex(i)+"->");
isVisited[i] = true;
queue.addLast(i);
while ( !queue.isEmpty() ) {
u = (Integer)queue.removeFirst();
w = getFirstNeighbor(u);
while ( w != -1 ) {
if (!isVisited[w]) {
System.out.print(getValueByIndex(w)+"->");
isVisited[w] = true;
queue.addLast(w);
}
w = getNextNeighbor(u,w);//体现出广度优先
}
}
}
/**
* 遍历所有的节点,都进行广度优先搜索
*/
public void bfs() {
for ( int i = 0; i < getNumOfVertex(); i++ ) {
if (!isVisited[i]) {
bfs(isVisited,i);
}
}
}
/**
*
* @return 返回节点的个数
*/
public int getNumOfVertex() {
return vertexList.size();
}
/**
*
* @return 返回边的数目
*/
public int getNumOfEdges() {
return numOfEdges;
}
/**
*
* @param i
* @return 返回节点 i对应的数据
*/
public String getValueByIndex(int i) {
return vertexList.get(i);
}
/**
*
* @param v1
* @param v2
* @return 返回节点v1和v2之间的权值
*/
public int getWeight(int v1, int v2) {
return edges[v1][v2];
}
/**
* 插入节点
* @param vertex
*/
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
/**
* 显示对应的矩阵
*/
public void showGraph() {
for( int[] link: edges ) {
System.out.println(Arrays.toString(link));
}
}
/**
* 添加边
* @param v1 第一个顶点对应的下标
* @param v2 第二个顶点对应的下标
* @param weight 要插入边的权值
*/
public void insertEdge(int v1, int v2, int weight) {
edges[v1][v2] = weight;
edges[v2][v1] = weight;
numOfEdges++;
}
}
图的创建以及DFS、BFS
最新推荐文章于 2024-06-14 09:55:36 发布