一、为什么要有图？
1、线性表局限于一个直接前驱和一个直接后继的关系
2、树也只能有一个直接前驱也就是父节点
3、当我们需要表示多对多的关系时， 这里我们就用到了图
二、什么是图？
图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图：
三、图的常用概念
顶点(vertex)：A,B,C,D,E
边(edge): 顶点之间的连接线
路径
无向图(右图)
四、图的表示方式
图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。
邻接矩阵
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1....n个点。
0：表示俩个顶点没有连接
1：表示俩个顶点是连接的【也可以用权值来表示】
邻接表
1、邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失.
2、邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
说明:
标号为0的结点的相关联的结点为 1 2 3 4
标号为1的结点的相关联结点为0 4，
标号为2的结点相关联的结点为 0 4 5
....
五、“图的应用”
要求: 代码实现如下图结构.
思路：
使用一个ArrayList来保存顶点ABCDE
用一个二维数组来保存邻接矩阵
代码实现：
//创建图
class Graph {
//保存顶点
ArrayList<String> verTexs = new ArrayList<>();
//保存邻接矩阵
int[][] edge;
//保存边的个数
int numsOfEdge = 0;
//n 顶点的个数
public Graph(int n) {
edge = new int[n][n];
}
//增加顶点
public void addVertex(String vertex) {
verTexs.add(vertex);
}
//增加边
/**
*
* @param v1 顶点
* @param v2 顶点
* @param weight 权值，0代表未连接，1代表已连接
*/
public void addEdge(int v1, int v2, int weight) {
edge[v1][v2] = weight;
edge[v2][v1] = weight;
numsOfEdge++;
}
//遍历邻接矩阵
public void show() {
for (int[] edges : edge) {
System.err.println(Arrays.toString(edges));
}
}
//返回顶点个数
public int VertexsNums() {
return verTexs.size();
}
//返回边的个数
public int EdgesNums() {
return numsOfEdge;
}
//返回顶点之间对应的权值
public int getWeight(int v1, int v2) {
return edge[v1][v2];
}
//通过下标返回对应的顶点
public String getVertex(int index) {
return verTexs.get(index);
}
}测试：
public static void main(String[] args) {
//测试
int n = 5 ;//顶点的个数
String[] verTex = {"A","B","C","D","E"};
Graph graph = new Graph(n) ;
//插入顶点
for (int i = 0; i < verTex.length; i++) {
graph.addVertex(verTex[i]);
}
//增加边的关系
//A-C A-B B-C B-D B-E
graph.addEdge(0,1,1);
graph.addEdge(0,2,1);
graph.addEdge(1,2,1);
graph.addEdge(1,3,1);
graph.addEdge(1,4,1);
//显示图
graph.show();
}结果：
六、图的遍历
所谓图的遍历，即是对结点(顶点)的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历
(一)、图的深度优先搜索(Depth First Search) ：
1、深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
2、我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
3、显然，深度优先搜索是一个递归的过程
深度优先遍历算法步骤
1、访问初始结点v，并标记结点v为已访问。
2、查找结点v的第一个邻接结点w。
3、若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
4、若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
5、查找结点v的w邻接结点的下一个邻接结点，转到步骤3。
拿上图解释：
1、假设从A结点开始遍历。首先将A结点设置成已访问【可以通过一个boolean数组进行判断】
//判断结点是否被访问过
boolean[] isVisited ;2、访问 A 结点第一个邻接结点 B，判断 B 没有被访问过，将 B 设置为初始结点，
3、访问与 B 的第一个邻接结点 C，判断 C 也没有被访问过，将 C 设置为初始结点， C 的邻接节点A，B 但都已经访问过了，所以回溯到 第一步，从A的下一个临接节点B开始
4、B-D是连接的，判断D没有被访问过，将D设置为初始节点，访问D的相邻节点，D没有相邻节点，继续回溯到第一步，从A的下一个临接节点B开始
5、B-E是连接的，判断E没有访问过，最后访问E
代码实现：
//得到结点v的第一个邻接结点w的下标，index结点v的下标
public int getFirstNeighbor(int index) {
for (int i = 0; i < verTexs.size(); i++) {
if (edge[index][i] > 0) {
return i;
}
}
return -1;
}
//得到结点v的下一个邻接结点
public int getNextNeighbor(int v, int w) {
for (int i = w + 1; i < verTexs.size(); i++) {
if (edge[v][i] > 0) {
return i;
}
}
return -1;
}
//深度优先遍历--只是对一个结点的遍历，index是第一个结点的下标
public void dfs(boolean[] isVisited, int index) {
//访问第一个结点，并将它设置成已访问
System.out.print(getVertex(index) + "--->");
isVisited[index] = true;
//获取第一个邻接结点 w 的下标
int w = getFirstNeighbor(index);
//判断w是否存在
while (w != -1) {
if (!isVisited[w]) {
//没有被访问过
dfs(isVisited, w);
}
//被访问过，获取下一个邻接结点
w = getNextNeighbor(index, w);
}
}
//遍历所有结点
public void dfs() {
for (int i = 0; i < verTexs.size(); i++) {
if (!isVisited[i]) {
dfs(isVisited, i);
}
}
}(二)、图的广度优先搜索(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。
拿上图解释一下遍历过程：
1、假设A为初始结点，访问并标记
2、访问A的邻接结点B，标记访问
3、访问A的邻接结点C，标记访问
4、A-D并不连接，所以找到A的下一个邻接结点B继续遍历。
5、B的邻接结点C，已经访问过，所以访问下一个邻接结点D，并标记。
6、最后访问B的邻接结点E，并标记
代码实现：
//广度优先遍历--index是初始结点v 的下标
public void bfs(boolean[] isVisited, int index) {
int u; //头结点
int w; //邻接结点
//访问初始结点并标记
System.out.println(getVertex(index) + "-->");
isVisited[index] = true;
//使用集合模拟队列：记录结点访问顺序
LinkedList queue = new LinkedList();
//将初始结点入队列
queue.addLast(index);
while (!queue.isEmpty()) {
//取出头结点
u = (Integer) queue.removeFirst();
//找出头结点的第一个邻接结点
w = getFirstNeighbor(u);
while (w != -1) {
if (!isVisited[w]) {
//w存在,并且没有被访问过。则访问w并标记
System.out.print(getVertex(w) + "-->");
isVisited[w] = true;
//将w入队列，为了能够使w结点作为初始结点继续广度优先遍历
queue.addLast(w);
}
//继续查找u的下一个邻接结点
w = getNextNeighbor(u, w);
}
}
}
//遍历所有结点
public void bfs() {
//重置isVisited数组，不然还会保留深度优先遍历时的访问策略
isVisited = new boolean[verTexs.size()];
for (int i = 0; i < verTexs.size(); i++) {
if (!isVisited[i]) {
bfs(isVisited, i);
}
}
}
扫一扫
2515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
