1、图
- 1、为什么要用图:线性表局限于一个前驱一个后继,树只能有一个前驱(父节点),这两种数据结构可表征的结构形式较为简单,无法表示多对多的关系;
- 2、什么是图:一种数据结构,其中的节点可具有零个或多个相邻元素;两个节点之间的连线称为边,节点也称顶点;
- 3、分类:
- ① 无向图(undirected graph):一个图结构中,所有的边都没有方向性;
- ② 有向图(directed graph):一个图结构中,边有方向性;
- ③ 带权图:一个图结构中,边具有权值;也称为网;
- 4、图的表示方式:
- ① 邻接表:即使用链表数组,为每个顶点保存一个链表,链表的每个节点代表一个连接到该顶点的其他顶点;
- ② 邻接矩阵:即使用二维数组表示顶点之间的相邻关系,顶点i和j之间若存在一条边,则元素(i, j)的值为1,否则为0;
- 5、图的遍历方式:
- ① 深度优先遍历DFS(Depth First Search):类似于树的前、中、后序遍历,首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点;当没有未访问过的顶点时,则回到上一个顶点,继续试探别的顶点,直至所有的顶点都被访问过。特点是“不撞南墙不回头”。
- ② 广度优先遍历BFS(Broad First Search):类似于树的层遍历,把当前顶点的所有邻接顶点访问完,再依照此逻辑访问其他顶点。
2、Java 代码 -- 图的创建,添加顶点,深度及广度优先遍历
package DataStructures.Graph;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
/**
* @author yhx
* @date 2020/10/29
*/
public class Graph {
/**
* 存储顶点集合
*/
private final ArrayList<String> vertexList;
/**
* 存储图对应的邻接矩阵
*/
private final int[][] edges;
/**
* 边的数目
*/
private int numOfEdges;
/**
* 记录某个顶点是否被访问过
*/
private boolean[] isVisited;
public static void main(String[] args) {
// 顶点个数及对应的名称
int n = 8;
String[] Vertex = {"A", "B", "C", "D", "E", "F", "G", "H"};
Graph graph = new Graph(n);
// 添加节点
for (String vertex : Vertex) {
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, 3, 1);
graph.insertEdge(1, 4, 1);
graph.insertEdge(3, 7, 1);
graph.insertEdge(4, 7, 1);
graph.insertEdge(2, 5, 1);
graph.insertEdge(2, 6, 1);
graph.insertEdge(5, 6, 1);
System.out.println("图的邻接矩阵为:");
graph.showGraph();
System.out.println();
// 深度优先遍历
System.out.println("深度优先遍历dfs:");
graph.dfs();
System.out.println();
System.out.println();
// 广度优先遍历
System.out.println("广度优先遍历bfs:");
graph.bfs();
}
/**
* 构造器
*
* @param n 顶点个数
*/
public Graph(int n) {
edges = new int[n][n];
vertexList = new ArrayList<>(n);
numOfEdges = 0;
isVisited = new boolean[n];
}
/**
* 插入节点
*
* @param vertex 节点名
*/
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
/**
* 添加边
*
* @param v1 顶点1对应的下标
* @param v2 顶点2对应的下标
* @param weight 权值,表示两个顶点互相关联
*/
public void insertEdge(int v1, int v2, int weight) {
edges[v1][v2] = weight;
edges[v2][v1] = weight;
numOfEdges++;
}
/**
* 返回顶点个数
*
* @return 顶点个数
*/
public int getNumOfVertex() {
return vertexList.size();
}
/**
* 返回边的个数
*
* @return 边的个数
*/
public int getNumOfEdges() {
return numOfEdges;
}
/**
* 返回顶点i对应的名称
*
* @param i 顶点的下标
* @return 顶点名称
*/
public String getValueByIndex(int i) {
return vertexList.get(i);
}
/**
* 返回两个顶点之间的权值
*
* @param v1 顶点1对应的下标
* @param v2 顶点2对应的下标
* @return 权值
*/
public int getWeight(int v1, int v2) {
return edges[v1][v2];
}
/**
* 显示邻接矩阵
*/
public void showGraph() {
// 逐行取出
for (int[] link : edges) {
System.out.println(Arrays.toString(link));
}
}
/**
* 得到指定顶点的第一个邻接顶点的下标w
*
* @param index 指定顶点的索引
* @return 存在即返回下标,否则返回-1
*/
public int getFirstNeighbor(int index) {
for (int j = 0; j < vertexList.size(); j++) {
if (edges[index][j] > 0) {
return j;
}
}
return -1;
}
/**
* 根据前一个邻接顶点v2的下标获取下一个邻接顶点v1的下标
*
* @param v1 下一个邻接顶点
* @param v2 前一个邻接顶点
* @return 返回下一个邻接顶点的下标,不存在返回-1
*/
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;
}
/**
* 深度优先遍历算法dfs,遍历顶点i的所有邻接顶点
*
* @param isVisited 是否被访问的状态数组
* @param i 第i个顶点
*/
private void dfs(boolean[] isVisited, int i) {
// 首先访问该顶点
System.out.print(getValueByIndex(i) + "->");
// 将顶点设置为已经访问
isVisited[i] = true;
// 查找顶点i的第一个邻接顶点w
int w = getFirstNeighbor(i);
// 如果找到第一个邻接顶点,就递归的查找邻接顶点的下一个邻接顶点
while (w != -1) {
if (!isVisited[w]) {
dfs(isVisited, w);
}
// 如果w顶点已经被访问过,就跳过w访问w的下一个顶点i
w = getNextNeighbor(i, w);
}
}
/**
* 重载dfs深度优先遍历算法,遍历所有顶点的邻接顶点
*/
public void dfs() {
// 遍历所有的节点,进行dfs[回溯]
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]) {
dfs(isVisited, i);
}
}
}
/**
* 对顶点i进行bfs广度优先遍历
*
* @param isVisited 是否被访问过
* @param i 顶点i
*/
private void bfs(boolean[] isVisited, int i) {
// 队列的头顶点对应的下标
int u;
// 邻接顶点w
int w;
// 记录顶点的访问顺序
LinkedList<Integer> queue = new LinkedList<>();
// 打印顶点信息
System.out.print(getValueByIndex(i) + "->");
// 标记为已经访问
isVisited[i] = true;
// 将顶点加入队列
queue.addLast(i);
while (!queue.isEmpty()) {
// 取出队列的头顶点的下标
u = queue.removeFirst();
// 得到第一个邻接顶点的下标w
w = getFirstNeighbor(u);
while (w != -1) {
if (!isVisited[w]) {
System.out.print(getValueByIndex(w) + "->");
// 标记已访问
isVisited[w] = true;
// 入队
queue.addLast(w);
}
// 如果w已经访问过,就以u为前驱点,找w之后的下一个邻接顶点
w = getNextNeighbor(u, w);
}
}
}
/**
* 重载bfs广度优先遍历算法,遍历所有顶点的邻接顶点
*/
public void bfs() {
isVisited = new boolean[8];
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]) {
bfs(isVisited, i);
}
}
}
}
3、运行结果
图的邻接矩阵为:
[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]
深度优先遍历dfs:
A->B->D->H->E->C->F->G->
广度优先遍历bfs:
A->B->C->D->E->F->G->H->