不要你觉得，我要我觉得，我说图它不是个东西。——明人明言。
为什么有图
用来表示多对多的关系。
线性表局限于一个直接前驱和一个直接后继的关系
树也只能有一个直接前驱也就是父节点
基本概念
边：两结点的连线
顶点（vertex）：数据元素，一个顶点可以具有零个或多个相邻元素。
路径: 比如从 D-> C 的路径有
1)D->B->C
2)D->A->B->C
分类
无向图：如上图，顶点间连线无方向。比如A-B,即可以是 A-> B 也可以 B->A .
有向图：顶点之间的连接有方向，比如A-B,
只能是 A-> B 不能是 B->A
带权图：这种边带权值的图也叫网
表示方式
或者也就存储结构
图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。
邻接矩阵
我们用两个数组来表示图：
一维数组用来存储图中顶点信息
二维数组存放存放图中边信息
求顶点vi的所有邻接点就是将矩阵中第i行元素扫描一遍，arr[i][j]为1的就是邻接点。
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是row和col表示的是1....n个点。
下面是无向图的一个例子，观察：
邻接矩阵是对称矩阵
主对角线为0，不存在顶点到自身的边；
邻接表
只关心存在的边。
因为邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失.
邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组和链表组成。
创建一个图
代码实现如下图结构
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
//说明
//(1) 1 表示能够直接连接
//(2) 0 表示不能直接连接思路分析：
需要两个数组
String类型的ArrayList用来存储顶点
二维数组来保存边信息
常用方法：
- 插入顶点
- 插入边
- 返回结点的个数
- 得到边的数目，每插入边就累加一次
- 显示图对应的矩阵
- 返回结点i(下标)对应的数据 0->"A" 1->"B" 2->"C"
- 返回v1和v2的权值，该权值存在数组里。
代码实现
import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; /** * @ClassName: Demo20_Graph * @author: benjamin * @version: 1.0 * @description: TODO * @createTime: 2019/08/26/11:20 */ public class Demo20_Graph { // 用于存储顶点的集合 private ArrayList<String> vertexList; // 存储边的信息的二维数组 private int[][] edges; // 记录边的数目 private int numOfEdges; // 定义数组boolean[]，记录某个结点是否被访问 public static void main(String[] args) { Demo20_Graph graph = new Demo20_Graph(5); // 插入顶点 String vertexs[] = {"A","B","C","D","E","F"}; for(String vertex:vertexs){ graph.insertVertex(vertex); } // 添加边 // A-B A-C B-C B-D B-E 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(); } // 构造器，初始化矩阵和顶点集合 Demo20_Graph(int n) { // 集合长度为n vertexList = new ArrayList<String>(n); // 邻接矩阵为n*n edges = new int[n][n]; numOfEdges = 0; } //常用的方法 //返回结点的个数 public int getNumOfVertex() { return vertexList.size(); } //显示图对应的矩阵 public void showGraph() { for(int[] vertex:edges){ System.out.println(Arrays.toString(vertex)); } } //得到边的数目 public int getNumOfEdges() { return numOfEdges; } //返回结点i(下标)对应的数据 0->"A" 1->"B" 2->"C" 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); } /** * 添加边 * * @param v1 表示点的下标即使第几个顶点 "A"-"B" "A"->0 "B"->1 * @param v2 第二个顶点对应的下标 * @param weight 表示权，1或者0 */ public void insertEdge(int v1, int v2, int weight) { edges[v1][v2] = weight; edges[v2][v1] = weight; numOfEdges++; } }
输出：
[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
图的遍历
即结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略:
- 深度优先遍历
- 广度优先遍历
前者选择一个领域精通后，再回来进行研究下一个领域；
后者像创业，从已知出发， 从已经知道的东西逐渐再挖掘感兴趣的部分；
深度优先遍历(DFS)
基本思想
图的深度优先搜索(Depth First Search)
从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
我们可以看到，这样的访问策略是优先往纵向挖掘深入，深度优先搜索是一个递归的过程
如何实现上图中的DFS步骤呢？
初始结点为A，从A出发，先标记A已访问，
A的第一个邻接结点为B，B存在而且未被访问，现在把B当做初始结点
从B出发，先标记B已访问，B的第一个邻接结点为C，C存在而且未被访问，现在把C当做初始结点
C 结点的下一个结点D不存在，此时回到B，B的下一个邻接结点尾E
算法步骤
- 访问初始结点v，并标记结点v为已访问。
- 查找结点v的第一个邻接结点w。
- 若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
- 若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
- 查找结点v的w邻接结点的下一个邻接结点，转到步骤3。
代码实现
/**
* 得到第一个邻接结点的下标 w
*
* @return 如果存在就返回对应的下标，否则返回-1
*/
public int getFirstNeighbor(int index) {
for (int j = 0; j < vertexList.size(); j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
/**
* @Description: 根据前一个邻接结点的下标来获取下一个邻接结点
* @Param: [v1, v2]
* @return: int
* @Author: benjamin
* @Date: 2019/8/26
*/
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;
}
//深度优先遍历算法
//i 第一次就是 0
private void dfs(boolean[] isVisited, int i) {
// 首先输出访问的结点
System.out.print(getValueByIndex(i) + "->");
// 将结点设置为已经访问
isVisited[i] = true;
// 查找结点i的第一个邻接结点w
int w = getFirstNeighbor(i);
// 只要w不为1，说明有
while (w != -1){
if(!isVisited[w]){
dfs(isVisited,w);
}
// 如果该结点已经被访问过，则访问i的下下一个邻接结点
w = getNextNeighbor(i,w);
}
}
//对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
public void dfs() {
isVisited = new boolean[vertexList.size()];
//遍历所有的结点，长度为集合的长度，进行dfs[回溯]
for(int i = 0; i < getNumOfVertex(); i++) {
if(!isVisited[i]) {
dfs(isVisited, i);
}
}
}广度优先遍历（BFS）
基本思想
图的广度优先搜索(Broad First Search) 。
类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点
算法步骤
- 访问初始结点v并标记结点v为已访问。
- 结点v入队列
- 当队列非空时，继续执行，否则算法结束。
- 出队列，取得队头结点u。
- 查找结点u的第一个邻接结点w。
- 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
- 若结点w尚未被访问，则访问结点w并标记为已访问。
- 结点w入队列
- 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。
代码实现
/**
* 得到第一个邻接结点的下标 w
*
* @return 如果存在就返回对应的下标，否则返回-1
*/
public int getFirstNeighbor(int index) {
for (int j = 0; j < vertexList.size(); j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
/**
* @Description: 根据前一个邻接结点的下标来获取下一个邻接结点
* @Param: [v1, v2]
* @return: int
* @Author: benjamin
* @Date: 2019/8/26
*/
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 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
w = getFirstNeighbor(u);
while(w != -1) {//找到
//是否访问过
if(!isVisited[w]) {
System.out.print(getValueByIndex(w) + "=>");
//标记已经访问
isVisited[w] = true;
//入队
queue.addLast(w);
}
//以u为前驱点，找w后面的下一个邻结点
w = getNextNeighbor(u, w); //体现出我们的广度优先
}
}
}
//遍历所有的结点，都进行广度优先搜索
public void bfs() {
isVisited = new boolean[vertexList.size()];// 清空标志位
for (int j = 0; j < vertexList.size(); j++) {
if (!isVisited[j]) {
bfs(isVisited, j);
}
}
}