一、为什么要有图
1)
前面学了
线性表和树
2)
线性表局限于一个直接前驱和一个直接后继的关系
3)
树也只能有一个直接前驱也就是父节点
4)
当我们需要表示多对多的关系时， 我们就用到了图
二、图的常用概念
1)
顶点
(vertex)
2)
边
(edge)
3)
路径
4) 无向图
5) 有向图
6) 带权图
三、图的存储结构
图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。
3.1 邻接矩阵
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1....n个点。
3.2 邻接表
1)
邻接矩阵需要为每个顶点都分配
n
个边的空间，其实有很多边都是不存在
,
会造成空间的一定损失
.
2) 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
四、图的创建与遍历
4.1 图的创建
我们使用邻接矩阵来表示图结构。使用集合来存储顶点，二维数组存储边的信息。
class Graph{
protected List<String> vertex;//存放顶点
protected int[][] edges;//存放边
protected boolean[] isVisited;//是否被访问
protected int numOfEdges;
public Graph(int n) {
this.vertex=new ArrayList<>(n);
this.edges=new int[n][n];
this.isVisited=new boolean[n];
}
//常用方法
// 1. 获取节点个数
protected int getNumOfVertex(){
return vertex.size();
}
// 2. 打印邻接矩阵
protected void printGraph(){
System.out.print(" ");
for (String s : vertex) System.out.print(" " + s);
System.out.println();
for(int r=0;r<vertex.size();r++){
System.out.print(vertex.get(r) + " ");
for(int c=0;c<vertex.size();c++) {
System.out.print(edges[r][c]+" ");
}
System.out.println();
}
}
// 3. 获取边的数目
protected int getNumOfEdges(){
return numOfEdges;
}
// 4. 获取某条边的权值
protected int getWeightOfEdges(int v1,int v2){
return edges[v1][v2];
}
// 5. 添加节点
protected void addVertex(String v){
vertex.add(v);
}
// 6. 添加边（双向）
protected void addEdge(int v1,int v2,int weight){
edges[v1][v2]=weight;
edges[v2][v1]=weight;
numOfEdges++;
}
// 7.获取顶点索引对应的值
protected String getValueByIndex(int i){
return vertex.get(i);
}测试：
@Test
public void testMethods(){
Graph graph=new Graph(5);
graph.addVertex("A");
graph.addVertex("B");
graph.addVertex("C");
graph.addVertex("D");
graph.addVertex("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);
System.out.println("边的数量： "+graph.getNumOfEdges());
System.out.println("顶点的数量： "+graph.getNumOfVertex());
System.out.println("邻接矩阵：");
graph.printGraph();
}
边的数量： 5
顶点的数量： 5
邻接矩阵：
A B C D E
A 0 1 1 0 0
B 1 0 1 1 1
C 1 1 0 0 0
D 0 1 0 0 0
E 0 1 0 0 0 4.2 图的深度优先搜索
深度优先搜索(Depth First Search)的思想：
1)
深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完
当前结点
后首先访问
当前结点的第一个邻接结点
。
2)
我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
显然，深度优先搜索是一个递归的过程
深度优先遍历算法步骤
1)
访问初始结点
v
，并标记结点
v
为已访问。
2)
查找结点
v
的第一个邻接结点
w
。
3)
若
w
存在，则继续执行
4
，如果
w
不存在，则回到第
1
步，将从
v
的下一个结点继续。
4)
若
w
未被访问，对
w
进行深度优先遍历递归（即把
w
当做另一个
v
，然后进行步骤
123
）。
5)
查找结点
v
的
w
邻接结点的下一个邻接结点，转到步骤
3
。
//1.深度优先DFS
protected void DFS(int index){
//标记为已访问
isVisited[index]=true;
System.out.print(vertex.get(index)+" ");
//从某点开始，找与之依次邻接的点
for(int i=0;i<vertex.size();i++) {
//如果都遍历过了就退出，防止无限循环
if (!isVisited[i]) {
//一旦找到邻接点，且其未被访问过，就对其进行深度优先搜索
if (edges[index][i] != 0 && !isVisited[i]) {
DFS(i);
}
//如果找到最后都没找到合适的邻接点，就回溯到该点前面的点再次进行深度优先搜索
if (i == vertex.size() - 1 && edges[index][i] == 0) DFS(i - 1);
}
}
}测试：
@Test
public void testDFS(){
Graph graph=new Graph(8);
graph.addVertex("1");
graph.addVertex("2");
graph.addVertex("3");
graph.addVertex("4");
graph.addVertex("5");
graph.addVertex("6");
graph.addVertex("7");
graph.addVertex("8");
graph.addEdge(0, 1, 1);
graph.addEdge(0, 2, 1);
graph.addEdge(1, 3, 1);
graph.addEdge(1, 4, 1);
graph.addEdge(3, 7, 1);
graph.addEdge(4, 7, 1);
graph.addEdge(2, 5, 1);
graph.addEdge(2, 6, 1);
graph.addEdge(5, 6, 1);
System.out.println("邻接矩阵：");
graph.printGraph();
System.out.println("深度优先搜索：");
graph.DFS(0);
}
邻接矩阵：
1 2 3 4 5 6 7 8
1 0 1 1 0 0 0 0 0
2 1 0 0 1 1 0 0 0
3 1 0 0 0 0 1 1 0
4 0 1 0 0 0 0 0 1
5 0 1 0 0 0 0 0 1
6 0 0 1 0 0 0 1 0
7 0 0 1 0 0 1 0 0
8 0 0 0 1 1 0 0 0
深度优先搜索：
1 2 4 8 5 3 6 7
4.3 图的广度优先搜索
广度优先搜索(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。
//2.广度优先BFS
protected void BFS() {
int index=0;//当前进行广度搜索的顶点索引
Queue<Integer> order = new LinkedList<>();//存储中间的遍历结果
isVisited[index] = true;//标记为已访问
order.add(index);
System.out.print(vertex.get(index) + " ");
//队列为空代表遍历完了
while (!order.isEmpty()) {
//从某点开始，找与之依次邻接的点
for (int i = 0; i < vertex.size(); i++) {
//若找到了邻接点，且其未被访问过，就标记为已访问并入队，再接着找下一个邻接点
if (edges[index][i] != 0 && !isVisited[i]) {
isVisited[i] = true;
order.add(i);
System.out.print(vertex.get(i) + " ");
}
}
//如果某点的邻接点遍历完了，就从队列中取出一个顶点继续广度搜索
index=order.poll();
}
}测试：
@Test
public void testBFS(){
Graph graph=new Graph(8);
graph.addVertex("1");
graph.addVertex("2");
graph.addVertex("3");
graph.addVertex("4");
graph.addVertex("5");
graph.addVertex("6");
graph.addVertex("7");
graph.addVertex("8");
graph.addEdge(0, 1, 1);
graph.addEdge(0, 2, 1);
graph.addEdge(1, 3, 1);
graph.addEdge(1, 4, 1);
graph.addEdge(3, 7, 1);
graph.addEdge(4, 7, 1);
graph.addEdge(2, 5, 1);
graph.addEdge(2, 6, 1);
graph.addEdge(5, 6, 1);
System.out.println("邻接矩阵：");
graph.printGraph();
System.out.println("广度优先搜索：");
graph.BFS();
}
邻接矩阵：
1 2 3 4 5 6 7 8
1 0 1 1 0 0 0 0 0
2 1 0 0 1 1 0 0 0
3 1 0 0 0 0 1 1 0
4 0 1 0 0 0 0 0 1
5 0 1 0 0 0 0 0 1
6 0 0 1 0 0 0 1 0
7 0 0 1 0 0 1 0 0
8 0 0 0 1 1 0 0 0
广度优先搜索：
1 2 3 4 5 6 7 8 五、总结
DFS可使用递归结构来完成，BFS则使用迭代结构就可完成。BFS还需要使用队列来保存中间遍历结果。
1037
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
