图的创建
- 介绍
- 为什么要有图？
- 举例
- 图的常用概念
- 无向图
- 有向图
- 带权图
- 图的表示方式
- 邻接矩阵
- 邻接表
- 图的入门案例
- 代码实现
- 结果
- 图的遍历
- 深度优先遍历（Depth First Search）
- 具体步骤
- 实现思路
- 代码实现
- 结果
- 广度优先遍历（Broad First Search）
- 具体步骤
- 实现思路
- 代码实现
- 结果
- 完整代码
介绍
为什么要有图？
前面我们学了线性表和树，它们都有一些局限性，线性表局限于一个直接前驱和一个直接后继的关系，树也只能有一个直接前驱也就是父节点，当我们需要表示多对多的关系时， 这里我们就要用到图。
举例
图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。如图(地铁线路图也可以看作是图)：
图的常用概念
无向图
顶点之间的连接没有方向，比如A和B之间,既可以是 A-> B，也可以B->A 。
- 顶点(vertex)
- 边(edge)
- 路径：比如从 D -> C 的路径有两条：
① D->B->C
② D->A->B->C
有向图
顶点之间的连接有方向，比如A和B之间，只能是 A-> B，不能B->A。
带权图
边带权值的图叫做带权图，也叫网。
图的表示方式
邻接矩阵
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵的row和col表示的是1…n个节点。其中邻接矩阵中的1表示两点之间连通，反之0表示两点之间不连通。可以通过二维数组来实现邻接矩阵。
邻接表
邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在，这就会造成空间的一定损失。而邻接表只关心存在的边，因此没有空间浪费。邻接表由数组+链表组成，如下图：
其中，标号为0的结点的相关联的结点为1、2、3、4；标号为1的结点的相关联结点为0、4；标号为2的结点相关联的结点为0、4、5；依此类推。
图的入门案例
使用邻接矩阵来表示如下的图结构：
思路：
使用String类型的ArrayList来存放顶点的集合，使用int类型的二维数组来存放图对应的邻接矩阵。
代码实现
package graph;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
public class Graph {
private ArrayList<String> vertexList; // 存储顶点集合
private int[][] edges; // 存储图对应的邻接矩阵
private int numOfEdges;
public static void main(String[] args) {
int n = 5;
String VertexValue[] = {"A","B","C","D","E"};
Graph graph = new Graph(5);
// 循环添加节点
for (String s :
VertexValue) {
graph.insertVertex(s);
}
// 添加边： A-B A-C B-C B-D B-E
// 1表示两个结点连通
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();
}
// 构造器：初始化邻接矩阵和vertexList
public Graph(int n){
edges = new int[n][n];
vertexList = new ArrayList<>(n);
numOfEdges = 0;
}
// 插入节点
public void insertVertex(String vertex){
vertexList.add(vertex);
}
// 返回图中节点的个数
public int getNumOfVertex(){
return vertexList.size();
}
// 返回边的数量
public int getNumOfEdges(){
return numOfEdges;
}
// 返回对应下标的结点的数据
public String getValueByIndex(int i){
return vertexList.get(i);
}
// 返回两个结点的权值
public int getWeight(int v1, int v2){
return edges[v1][v2];
}
// 显示对应的矩阵
public void showGraph(){
int i = 0;
Iterator<String> iterator = vertexList.iterator();
// 装饰一下
System.out.print(" ");
while (iterator.hasNext()){
System.out.print(iterator.next() + " ");
}
System.out.println();
for (int[] link: edges){
System.out.println(vertexList.get(i) + Arrays.toString(link));
i++;
}
}
/**
* @params
* @param v1 表示第一个顶点的下标
* @param v2 表示第二个顶点的下标
* @param weight 自定义如何表示连通性
* @return void
*/
public void insertedge(int v1, int v2, int weight){
// 无向图
edges[v1][v2] = weight;
edges[v2][v1] = weight;
// 边的数目加1
numOfEdges++;
}
}结果
图的遍历
所谓图的遍历，即是逐个对结点的访问。那么一个图有这么多结点，如何遍历这些结点？这就需要有特定策略，一般有两种访问策略: 深度优先遍历和广度优先遍历。
深度优先遍历（Depth First Search）
深度优先遍历是一个递归的过程。从初始访问结点出发会有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点。
可以这样理解：每次都在访问完当前结点后，优先访问当前结点的第一个邻接结点。这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
具体步骤
实现思路
- 访问初始节点v(刚开始的v是初始结点，后面一直在换)，并标记结点v已被访问。
- 查找结点v的第一个邻接结点w。
- 若w存在，则继续执行步骤4，如果w不存在，则回到步骤1，将从v的下一个结点继续。
- 若w未被访问，则对w进行深度优先遍历递归(即把w当做另一个v，然后进行步骤123)。
- 若w已被访问，查找结点v的w邻接结点的下一个邻接结点，转到步骤3。
代码实现
先写一个方法实现：得到第一个邻接结点的下标w
// 得到第一个邻接结点的下标w，没有找到返回-1
public int getFirstNeighbor(int index){
for (int i = 0; i <vertexList.size(); i++) {
// 如果找到
if (edges[index][i] > 0){
// 如果存在则返回下标
return i;
}
}
// 否则返回-1
return -1;
}写一个方法实现：根据前一个邻居结点的下标，来获取下一个邻接结点
// 根据前一个邻居结点的下标，来获取下一个邻接结点
public int getNextNeighbor(int v1, int v2){
for (int i = v2 + 1; i < vertexList.size(); i++) {
if (edges[v1][i] > 0){
return i;
}
}
return -1;
}深度优先遍历方法：
// 深度优先遍历方法
public void dfs(boolean[] isVisited, int i){
// 首先访问该结点
System.out.print(getValueByIndex(i) + "->");
// 将该结点设置为已经访问
isVisited[i] = true;
// 查找该节点的第一个邻接结点
int w = getFirstNeighbor(i);
while (w != -1){ // 说明找到了邻接结点
// 如果该结点没有被访问过
if (!isVisited[w]){
// 递归
dfs(isVisited, w);
}
// 如果该结点被访问过
// 形参中：i是当前的结点，w是当前结点的下一个邻接结点
w = getNextNeighbor(i, w);
}
}再对深度优先遍历方法进行重载，遍历所有结点进行dfs操作
// 对dfs进行重载 遍历所有结点进行dfs
public void dfs(){
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]){
dfs(isVisited, i);
}
}
}结果
广度优先遍历（Broad First Search）
具体步骤
实现思路
- 访问初始结点v并标记结点v为已访问。
- 结点v入队列。
- 当队列非空时，继续执行，否则算法结束。
- 出队列，取得队头结点u。
- 查找结点u的第一个邻接结点w。
- 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
①：若结点w尚未被访问，则访问结点w并标记为已访问。
②：结点w入队列
③：查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。
代码实现
深度优先遍历方法：
// 深度优先遍历方法
// 对一个结点进行广度优先遍历方法
public void bfs(boolean[] isVisited, int i){
int u; // 表示队列的头结点的下标
int w; // 表示邻接结点
// 模拟队列，记录结点访问顺序
LinkedList queue = new LinkedList();
// 访问结点，输出结点信息
System.out.print(getValueByIndex(i) + "->");
// 标将结点已经访问
isVisited[i] = true;
// 将结点加入队列
// 注意：从队列尾加入
queue.addLast(i);
while (!queue.isEmpty()){
// 注意：从队列头取出
u = (Integer) queue.removeFirst();
// 取邻接结点
w = getFirstNeighbor(u);
while (w != -1){ // 找到
// 判断是否访问过
if (!isVisited[w]){
// 取出
System.out.println(getValueByIndex(w) + "->");
// 标将结点已经访问
isVisited[w] = true;
// 将邻接结点加入队列
queue.addLast(w);
}
// 以u为前结点，找w后面的下一个邻接结点
w = getNextNeighbor(u, w);
}
}
}再对广度优先遍历方法进行重载，遍历所有结点进行bfs操作
// 对bfs进行重载 遍历所有结点进行bfs
public void bfs(){
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]){
bfs(isVisited, i);
}
}
}结果
完整代码
package graph;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
public class Graph {
private ArrayList<String> vertexList; // 存储顶点集合
private int[][] edges; // 存储图对应的邻接矩阵
private int numOfEdges;
private boolean[] isVisited; // 记录某个结点是否被访问
public static void main(String[] args) {
int n = 5;
String VertexValue[] = {"A","B","C","D","E"};
Graph graph = new Graph(5);
// 循环添加节点
for (String s :
VertexValue) {
graph.insertVertex(s);
}
// 添加边： A-B A-C B-C B-D B-E
// 1表示两个结点连通
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.dfs();
System.out.println();
System.out.println();
// 测试广度优先遍历
// 注意测试的时候要先把前面的深度优先遍历给注释掉
// 不然的话isVisited全是true 就不会有输出
// System.out.println("广度优先遍历");
// graph.bfs();
// System.out.println();
// System.out.println();
}
// 构造器：初始化邻接矩阵和vertexList
public Graph(int n){
edges = new int[n][n];
vertexList = new ArrayList<>(n);
numOfEdges = 0;
isVisited = new boolean[5];
}
// 得到第一个邻接结点的下标w
public int getFirstNeighbor(int index){
for (int i = 0; i <vertexList.size(); i++) {
// 如果找到
if (edges[index][i] > 0){
// 如果存在则返回下标
return i;
}
}
// 否则返回-1
return -1;
}
// 根据前一个邻居结点的下标，来获取下一个邻接结点
public int getNextNeighbor(int v1, int v2){
for (int i = v2 + 1; i < vertexList.size(); i++) {
if (edges[v1][i] > 0){
return i;
}
}
return -1;
}
// 对一个结点进行广度优先遍历方法
public void bfs(boolean[] isVisited, int i){
int u; // 表示队列的头结点的下标
int w; // 表示邻接结点
// 模拟队列，记录结点访问顺序
LinkedList queue = new LinkedList();
// 访问结点，输出结点信息
System.out.print(getValueByIndex(i) + "->");
// 标将结点已经访问
isVisited[i] = true;
// 将结点加入队列
// 注意：从队列尾加入
queue.addLast(i);
while (!queue.isEmpty()){
// 注意：从队列头取出
u = (Integer) queue.removeFirst();
// 取邻接结点
w = getFirstNeighbor(u);
while (w != -1){ // 找到
// 判断是否访问过
if (!isVisited[w]){
// 取出
System.out.println(getValueByIndex(w) + "->");
// 标将结点已经访问
isVisited[w] = true;
// 将邻接结点加入队列
queue.addLast(w);
}
// 以u为前结点，找w后面的下一个邻接结点
w = getNextNeighbor(u, w);
}
}
}
// 对bfs进行重载 遍历所有结点进行bfs
public void bfs(){
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]){
bfs(isVisited, i);
}
}
}
// 深度优先遍历方法
public void dfs(boolean[] isVisited, int i){
// 首先访问该结点
System.out.print(getValueByIndex(i) + "->");
// 将该结点设置为已经访问
isVisited[i] = true;
// 查找该节点的第一个邻接结点
int w = getFirstNeighbor(i);
while (w != -1){ // 说明找到了邻接结点
// 如果该结点没有被访问过
if (!isVisited[w]){
// 递归
dfs(isVisited, w);
}
// 如果该结点被访问过
// 形参中：i是当前的结点，w是当前结点的下一个邻接结点
w = getNextNeighbor(i, w);
}
}
// 对dfs进行重载 遍历所有结点进行dfs
public void dfs(){
for (int i = 0; i < getNumOfVertex(); i++) {
if (!isVisited[i]){
dfs(isVisited, i);
}
}
}
// 插入节点
public void insertVertex(String vertex){
vertexList.add(vertex);
}
// 返回图中节点的个数
public int getNumOfVertex(){
return vertexList.size();
}
// 返回边的数量
public int getNumOfEdges(){
return numOfEdges;
}
// 返回对应下标的结点的数据
public String getValueByIndex(int i){
return vertexList.get(i);
}
// 返回两个结点的权值
public int getWeight(int v1, int v2){
return edges[v1][v2];
}
// 显示对应的矩阵
public void showGraph(){
int i = 0;
Iterator<String> iterator = vertexList.iterator();
System.out.print(" ");
while (iterator.hasNext()){
System.out.print(iterator.next() + " ");
}
System.out.println();
for (int[] link: edges){
System.out.println(vertexList.get(i) + Arrays.toString(link));
i++;
}
}
/**
* @params
* @param v1 表示第一个顶点的下标
* @param v2 表示第二个顶点的下标
* @param weight 自定义如何表示连通性
* @return void
*/
public void insertedge(int v1, int v2, int weight){
// 无向图
edges[v1][v2] = weight;
edges[v2][v1] = weight;
// 边的数目加1
numOfEdges++;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
