简介
在现实生活中，有许多应用场景会包含很多点以及点点之间的连接，而这些应用场景我们都可以用即将要学习的图这种数据结构去解决。
地图：
我们生活中经常使用的地图，基本上是由城市以及连接城市的道路组成，如果我们把城市看做是一个一个的点，把道路看做是一条一条的连接，那么地图就是我们将要学习的图这种数据结构。
电路图：
下面是一个我们生活中经常见到的集成电路板，它其实就是由一个一个触点组成，并把触点与触点之间通过线进行连接，这也是我们即将要学习的图这种数据结构的应用场景
图的定义及分类：
定义：图是由一组顶点和一组能够将两个顶点相连的边组成的
特殊的图：
- 自环：即一条连接一个顶点和其自身的边；
- 平行边：连接同一对顶点的两条边；
图的分类：
按照连接两个顶点的边的不同，可以把图分为以下两种：
无向图：边仅仅连接两个顶点，没有其他含义；
有向图：边不仅连接两个顶点，并且具有方向；
无向图
图的相关术语
相邻顶点：当两个顶点通过一条边相连时，我们称这两个顶点是相邻的，并且称这条边依附于这两个顶点。
度：某个顶点的度就是依附于该顶点的边的个数
子图：是一幅图的所有边的子集(包含这些边依附的顶点)组成的图；
路径：是由边顺序连接的一系列的顶点组成
环：是一条至少含有一条边且终点和起点相同的路径
连通图：如果图中任意一个顶点都存在一条路径到达另外一个顶点，那么这幅图就称之为连通图
连通子图：一个非连通图由若干连通的部分组成，每一个连通的部分都可以称为该图的连通子图
图的存储结构
要表示一幅图，只需要表示清楚以下两部分内容即可：
- 图中所有的顶点；
- 所有连接顶点的边；
常见的图的存储结构有两种：邻接矩阵和邻接表
邻接矩阵
- 使用一个V*V的二维数组int[V][V] adj,把索引的值看做是顶点；
- 如果顶点v和顶点w相连，我们只需要将adj[v][w]和adj[w][v]的值设置为1,否则设置为0即可。
很明显，邻接矩阵这种存储方式的空间复杂度是V^2的，如果我们处理的问题规模比较大的话，内存空间极有可能不够用。
邻接表
1.使用一个大小为V的数组 Queue[V] adj，把索引看做是顶点；
2.每个索引处adj[v]存储了一个队列，该队列中存储的是所有与该顶点相邻的其他顶点
很明显，邻接表的空间并不是是线性级别的，所以后面我们一直采用邻接表这种存储形式来表示图。
代码实现
图API设计：
| 类名 | Graph |
|---|---|
| 构造方法 | Graph(int V)：创建一个包含V个顶点但不包含边的图 |
| 成员方法 | 1.public int V():获取图中顶点的数量 2.public int E():获取图中边的数量 3.public void addEdge(int v,int w):向图中添加一条边 v-w 4.public Queue adj(int v)：获取和顶点v相邻的所有顶点 |
| 成员变量 | 1.private final int V: 记录顶点数量 2.private int E: 记录边数量 3.private Queue[] adj: 邻接表 |
/**
* @author wen.jie
* @date 2021/8/27 10:43
* 无向图
*/
public class Graph {
//顶点数目
final int V;
//边的数目
int E;
//邻接表
Queue<Integer>[] adj;
//初始化
public Graph(int v) {
this.V = v;
this.E = 0;
this.adj = new Queue[v];
for (int i = 0; i < adj.length; i++) {
adj[i] = new Queue<>();
}
}
public int V(){
return V;
}
public int E(){
return E;
}
//向图中添加一条边 v-w
public void addEdge(int v, int w) {
adj[v].enqueue(w);
adj[w].enqueue(v);
E++;
}
//获取和顶点v相邻的所有顶点
public Queue<Integer> adj(int v) {
return adj[v];
}
}
图的搜索
在很多情况下，我们需要遍历图，得到图的一些性质，例如，找出图中与指定的顶点相连的所有顶点，或者判定某个顶点与指定顶点是否相通，是非常常见的需求。
有关图的搜索，最经典的算法有深度优先搜索和广度优先搜索，接下来我们分别讲解这两种搜索算法。
深度优先搜索
所谓的深度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找子结点，然后找 兄弟结点。
很明显，在由于边是没有方向的，所以，如果4和5顶点相连，那么4会出现在5的相邻链表中，5也会出现在4的相邻链表中，那么为了不对顶点进行重复搜索，应该要有相应的标记来表示当前顶点有没有搜索过，可以使用一个布尔类型的数组 boolean[V] marked,索引代表顶点，值代表当前顶点是否已经搜索，如果已经搜索，标记为true， 如果没有搜索，标记为false；
api设计：
| 类名 | DepthFirstSearch |
|---|---|
| 构造方法 | DepthFirstSearch(Graph G,int s)：构造深度优先搜索对象，使用深度优先搜索找出G图中s顶点 的所有相通顶点 |
| 成员方法 | 1.private void dfs(Graph G, int v)：使用深度优先搜索找出G图中v顶点的所有相通顶点 2.public boolean marked(int w):判断w顶点与s顶点是否相通 3.public int count():获取与顶点s相通的所有顶点的总数 |
| 成员变量 | 1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int count：记录有多少个顶点与s顶点相通 |
代码实现：
/**
* dfs:深度优先搜索
* @author wen.jie
* @date 2021/8/27 11:08
*/
public class DepthFirstSearch {
//索引代表顶点，值代表当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少顶点与s顶点相通
private int count;
public DepthFirstSearch(Graph G, int s) {
this.marked = new boolean[G.V()];
dfs(G, s);
}
//深度优先搜索找出G图中v顶点的所有相通顶点
private void dfs(Graph G, int v) {
//标为已搜索
marked[v] = true;
for (int w : G.adj(v)) {
if (!marked(w))
dfs(G, w);
}
count++;
}
//判断w顶点与s顶点是否相通
public boolean marked(int w){
return marked[w];
}
//获取与顶点s相通的所有顶点的总数
public int count() {
return this.count;
}
}
构造如下的图，并测试：
private Graph graph = new Graph(13);
{
graph.addEdge(0, 5);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(0, 6);
graph.addEdge(6, 4);
graph.addEdge(4, 3);
graph.addEdge(4, 5);
graph.addEdge(5, 3);
graph.addEdge(7, 8);
graph.addEdge(9, 10);
graph.addEdge(9, 11);
graph.addEdge(9, 12);
graph.addEdge(11, 12);
}
@Test
public void test1() {
DepthFirstSearch dfs = new DepthFirstSearch(graph, 0);
int count = dfs.count();
System.out.println("与起点0相通的顶点数量为："+ count);
System.out.println(dfs.marked(5));
System.out.println(dfs.marked(7));
}
广度优先搜索
所谓的广度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找兄弟结点，然后找子结点。
api设计：
| 类名 | BreadthFirstSearch |
|---|---|
| 构造方法 | BreadthFirstSearch(Graph G,int s)：构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点 |
| 构造方法 | 1.private void bfs(Graph G, int v)：使用广度优先搜索找出G图中v顶点的所有相邻顶点 2.public boolean marked(int w):判断w顶点与s顶点是否相通 3.public int count():获取与顶点s相通的所有顶点的总数 |
| 成员变量 | 1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int count：记录有多少个顶点与s顶点相通 3.private Queue waitSearch: 用来存储待搜索邻接表的点 |
代码实现：
/**
* @author wen.jie
* @date 2021/8/27 13:43
* bfs:广度优先遍历
*/
public class BreadthFirstSearch {
//索引代表顶点，值代表当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少顶点与s顶点相通
private int count;
//用来存储待搜索邻接表的点
private Queue<Integer> waitSearch;
public BreadthFirstSearch(Graph G, int s) {
this.marked = new boolean[G.V()];
this.waitSearch = new Queue<>();
bfs(G, s);
}
//广度优先搜索找出G图中v顶点的所有相通顶点
private void bfs(Graph G, int v) {
count++;
marked[v] = true;
//入队列,待搜索
waitSearch.enqueue(v);
while (!waitSearch.isEmpty()) {
//出队列
Integer wait = waitSearch.dequeue();
for (Integer w : G.adj(wait)) {
if (!marked[w]) {
waitSearch.enqueue(w);
marked[w] = true;
count++;
}
}
}
}
//判断w顶点与s顶点是否相通
public boolean marked(int w){
return marked[w];
}
//获取与顶点s相通的所有顶点的总数
public int count() {
return this.count;
}
}
测试：
@Test
public void test2() {
BreadthFirstSearch bfs = new BreadthFirstSearch(graph, 0);
int count = bfs.count();
System.out.println("与起点0相通的顶点数量为："+ count);
System.out.println(bfs.marked(5));
System.out.println(bfs.marked(7));
}
路径查找
在实际生活中，地图是我们经常使用的一种工具，通常我们会用它进行导航，输入一个出发城市，输入一个目的地城市，就可以把路线规划好，而在规划好的这个路线上，会路过很多中间的城市。这类问题翻译成专业问题就是： 从s顶点到v顶点是否存在一条路径？如果存在，请找出这条路径。
例如在上图上查找顶点0到顶点4的路径用红色标识出来,那么我们可以把该路径表示为 0-2-3-4。
深度优先遍历查找路径
| 类名 | DepthFirstPaths |
|---|---|
| 构造方法 | DepthFirstPaths(Graph G,int s)：构造深度优先搜索对象，使用深度优先搜索找出G图中起点为 s的所有路径 |
| 构造方法 | 1.private void dfs(Graph G, int v)：使用深度优先搜索找出G图中v顶点的所有相邻顶点 2.public boolean hasPathTo(int v):判断v顶点与s顶点是否存在路径 3.public Stack pathTo(int v):找出从起点s到顶点v的路径(就是该路径经过的顶点) |
| 成员变量 | 1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int s:起点 3.private int[] edgeTo:索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点 |
思路：
我们实现路径查找，最基本的操作还是得遍历并搜索图，所以，我们的实现暂且基于深度优先搜索来完成。其搜索的过程是比较简单的。我们添加了edgeTo[]整型数组，这个整型数组会记录从每个顶点回到起点s的路径。 如果我们把顶点设定为0，那么它的搜索可以表示为下图：
代码实现如下：
public class DepthFirstPaths {
// 索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//起点
private int s;
//索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点
private Integer[] edgeTo;
public DepthFirstPaths(Graph G,int s){
this.marked = new boolean[G.V()];
this.s = s;
this.edgeTo = new Integer[G.V()];
dfs(G, s);
}
private void dfs(Graph G, int v){
marked[v] = true;
for (Integer w : G.adj(v)) {
if(!marked[w]) {
//到达顶点w的路径上的最后一个顶点是v
edgeTo[w] = v;
dfs(G, w);
}
}
}
//判断v顶点与s顶点是否存在路径
public boolean hasPathTo(int v){
return marked[v];
}
//找出从起点s到顶点v的路径(就是该路径经过的顶点)
public Stack<Integer> pathTo(int v){
if (!hasPathTo(v))
return null;
Stack<Integer> path = new Stack<>();
path.push(v);
while (edgeTo[v] != null) {
int p = edgeTo[v];
path.push(p);
v = p;
}
return path;
}
}
测试：
private Graph graph = new Graph(6);
{
graph.addEdge(0,2);
graph.addEdge(2,1);
graph.addEdge(2,3);
graph.addEdge(0,1);
graph.addEdge(0,5);
graph.addEdge(3,5);
graph.addEdge(3,4);
graph.addEdge(2,4);
}
@Test
public void test() {
DepthFirstPaths paths = new DepthFirstPaths(graph, 0);
Stack<Integer> path = paths.pathTo(4);
for (Integer integer : path) {
System.out.println(integer);
}
}
广度优先遍历查找路径
深度优先搜索得到的路径不仅取决于图的结构，还取决于图的表示和递归调用的性质。
对于找出最短路径的那条，我们可以使用广度优先遍历（BFS）。
结合上面的深度优先遍历查找路径和前面广度优先搜索代码，不难得出广度优先遍历查找路径的代码：
/**
* @author wen.jie
* @date 2021/8/27 14:52
*/
public class BreadthFirstPaths {
//索引代表顶点，值代表当前顶点是否已经被搜索
private boolean[] marked;
//用来存储待搜索邻接表的点
private Queue<Integer> waitSearch;
//索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点
private Integer[] edgeTo;
public BreadthFirstPaths(Graph G, int s) {
this.marked = new boolean[G.V()];
this.waitSearch = new Queue<>();
this.edgeTo = new Integer[G.V()];
bfs(G, s);
}
//深度优先搜索找出G图中v顶点的所有相通顶点
private void bfs(Graph G, int v) {
//标记起点
marked[v] = true;
//入队列,待搜索
waitSearch.enqueue(v);
while (!waitSearch.isEmpty()) {
//出队列
Integer wait = waitSearch.dequeue();
for (Integer w : G.adj(wait)) {
if (!marked[w]) { //对于每个未被标记的相邻顶点
edgeTo[w] = wait; //保存最短路径的最后一条边
marked[w] = true; //标记，因为最短路径已知
waitSearch.enqueue(w); //入队列
}
}
}
}
//判断w顶点与s顶点是否相通
public boolean hasPathTo(int w){
return marked[w];
}
//找出从起点s到顶点v的路径(就是该路径经过的顶点)
public Stack<Integer> pathTo(int v){
if (!hasPathTo(v))
return null;
Stack<Integer> path = new Stack<>();
path.push(v);
while (edgeTo[v] != null) {
int p = edgeTo[v];
path.push(p);
v = p;
}
return path;
}
}
测试：
BreadthFirstPaths paths = new BreadthFirstPaths(graph, 1);
Stack<Integer> path = paths.pathTo(3);
for (Integer integer : path) {
System.out.println(integer);
}
下面是广度优先遍历的处理样图：
命题：对于从s可达的任意顶点v，广度优先搜索都能找到一条从s到v的最短路径（没有其他从s到v的路径所含的边比这条路径更少）
证明：由归纳易得队列总是包含零个或多个到起点的距离为k的顶点，之后是零个或多个到起点的举例为k+1的顶点，其中k为整数，起始值为0。这意味着顶点是按照它们和s的距离的顺序加入队列或者离开队列的。从顶点v加入队列到它离开队列之前，不可能找出到v的更短的路径，而在v离开队列之后发现的所有能够到达v的路径不可能短于v在树中的路径长度。
本篇所有代码均已上传至：https://gitee.com/wj204811/algorithm