Java数据结构——邻接矩阵+邻接表

一、邻接矩阵

1. 定义

• vexs[]（存储顶点）和 arcs[][]（存储边关系，叫邻接矩阵）集合。因此，用一个一维数组存放图中所有顶点数据；
• 用一个二维数组存放顶点间关系（边或弧）的数据，这个二维数组称为邻接矩阵。
• 无向图邻接矩阵是一个对称矩阵。
• 用邻接矩阵表示图，很容易确定图中任意两个顶点是否有边相连。
• 前一天的基础知识讲了：有权的图被称为网。无向图比有向图更为特殊。

2. 数据结构

• 邻接矩阵，C语言数据结构

#define MAX_VEX 20
typedef enum {
   DG, UDG};
typedef int InfoType;
// 弧结点与矩阵的类型
typedef struct ArcCell {
   
	int adj; // 图--0,1;网--权值
	InfoType * Info; //与弧相关的信息的指针,如：权值
}ArcCell, AdjMatrix[MAX_VEX][MAX_VEX];
//  图的类型
typedef struct {
           
    char vexs[MAX_VEX]; // 顶点向量，一维矩阵 
    AdjMatrix arcs; // 邻接矩阵，二维矩阵 
    int vexnum, arcnum; // 顶点数，边数
    GraphKind kind; // 图类型
}MGraph;

• Java代码：

图的接口：（1.因为要写的数据结构较多，邻接矩阵，邻接表，十字链表，多重链表。但我们要实现的功能差不多，我们就可以把图的基本操作集成为一个接口。2.尝试多种方式开发，不拘泥。）

package graph;

/**
 * 邻接矩阵图的接口
 * 
 * @author 己千之
 * @time 2022/2/8/16:32 (tuesday)
 */
public interface IGraph {
   

	/**
	 * 获取顶点的个数
	 * 
	 * @return 顶点的个数
	 */
	int getNumOfVertex();
	
	/**
	 * 获取边的个数
	 * 
	 * @return
	 */
	int getNumOfArc();

	/**
	 * 插入顶点
	 * 
	 * @param String v
	 * @return boolean
	 */
	boolean insertVex(String v);

	/**
	 * 删除顶点
	 * 
	 * @param String v
	 * @return boolean
	 */
	boolean deleteVex(String v);

	/**
	 * 定位顶点的位置
	 * 
	 * @param String v
	 * @return 顶点的位置
	 */
	int indexOfVex(String v);

	/**
	 * 定位指定位置的顶点
	 * 
	 * @param v 顶点的位置
	 * @return E
	 */
	String valueOfVex(int v);

	/**
	 * 插入边
	 * 
	 * @param v1     顶点的位置
	 * @param v2     顶点的位置
	 * @param weight
	 * @return boolean
	 */
	boolean insertEdge(int v1, int v2, int weight);

	/**
	 * 删除边
	 * 
	 * @param v1 顶点的位置
	 * @param v2 顶点的位置
	 * @return boolean
	 */
	boolean deleteEdge(int v1, int v2);

	/**
	 * 查找边，获取权值
	 * 
	 * @param v1 顶点的位置
	 * @param v2 顶点的位置
	 * @return
	 */
	int getEdge(int v1, int v2);

	/**
	 * @深度优先搜索遍历 
	 * 从第v个顶点位置开始，深度优先搜索遍历
	 * 
	 * @param v 顶点的位置
	 * @return eg: v1->v2-v3
	 */
	void DFSTraverse();

	/**
	 * @广度优先搜索遍历 
	 * 从第v个顶点位置开始，广度优先搜索遍历
	 * 
	 * @param v 顶点的位置
	 * @return eg: v1->v2-v3
	 */
	void BFSTraverse();

	/**
	 * 查找源点到其它各个顶点的最短路径
	 * 
	 * @param v
	 * @return int[] 源点到其它各个顶点的最短路径
	 */
	public int[] dijkstra(int v);

} // IGraph

Java邻接矩阵：

package graph;

import java.util.Arrays;

/**
 * 邻接矩阵 存储图
 * 
 * @author 己千之
 * @MGraph Matrix Graph
 */
public class MGraph implements IGraph {
   

	/**
	 * @INF 无穷大 private static final int INF=Integer.MAX_VALUE;
	 */
	public static final int INF = 99; // 最大值

	/**
	 * 存储图的顶点的一维数组
	 */
	String[] vexs;

	/**
	 * 存储图的边的二维数组
	 */
	int[][] arcs;

	/**
	 * 顶点的实际数量
	 */
	int vexNum;

	/**
	 * 边数
	 */
	int arcNum;

	/**
	 * 顶点的最大数量
	 */
	int vexMax;

	/**
	 * 构造函数
	 * 
	 * @param vexMax int型
	 */
	public MGraph(int vexMax) {
   
		this.vexMax = vexMax;
		this.arcs = new int[vexMax][vexMax];
		this.vexs = new String[vexMax];
	}

	/**
	 * 构造函数
	 * 
	 * 直接传入一个矩阵，作为邻接矩阵
	 * 
	 * @param AdjMatrix
	 */
	public MGraph(int[][] AdjMatrix) {
   
		vexMax = AdjMatrix.length;

		this.arcs = new int[vexMax][vexMax];
		for (int i = 0; i < vexMax; i++) {
   
			for (int j = 0; j < vexMax; j++) {
   
				arcs[i][j] = AdjMatrix[i][j];
			}
		}

		this.vexs = new String[vexMax];
		for (int i = 0; i < vexMax; i++) {
   
			int t = i + 1;
			vexs[i] = "node" + t;
		}
	}

	/**
	 * 深度遍历
	 * 
	 * toString() arcs[][]
	 */
	public String toString() {
   
		return Arrays.deepToString(arcs);
	}

	@Override
	public int getNumOfVertex() {
   
		// 得到顶点的数目

		return this.vexNum;
	}

	@Override
	public int getNumOfArc() {
   
		// 得到边的数目
		int edgeNum = 0;
		for (int i = 0; i < vexNum; i++) {
   
			for (int j = 0; j < vexNum; j++) {
   
				if (this.arcs[i][j] != INF && arcs[i][j] != 0) {
   
					edgeNum++;
				}
			}
		}

		return edgeNum;
	}

	@Override
	public boolean insertVex(String v) {
   
		// 插入顶点

		if (