图
1. 图的基本介绍
1.1 为什么要有图？
- 前面我们学了线性表和树
- 线性表局限于一个直接前驱和一个直接后继的关系
- 树也只能有一个直接前驱也就是父节点
- 当我们需要表示多对多的关系是，就需要用到图
1.2 图的基本概念
- 顶点(Vertex)： 节点
- 边(edge)
- 路径：
例如D -> C 的路径有- D -> B -> C
- D -> A -> B -> C
- 无向图: 顶点之间的链接没有方向
- 有向图: 顶点之间的链接有方向，只能按照规定方向走
- 带权图：边带有权重，这种带权的图也称作网
1.3 图的表示方法
图的表示方式有两种：
- 二维数组表示（邻接矩阵）
- 链表表示（邻接表）
1.3.1 邻接矩阵
邻接矩阵是表示图中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是n行n列的
用0或1表示是否直接链接。
1.3.2 邻接表
- 邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边是不存在的，造成内存空间浪费
- 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表
邻接表.png
| 0 | 1 -> | 2 -> | 3 -> | 4 -> | |
|---|---|---|---|---|---|
| 1 | 0 -> | 4 -> | |||
| 2 | 0 -> | 4 -> | 5 -> | ||
| 3 | 0 -> | 5 -> | |||
| 4 | 0 -> | 1 -> | 2 -> | 5 -> | |
| 5 | 2 -> | 3 -> | 4 -> |
1.4 图的深度优先遍历
1.4.1 图遍历介绍
所谓图的遍历，即是对节点的访问。一个图有那么多个节点，如何遍历这些节点，需要特定的策略，一般有两种策略：
- 深度优先遍历
- 广度优先遍历
基础代码：
/***
* 邻接矩阵
* 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.存储顶点 String 使用ArrayList
* 2. 保存图的邻接矩阵： 二维数组 int[][] edges
*
* * 要实现的方法：
* * 1.插入顶点
* * 2.添加边
*
* 图中常用方法：
* 1. 返回节点的个数
* 2.返回边的数目
* 3.返回节点i(下标)对应的数据
* 4.返回vertex1与vertex2之间边的权值
* 5.显示图（显示矩阵）
*
*
*/
public class MyGraph {
private ArrayList<String> vertexList; //存储顶点的集合,链表
private int[][] edges; //存储图的边，邻接矩阵
private int numOfEdges; //表示边的数目
//定义一个数组 boolean[],记录某个节点是否被访问过
private boolean[] isVisited;
//构造方法,传入顶点数目
public MyGraph(int n) {
//初始化矩阵和ArrayList
edges = new int[n][n];
vertexList = new ArrayList<String>(n);
isVisited = new boolean[n];
numOfEdges = 0;
}
//1.插入顶点 传入字符串
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
//2.添加边，通过邻接矩阵中的值是0还是1来决定
/***
*
* @param vertex1 第一个顶点下标，第几个顶点
* @param vertex2 第二个顶点下标
* @param weight 边权重
*/
public void insertEdge(int vertex1, int vertex2, int weight) {
edges[vertex1][vertex2] = weight;
//因为是无向图，所以反着写一次
edges[vertex2][vertex1] = weight;
numOfEdges++;
}
//常用方法1. 返回节点数目
public int getNumOfVertex() {
return vertexList.size();
}
//常用方法2.得到边的数目
public int getNumOfEdges() {
return numOfEdges;
}
//常用方法3.返回节点i(下标)对应的数据 0 -> "A" ; 1 -> "B" ...
public String getValueByIndex(int index) {
return vertexList.get(index);
}
//常用方法4.返回vertex1与vertex2之间边的权值
public int getWeight(int vertex1, int vertex2) {
return edges[vertex1][vertex2];
}
//常用方法5.显示图（显示矩阵）
public void showGraph() {
for (int[] link : edges) {
System.out.println(Arrays.toString(link));
}
}
}
1.4.2 图的深度优先搜索(Depth First Search)
- 深度优先遍历，从初始访问节点出发，初始访问节点可能有多个邻接点，深度优先遍历的策略是首先访问第一个邻接节点，然后再以这个被访问的邻接节点为初始节点，访问它的第一个邻接节点，可以这样理解：每次都在访问完当前节点后首先访问当前节点的第一个邻接节点。
- 我们可以看到，这样的访问策略是有限往纵深挖掘深入，而不是对一个节点的所有邻接节点进行横向访问
- 显然深度优先搜索是一个递归过程
步骤：
- 访问初始节点v,并标记节点v为已访问
- 查找节点v的第一个邻接节点w.
- 若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个节点继续
- 若w未被访问，则对w进行深度优先遍历递归（即把w当作另一个v，进行123步）
- 查找节点v的邻接节点w的下一个邻接节点，转到步骤3
/***
*
* @param index
* @return 如果存在返回对应下标，否则返回-1
*/
// 遍历方法1 得到第一个邻接节点的下标w
public int getFirstNeighbor(int index) {
for (int j = 0; j < vertexList.size(); j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
//遍历方法2，根据前一个邻接节点的下标，获取下一个邻接节点
public int getNextNeighbor(int vertex1, int vertex2) {
for (int j = vertex2 + 1; j < vertexList.size(); j++) {
if (edges[vertex1][j] > 0) {
return j;
}
}
return -1;
}
//遍历方法3：正式的——深度优先遍历
// index第一次就是0
private void depthFirstSearch(boolean[] isVisited, int index) {
//访问该节点
System.out.print(getValueByIndex(index) + "->");
//把访问的节点设置为已访问
isVisited[index] = true;
//查找该节点的第一个邻接节点
int w = getFirstNeighbor(index);
while (w != -1) { //说明有，判断是否被访问过
if (!isVisited[w]) {
depthFirstSearch(isVisited, w);
}
//w存在，但已经被访问过，则查找w的下一个邻接节点
w = getNextNeighbor(index, w);
}
}
//对depthFirstSearch进行重载 ，解决从0出发找不到邻接节点的状况
//考虑从其他节点出发， 遍历所有节点，并进行depthFirstSearch
public void depthFirstSearch() {
//遍历所有的节点，进行depthFirstSearch
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]) {
depthFirstSearch(isVisited, i);
}
}
}
1.4.3 图的广度优先遍历(Broad First Search)
- 基本思想
图的广度优先搜索，类似一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的节点的顺序，以便按这个顺序来访问这些节点的邻接节点
- 步骤：
- 访问初始节点v并标记节点v已访问
- 节点v入队列
- 当队列非空时，继续执行，否则算法结束
- 出队列，取得队头节点u
- 查找节点u的第一个邻接节点w
- 若节点u的邻接节点w不存在，则转到步骤3；否则循环执行以下三个步骤：
- 若节点w尚未被访问，则访问w并标记为已访问
- 节点w入队列
- 查找节点u的继w邻接节点后的下一个邻接节点w，转到步骤6
//广度优先1. 对一个节点进行广度优先遍历的方法
private void broadFirstSearch(boolean[] isVisited, int index) {
int u; ///定义队列头节点对应下标u
int w; //u的邻接节点下标w
//需要一个队列，记录节点访问顺序
LinkedList queue = new LinkedList();
//访问节点，输出节点信息
System.out.print(getValueByIndex(index) + "->");
//标记为已访问
isVisited[index] = true;
//将节点加入队列
queue.addLast(index);
//只要队列非空就继续执行，否则算法结束
while (!queue.isEmpty()) {
//取出队列的头节点索引u
u = (Integer) queue.removeFirst();
//查找节点u的第一个邻接节点w
w = getFirstNeighbor(u);
while (w != -1) {
//1.若结点w尚未被访问，则访问w并标记已访问
if (!isVisited[w]) {
System.out.println(getValueByIndex(w) + "->");
isVisited[w] = true;
//2.节点w入队列
queue.addLast(w);
}
//3.查找节点u的继w邻接节点后的下一刻邻接节点w
//如果w存在但已经访问过，则以u为前驱，找w后面的第一个邻接节点
w = getNextNeighbor(u, w); //体现广度优先
}
}
}
//广度优先遍历2.遍历所有节点进行广度优先遍历
public void broadFirstSearch() {
for (int i = 0; i < getNumOfVertex(); i++) {
broadFirstSearch(isVisited, i);
}
}
1.4.4 两种图遍历方法的完整代码
package Graph;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
/***
* 邻接矩阵
* 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.存储顶点 String 使用ArrayList
* 2. 保存图的邻接矩阵： 二维数组 int[][] edges
*
* * 要实现的方法：
* * 1.插入顶点
* * 2.添加边
*
* 图中常用方法：
* 1. 返回节点的个数
* 2.返回边的数目
* 3.返回节点i(下标)对应的数据
* 4.返回vertex1与vertex2之间边的权值
* 5.显示图（显示矩阵）
*
*
*/
public class MyGraph {
private ArrayList<String> vertexList; //存储顶点的集合,链表
private int[][] edges; //存储图的边，邻接矩阵
private int numOfEdges; //表示边的数目
//定义一个数组 boolean[],记录某个节点是否被访问过
private boolean[] isVisited;
//构造方法,传入顶点数目
public MyGraph(int n) {
//初始化矩阵和ArrayList
edges = new int[n][n];
vertexList = new ArrayList<String>(n);
isVisited = new boolean[n];
numOfEdges = 0;
}
//1.插入顶点 传入字符串
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
//2.添加边，通过邻接矩阵中的值是0还是1来决定
/***
*
* @param vertex1 第一个顶点下标，第几个顶点
* @param vertex2 第二个顶点下标
* @param weight 边权重
*/
public void insertEdge(int vertex1, int vertex2, int weight) {
edges[vertex1][vertex2] = weight;
//因为是无向图，所以反着写一次
edges[vertex2][vertex1] = weight;
numOfEdges++;
}
//常用方法1. 返回节点数目
public int getNumOfVertex() {
return vertexList.size();
}
//常用方法2.得到边的数目
public int getNumOfEdges() {
return numOfEdges;
}
//常用方法3.返回节点i(下标)对应的数据 0 -> "A" ; 1 -> "B" ...
public String getValueByIndex(int index) {
return vertexList.get(index);
}
//常用方法4.返回vertex1与vertex2之间边的权值
public int getWeight(int vertex1, int vertex2) {
return edges[vertex1][vertex2];
}
//常用方法5.显示图（显示矩阵）
public void showGraph() {
for (int[] link : edges) {
System.out.println(Arrays.toString(link));
}
}
/***
*
* @param index
* @return 如果存在返回对应下标，否则返回-1
*/
// 遍历方法1 得到第一个邻接节点的下标w
public int getFirstNeighbor(int index) {
for (int j = 0; j < vertexList.size(); j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
//遍历方法2，根据前一个邻接节点的下标，获取下一个邻接节点
public int getNextNeighbor(int vertex1, int vertex2) {
for (int j = vertex2 + 1; j < vertexList.size(); j++) {
if (edges[vertex1][j] > 0) {
return j;
}
}
return -1;
}
//遍历方法3：正式的——深度优先遍历
// index第一次就是0
private void depthFirstSearch(boolean[] isVisited, int index) {
//访问该节点
System.out.print(getValueByIndex(index) + "->");
//把访问的节点设置为已访问
isVisited[index] = true;
//查找该节点的第一个邻接节点
int w = getFirstNeighbor(index);
while (w != -1) { //说明有，判断是否被访问过
if (!isVisited[w]) {
depthFirstSearch(isVisited, w);
}
//w存在，但已经被访问过，则查找w的下一个邻接节点
w = getNextNeighbor(index, w);
}
}
//对depthFirstSearch进行重载 ，解决从0出发找不到邻接节点的状况
//考虑从其他节点出发， 遍历所有节点，并进行depthFirstSearch
public void depthFirstSearch() {
//遍历所有的节点，进行depthFirstSearch
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]) {
depthFirstSearch(isVisited, i);
}
}
}
//广度优先1. 对一个节点进行广度优先遍历的方法
private void broadFirstSearch(boolean[] isVisited, int index) {
int u; ///定义队列头节点对应下标u
int w; //u的邻接节点下标w
//需要一个队列，记录节点访问顺序
LinkedList queue = new LinkedList();
//访问节点，输出节点信息
System.out.print(getValueByIndex(index) + "->");
//标记为已访问
isVisited[index] = true;
//将节点加入队列
queue.addLast(index);
//只要队列非空就继续执行，否则算法结束
while (!queue.isEmpty()) {
//取出队列的头节点索引u
u = (Integer) queue.removeFirst();
//查找节点u的第一个邻接节点w
w = getFirstNeighbor(u);
while (w != -1) {
//1.若结点w尚未被访问，则访问w并标记已访问
if (!isVisited[w]) {
System.out.println(getValueByIndex(w) + "->");
isVisited[w] = true;
//2.节点w入队列
queue.addLast(w);
}
//3.查找节点u的继w邻接节点后的下一刻邻接节点w
//如果w存在但已经访问过，则以u为前驱，找w后面的第一个邻接节点
w = getNextNeighbor(u, w); //体现广度优先
}
}
}
//广度优先遍历2.遍历所有节点进行广度优先遍历
public void broadFirstSearch() {
for (int i = 0; i < getNumOfVertex(); i++) {
broadFirstSearch(isVisited, i);
}
}
public static void main(String[] args) {
int n = 5; //节点的个数
String vertexValue[] = {"A", "B", "C", "D", "E"};
//创建图对象
MyGraph graph = new MyGraph(n);
//循环添加顶点
for (String vertex : vertexValue) {
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();
//测试深度优先遍历
System.out.println("深度优先遍历");
graph.depthFirstSearch();
System.out.println();
System.out.println("广度优先遍历");
graph.broadFirstSearch();
}
}
