对于图的一些基本概率和术语的内容汗牛充栋，故本文不会做过多解释。仅仅总结下笔者学习图的邻接矩阵的相关知识
邻接矩阵的实现原理
邻接矩阵(adjacency matrix)是图ADT最基本的实现方式，使用二维数组A[n][n]来表示由n个顶点构成的图。二维数组中的A[i][j]表示一条从来顶点i为起点到顶点j的弧。
对于无权图，存在（不存在）从顶点u到v的边，当且仅当A[u][v] =1（0）。上图a,b即为无向图和有向图的邻接矩阵实例。图c所示，矩阵各单元可从布尔型改为整型或浮点型，记录所对应边的权重。对于不存在的边，通常统一取值null。
节点的实现
public class Node<T> {
private T data; // 存储的数据
private int outDegree; // 出度
private int inDegree; // 入度
//如下四个属性用与遍历中
private int status = 0; //状态 0 undiscovered 1 discovered 2 visited
//status应该使用枚举的，这里笔者偷懒了
private int parent = -1;
private int dTime = -1; //开始遍历的时间
private int fTime = -1; //结束遍历的时间
public Node(T t) {
this.data = t;
this.outDegree = 0;
this.inDegree = 0;
}
protected void addInDegree() {
this.inDegree++;
}
protected void addOutDegree() {
this.outDegree++;
}
protected void delInDegree() {
this.inDegree--;
}
protected void delOutDegree() {
this.outDegree--;
}
//节约篇幅，省略getter setter...
}弧的实现
public class Edge<T> {
private T data; // 弧数据
private int weight; // 权值
private int type;
//应该使用枚举的，这里笔者偷懒了
//弧类型：0 CROSS 跨边 1 TREE（支撑树）
//2 BACKWARD(该弧的起点和终点在支撑树中存在终点到起点的路径)
//3 FORWARD (该弧的起点和终点在支撑树中存在其他路径依然可以从起点到终点)
public Edge(T data) {
this(data, 1);
}
public Edge(T data, int weight) {
this.data = data;
this.weight = weight;
}
//节约篇幅，省略getter setter...
}邻接矩阵的存储实现
public class AdjacencyMatrix {
private Edge[][] nodeGraphs;
private Node[] allNodes;
private Integer size=0;
private int DEFAULT_CAPACITY = 10;
//创建默认长度的邻接矩阵
public AdjacencyMatrix() {
nodeGraphs = new Edge[DEFAULT_CAPACITY][DEFAULT_CAPACITY];
allNodes = new Node[DEFAULT_CAPACITY];
}
//创建指定长度的邻接矩阵
public AdjacencyMatrix(int numbers) {
nodeGraphs = new Edge[numbers][numbers];
allNodes = new Node[numbers];
}
//添加新节点，并返回新节点索引
public int addNode(Node node) {
int returnIndex = size;
//判断当前数组的容量，来决定是否扩容
ensureCapacityInternal(size + 1);
allNodes[size++] = node;
return returnIndex;
}
private void ensureCapacityInternal(int minCapacity) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
//判断是否需要扩容
if(minCapacity - allNodes.length > 0) {
grow(minCapacity);
}
}
private void grow(int minCapacity) {
int oldCapacity = allNodes.length;
//新数组的长度为(原数组长度+原数组长度/2)
//右移n为即为除2的n次方
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//将原数组复制到扩容后的数组中
allNodes = Arrays.copyOf(allNodes, newCapacity);
nodeGraphs = Arrays.copyOf(nodeGraphs, newCapacity);
//对于二维中的数组执行扩容
for(int i=0;i<nodeGraphs.length;i++) {
if(nodeGraphs[i] != null) {
nodeGraphs[i] = Arrays.copyOf(nodeGraphs[i], newCapacity);
}else {
nodeGraphs[i] = new Edge[newCapacity];
}
}
}
//获取出度
public int getInDeep(int index) {
if(allNodes[index] == null) {
return -1;
}
return allNodes[index].getInDegree();
}
//获取入度
public int getOutDeep(int index) {
if(allNodes[index] == null) {
return -1;
}
return allNodes[index].getOutDegree();
}
//删除第index边及其相关边
public Node removeNode(int deleteIndex) {
Node node = allNodes[deleteIndex];
if(node == null) {
throw new RuntimeException("节点为空");
}
//先删除节点
allNodes[deleteIndex] = null;
//删除所有相关边
for(int i=0;i<size;i++) {
//该节点作为一条弧的弧头(即指向该节点的弧)
if(nodeGraphs[deleteIndex][i] != null) {
nodeGraphs[deleteIndex][i] = null;
allNodes[i].delInDegree();
}
//该节点作为一条弧的弧尾(即该节点出去的弧)
if(nodeGraphs[i][deleteIndex] != null) {
nodeGraphs[i][deleteIndex] = null;
allNodes[i].delOutDegree();
}
}
return node;
}
//设置一个从节点row为起点到col的弧
public void setMatrix(int row, int col, Edge val) {
nodeGraphs[row][col] = val;
allNodes[row].addOutDegree();
allNodes[col].addInDegree();
}
//重置状态
public void reload() {
for(int i=0;i<size;i++) {
allNodes[i].setStatus(0);
allNodes[i].setParent(-1);
}
}
}性能
时间性能：
按照代码的实现方式，各顶点的编号可直接转换为其在邻接矩阵中对应的顶点，从而使得图中所有的静态操作接口，均只需O(1)时间。弧的静态和动态操作也仅需O(1)时间，其代价是邻接矩阵的空间冗余。
邻接矩阵的不足主要体现在，顶点的动态操作接口均十分耗时。为了插入新的顶点，顶点集向量allNodes[]需要添加一个元素；弧集向量nodeGraphs[][]也需要增加一行，且每行都需要添加一个元素。顶点删除操作，亦与此类似。不难看出，这些恰恰也是数组结构固有的不足。
但在通常的算法中，顶点的动态操作远少于其它操作。而且，即便计入向量扩容的代价，就分摊意义而言，单次操作的耗时亦不过O(n)
空间性能：
上述实现方式所用空间，主要消耗于邻接矩阵，亦即其中的二维弧集向量nodeGraphs[][]。每个Edge对象虽需记录多项信息，但总体不过常数。根据我们扩容的算法根据其数组长度始终不低于50%，故空间总量渐进地不超过O(n*n)= O(n^2)
当然，对于无向图而言，仍有改进的余地。如上图a所示，无向图的邻接矩阵必为对称阵，其中除自环以外的每条边，都被重复地存放了两次。也就是说，近一半的单元都是冗余的。为消除这一缺点，可采用压缩存储等技巧，进一步提高空间利用率。
使用邻接矩阵实现一个图
现在使用刚刚笔者定义的Node，Edge和AdjacencyMatrix定义一个图
public static void main(String[] args) {
int aIndex = matrix.addNode(new Node<String>("a")); //索引为0
int bIndex = matrix.addNode(new Node<String>("b")); //索引为1
int cIndex = matrix.addNode(new Node<String>("c")); //索引为2
int dIndex = matrix.addNode(new Node<String>("d")); //索引为3
int eIndex = matrix.addNode(new Node<String>("e")); //索引为4
int fIndex = matrix.addNode(new Node<String>("f")); //索引为3
int gIndex = matrix.addNode(new Node<String>("g")); //索引为4
matrix.setMatrix(aIndex, bIndex, new Edge<String>("这是边a到b的弧",1));
matrix.setMatrix(aIndex, cIndex, new Edge<String>("这是边a到c的弧",1));
matrix.setMatrix(bIndex, dIndex, new Edge<String>("这是边b到d的弧",1));
matrix.setMatrix(bIndex, eIndex, new Edge<String>("这是边b到e的弧",1));
matrix.setMatrix(cIndex, fIndex, new Edge<String>("这是边c到f的弧",1));
matrix.setMatrix(cIndex, gIndex, new Edge<String>("这是边c到g的弧",1));
//打印节点的出度和入度
System.out.println("a:"+matrix.getInDeep(aIndex));
System.out.println("a:"+matrix.getOutDeep(aIndex));
System.out.println("b:"+matrix.getInDeep(bIndex));
System.out.println("b:"+matrix.getOutDeep(bIndex));
System.out.println("c:"+matrix.getInDeep(cIndex));
System.out.println("c:"+matrix.getOutDeep(cIndex));
System.out.println("d:"+matrix.getInDeep(dIndex));
System.out.println("d:"+matrix.getOutDeep(dIndex));
}