0092 图
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
/*
* 图
* 图是一种数据结构，其中节点可以具有零个或多个相邻元素。
* 两个节点之间的连接称为边，结点也成为顶点
*
* 常用概念
* 1.顶点
* 2.边
* 3.路径
* 4.无向图
* 5.有向图
* 6.带权图
*
* 表示方式：邻接矩阵（二维数组），邻接表（链表）
*
* 图的创建
* 1.存储顶点 String,使用ArrayList
* 2.保存矩阵 int[][] edges
*
* 图的遍历
* 1.深度优先遍历（DFS）
* 1.从初始访问点出发，先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点
* 即：每次访问当前结点后首先访问当前结点的第一个邻接结点
* 2.访问策略：优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问
* 3.是一个递归的过程
* 步骤：
* 1.访问初始结点v，并标记结点v为已访问
* 2.查找结点v的第一个邻接结点w
* 3.若w存在，执行4，若w不存在，回到1，从v的下一个邻接结点继续访问
* 4.若w未被访问，对w进行深度优先遍历递归（即把w当成v，继续进行1，2，3）
* 5.查找结点v的邻接结点w的下一个邻接结点，回到3
* 2.广度优先遍历（BFS）
* 类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序
* 以便按这个顺序来访问这些结点的邻接结点
* 步骤：
* 1.访问初始结点v并标记结点v为已访问
* 2.结点v入队列
* 3.当队列非空，继续执行，否则结束
* 4.出队列，取得队头结点u
* 5.查找结点u的第一个邻接结点w
* 6.若w不存在，回到3，否则循环执行下面步骤
* 6.1结点w未被访问，则访问结点w并标记为已访问
* 6.2结点w入队列
* 6.3查找结点u（除了w)的下一个邻接结点w，回到6
*/
public class Graph {
private ArrayList
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);
}
//添加边
//A-B,A-C,B-C,B-D,B-E
graph.insertEdge(0, 1, 1);//A-B
graph.insertEdge(0, 2, 1);//A-C
graph.insertEdge(1, 2, 1);//B-C
graph.insertEdge(1, 3, 1);//B-D
graph.insertEdge(1, 4, 1);//B-E
//显示对应矩阵
graph.showGraph();
//深度优先遍历
//graph.dfs();
//广度优先遍历
graph.bfs();
}
//构造器
public Graph(int n) {
//初始化
edges = new int[n][n];
vertexList = new ArrayList
numOfEdges = 0;
isVisited = new boolean[5];
}
//得到第一个邻接结点的下标w
//如果存在返回对应下标，否则返回-1
public int getFirstNeighbor(int index) {
for(int j = 0;j < vertexList.size();j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
//根据前一个邻接结点的下标，获取下一个邻接结点
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;
}
//深度优先遍历算法
private void dfs(boolean[] isVisited,int i) {
//访问该结点，输出
System.out.print(getValueByIndex(i) + "->");
//将结点置为已访问
isVisited[i] = true;
//查找结点v的第一个邻接结点w
int w = getFirstNeighbor(i);
while(w != -1) {//w存在
if (!isVisited[w]) {
dfs(isVisited, w);
}
//如果w结点已被访问
w = getNextNeighbor(i, w);
}
}
//对dfs进行重载，遍历所有结点并进行dfs
public void dfs() {
//遍历所有结点
for(int i = 0;i < getNumOfVertex();i++) {
if (!isVisited[i]) {
dfs(isVisited, i);
}
}
}
//广度优先遍历算法
private void bfs(boolean[] isVisited,int i) {
int u;//表示队列的头结点对应的下标
int w;//表示邻接结点
//队列,记录结点访问顺序
LinkedList queue = new LinkedList();
//访问结点，输出
System.out.print(getValueByIndex(i) + "->");
//标记为已访问
isVisited[i] = true;
//加入队列
queue.addLast(i);
while(!queue.isEmpty()) {
//取出队列头结点下标
u = (Integer) queue.removeFirst();
//得到第一个邻接结点的下标w
w = getFirstNeighbor(u);
while(w != -1) {
//是否访问过
if (!isVisited[w]) {
System.out.print(getValueByIndex(w)+ "->");
//标记已访问
isVisited[w] = true;
//入队
queue.addLast(w);
}
//w已被访问，找w后面的邻接结点
w = getNextNeighbor(u, w);
}
}
}
//对bfs进行重载，遍历所有结点并进行bfs
public void bfs() {
for(int i = 0;i < getNumOfVertex();i++) {
if (!isVisited[i]) {
bfs(isVisited, i);
}
}
}
//显示对应的矩阵
public void showGraph() {
for(int[] link : edges) {
System.out.println(Arrays.toString(link));
}
}
//返回结点个数
public int getNumOfVertex() {
return vertexList.size();
}
//返回边的数目
public int getNumOfEdges() {
return numOfEdges;
}
//返回结点i对应的数据
public String getValueByIndex(int i) {
return vertexList.get(i);
}
//返回v1,v2的权值
public int getWeight(int v1,int v2) {
return edges[v1][v2];
}
//插入顶点
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
//添加边
//v1,v2表示点的下标，weight表示权值
public void insertEdge(int v1,int v2,int weight) {
edges[v1][v2] = weight;
edges[v2][v1] = weight;
numOfEdges++;
}
}