图的存储结构与实现总结-java版

最新推荐文章于 2023-03-09 20:45:13 发布

xushiyu1996818

最新推荐文章于 2023-03-09 20:45:13 发布

阅读量3.9k

点赞数 7

分类专栏：数据结构数据结构-图

本文链接：https://blog.csdn.net/xushiyu1996818/article/details/90373591

版权

数据结构同时被 2 个专栏收录

30 篇文章 2 订阅

订阅专栏

数据结构-图

13 篇文章 0 订阅

订阅专栏

图的存储结构

图的存储结构主要分两种，一种是邻接矩阵，一种是邻接表。

邻接矩阵

图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。
设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

看一个实例，下图左就是一个无向图。

从上面可以看出，无向图的边数组是一个对称矩阵。所谓对称矩阵就是n阶矩阵的元满足aij = aji。即从矩阵的左上角到右下角的主对角线为轴，右上角的元和左下角相对应的元全都是相等的。
从这个矩阵中，很容易知道图中的信息。
（1）要判断任意两顶点是否有边无边就很容易了；
（2）要知道某个顶点的度，其实就是这个顶点vi在邻接矩阵中第i行或（第i列）的元素之和；
（3）求顶点vi的所有邻接点就是将矩阵中第i行元素扫描一遍，arc[i][j]为1就是邻接点；
而有向图讲究入度和出度，顶点vi的入度为1，正好是第i列各数之和。顶点vi的出度为2，即第i行的各数之和。
若图G是网图，有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

邻接表

邻接矩阵是不错的一种图存储结构，但是，对于边数相对顶点较少的图，这种结构存在对存储空间的极大浪费。因此，找到一种数组与链表相结合的存储方法称为邻接表。
邻接表的处理方法是这样的：
（1）图中顶点用一个一维数组存储，当然，顶点也可以用单链表来存储，不过，数组可以较容易的读取顶点的信息，更加方便。
（2）图中每个顶点vi的所有邻接点构成一个线性表，由于邻接点的个数不定，所以，用单链表存储，无向图称为顶点vi的边表，有向图则称为顶点vi作为弧尾的出边表。
例如，下图就是一个无向图的邻接表的结构。

从图中可以看出，顶点表的各个结点由data和firstedge两个域表示，data是数据域，存储顶点的信息，firstedge是指针域，指向边表的第一个结点，即此顶点的第一个邻接点。边表结点由adjvex和next两个域组成。adjvex是邻接点域，存储某顶点的邻接点在顶点表中的下标，next则存储指向边表中下一个结点的指针。
对于带权值的网图，可以在边表结点定义中再增加一个weight的数据域，存储权值信息即可。如下图所示。

两者区别

对于一个具有n个顶点e条边的无向图
它的邻接表表示有n个顶点表结点2e个边表结点
对于一个具有n个顶点e条边的有向图
它的邻接表表示有n个顶点表结点e个边表结点
如果图中边的数目远远小于n^2称作稀疏图，这是用邻接表表示比用邻接矩阵表示节省空间;
如果图中边的数目接近于n^2,对于无向图接近于n*(n-1)称作稠密图,考虑到邻接表中要附加链域，采用邻接矩阵表示法为宜。

图的java实现

这个实现是基于邻接表的

顶点

使用label作为顶点的标识

edgelist作为linkedlist，存储以这个顶点为起点的边

后面3个属性是为了应对其他操作（比如深度遍历等），特意保留的变量

package datastructure.graph.adjacencymatrixgraph;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;


/**邻接矩阵的顶点类
 * @author xusy
 *
 * @param <T>
 */
public class Vertex<T> {
	
	/**
	 * 能够标识这个定点的属性，可以用不同类型来标识顶点如String,Integer....
	 */
	private T label;
	
	/**
	 * 这个定点对应的边<br>
	 * 如果为有向图，则代表以这个定点为起点的边
	 */
	private List<Edge> edgeList;
	
	/**
	 * 表示这个顶点是否已被访问，在bfs和dfs中会被使用到
	 */
	private boolean visited;
	
	/**
	 * 该顶点的前驱节点<br>
	 * 在求图中某两个顶点之间的最短路径时，在从起始顶点遍历过程中，需要记录下遍历到某个顶点时的前驱顶点
	 */
	private Vertex previousVertex;
	
	/**
	 * 这个定点的权值（注意不是边的权值）
	 */
	private double cost;
	
	/**创建顶点
	 * @param label  这个顶点的标识
	 * @param cost  这个顶点的权值
	 */
	public Vertex(T label,double cost){
		this.label=label;
		//用链表存储边
		edgeList=new LinkedList<>();
		visited=false;
		previousVertex=null;
		this.cost=cost;
	}
	
	//下面与顶点的标识相关
	
	/**返回顶点的标识
	 * @return
	 */
	public T getLabel() {
		return label;
	}

	/** 
	 * 根据顶点的标识确定是否是同一个顶点
	 */
	@Override
	public boolean equals(Object otherVertex) {
		boolean result;
		//如果otherVertex为空或者类不同，直接返回false
		if(otherVertex==null||getClass()!=otherVertex.getClass()){
			return false;
		}
		Vertex other=(Vertex)otherVertex;
		//根据label确定是否是同一个顶点
		result=label.equals(other.getLabel());
		return result;		
	}

	//下面与顶点的边相关
	
	/** 返回边的迭代器
	 * @return
	 */
	public Iterator<Edge> getEdgeIterator(){
		return edgeList.iterator();
	}
	
	/**返回是否有以这个顶点为出发点的边数
	 * @return
	 */
	public int getEdgeCount(){
		return edgeList.size();
	}

	/**将这个顶点与endVertex连接，边的权值为weight
	 * @param endVertex
	 * @param weight
	 * @return 如果顶点已经与endVertex连接，那么将会更新权值，返回false<br>
	 * 如果顶点没有与endVertex相连，则互相连接，返回true
	 */
	public boolean connect(Vertex endVertex,double weight){
		Iterator<Edge> iterator=getEdgeIterator();
		Edge edge=null;
		Vertex vertex=null;
		while(iterator.hasNext()){
			edge=iterator.next();
			vertex=edge.getEndVertex();
			if(vertex.equals(endVertex)){
				//如果顶点已经与endVertex连接，那么将会更新权值，返回false
				edge.setWeight(weight);
				return false;
			}
		}
		//如果顶点没有与endVertex相连，则互相连接，返回true
		edge=new Edge(this,endVertex, weight);
		edgeList.add(edge);		
		return true;
	}
	
	/**将这个顶点与endVertex连接的边删除
	 * @param endVertex
	 * @return  如果顶点已经与endVertex连接，那么将会删除这条边，返回true<br>
	 * 如果顶点没有与endVertex连接，则啥都不做，返回false
	 */
	public boolean disconnect(Vertex endVertex){
		Iterator<Edge> iterator=getEdgeIterator();
		Edge edge=null;
		Vertex vertex=null;
		while(iterator.hasNext()){
			edge=iterator.next();
			vertex=edge.getEndVertex();
			if(vertex.equals(endVertex)){
				//如果顶点已经与endVertex连接，那么将会删除这条边，返回true
				//edgeList.remove(edge);
				iterator.remove();
				return true;
			}
		}
		//如果顶点没有与endVertex连接，则啥都不做，返回false		
		return false;
	}	
	
	/**返回是否有以这个顶点为出发点,以endVertex为结束点的边
	 * @return 如果有，返回那条边<br>
	 * 如果没有，返回null
	 */
	public Edge hasNeighbourVertex(Vertex endVertex){
		Iterator<Edge> iterator=getEdgeIterator();
		Edge edge=null;
		Vertex vertex=null;
		while(iterator.hasNext()){
			edge=iterator.next();
			vertex=edge.getEndVertex();
			if(vertex.equals(endVertex)){
				//如果顶点已经与endVertex连接，那么将返回这个边			
				return edge;
			}
		}
		//没有则返回null
		return null;
	}

	
	
	//下面是与顶点是否被访问相关
	
	/**返回顶点是否被访问
	 * @return
	 */
	public boolean isVisited() {
		return visited;
	}
	
	/**
	 * 访问这个顶点
	 */
	public void visit(){
		visited=true;
	}
	
	/**
	 * 不访问这个顶点，或者说是清除访问状态
	 */
	public void unVisit(){
		visited=false;
	}
	
	/**获得以这个顶点为出发点，相邻的第一个没有被访问的顶点
	 * @return 如果没有，返回null<br>
	 * 如果有，返回对应的顶点
	 */
	public Vertex getUnvisitedVertex(){
		Iterator<Edge> iterator=getEdgeIterator();
		Edge edge=null;
		Vertex vertex=null;
		while(iterator.hasNext()){
			edge=iterator.next();
			vertex=edge.getEndVertex();
			if(vertex.isVisited()==false){
				return vertex;
			}
		}
		//没有则返回null
		return null;
	}
	
	//下面与前驱节点相关	

	/**返回顶点的前驱节点
	 * @return
	 */
	public Vertex getPreviousVertex() {
		return previousVertex;
	}

	/**设置顶点的前驱节点
	 * @param previousVertex
	 */
	public void setPreviousVertex(Vertex previousVertex) {
		this.previousVertex = previousVertex;
	}

	//下面与顶点的权值相关
	
	/**返回顶点的权值
	 * @return
	 */
	public double getCost() {
		return cost;
	}

	/** 设置顶点的权值
	 * @param cost
	 */
	public void setCost(double cost) {
		this.cost = cost;
	}
	
	
	
	
	
	
}

边

beginVertex是开始点

endVertex是结束点

weight为边的权值

package datastructure.graph.adjacencymatrixgraph;

/** 连接两个顶点的边
 * @author xusy
 *
 */
public class Edge {
	
	/**
	 * beginVertex是边的起始顶点<br>
	 * 普通情况是不用显示地存储beginVertex，但是生成最小生成树时需要
	 */
	private Vertex beginVertex;
	
	/**
	 * 由于Edge是存储在Vertex中的，所以包含这个边的vertex是开始点
	 * endVertex是结束点
	 */
	private Vertex endVertex;
	
	/**
	 * 边的权值
	 */
	private double weight;

	/**创建边
	 * @param beginVertex 边的开始点
	 * @param endVertex 边的结束点
	 * @param weight  边的权值
	 */
	public Edge(Vertex beginVertex,Vertex endVertex, double weight) {
		this.beginVertex = beginVertex;
		this.endVertex = endVertex;
		this.weight = weight;
	}

		
	/**返回边的开始点
	 * @return
	 */
	public Vertex getBeginVertex() {
		return beginVertex;
	}

	/** 返回边的结束点
	 * @return
	 */
	public Vertex getEndVertex() {
		return endVertex;
	}

	/**返回边的权值
	 * @return
	 */
	public double getWeight() {
		return weight;
	}

	/**设置边的权值
	 * @param weight
	 */
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	
	
	

}

图

isDirect用来区分有向图，区别就是加入边的时候，无向图会加入两条，有向图只会加入一条

如果不需要边和顶点的权值，加入时，设置为0即可

package datastructure.graph.adjacencymatrixgraph;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

/**邻接矩阵的图类
 * @author xusy
 *
 * @param <T>
 */
public class Graph<T> {
	
	/**
	 * 用来存储顶点
	 * T做为标识，vertext作为实际的顶点
	 */
	private Map<T, Vertex<T>> vertexMap;
	
	/**
	 * 图中边的数目<br>
	 * 顶点的数目可以用vertexMap.size()
	 */
	private int edgeCount;
	
	/**
	 * 图是否为有向图<br>
	 * 如果是有向图，则为true
	 */
	boolean isDirect;
	
	/**图的构造函数
	 * @param isDirect  图是否为有向图<br>
	 * 如果是有向图，则为true
	 */
	public Graph(boolean isDirect){
		vertexMap=new LinkedHashMap<>();
		edgeCount=0;
		this.isDirect=isDirect;
	}
	

	//下面与图的顶点相关
	
	/**返回图中的顶点个数
	 * @return
	 */
	public int getVertexCount(){
		return vertexMap.size();
	}
	
	/** 返回图的顶点的迭代器
	 * @return
	 */
	public Iterator<Vertex<T>> getVertexIterator(){
		return vertexMap.values().iterator();
	}
	
	/**在图中插入节点，节点的标识为label,节点的权值为cost
	 * @param label
	 * @param cost  如果不需要节点的权值，则设0即可
	 * @return 如果图中不存在该节点，则插入，返回true<br>
	 * 如果图中已经存在该节点，则更新权值，返回false
	 */
	public boolean addVertex(T label,double cost){
		Vertex vertex=vertexMap.get(label);
		if(vertex!=null){
			//如果图中已经存在该节点，则更新权值，返回false
			vertex.setCost(cost);
			return false;
		}
		//如果图中不存在该节点，则插入，返回true
		vertex=new Vertex<T>(label, cost);
		vertexMap.put(label, vertex);
		return true;
	}
	
	//下面与图的边相关
	
	/** 返回图中所有的边的个数<br>
	 * 如果为有向图，则是所有的有向边的个数<br>
	 * 如果为无向图，则视一条边为两条相反的有向边，相当于返回无向边的个数*2
	 * @return
	 */
	public int getEdgeCount(){
		Iterator<Vertex<T>> iterator=getVertexIterator();
		int count=0;
		while(iterator.hasNext()){
			Vertex<T> vertex=iterator.next();
			count=count+vertex.getEdgeCount();
		}
		return count;
	}
	
	/** 返回图中标识为label的顶点作为出发点的边的个数
	 * @param label
	 * @return 如果为有向图，则返回标识为label的顶点作为出发点的边的个数
	 * 如果为无向图，则返回标识为label的顶点相连接的边的个数
	 * 如果图中没有这个顶点，返回-1
	 */
	public int getEdgeCount(T label){
		Vertex<T> vertex=vertexMap.get(label);
		if(vertex==null){
			//如果图中没有这个顶点，返回-1
			return -1;
		}
		//返回途中标识为label的顶点作为出发点的边的个数
		return vertex.getEdgeCount();
	}
	
	/** 返回图中标识为label的顶点作为出发点的边的迭代器
	 * @param label
	 * @return 如果没有这个顶点，返回null
	 */
	public Iterator<Edge> getEdgeIterator(T label){
		Vertex<T> vertex=vertexMap.get(label);
		if(vertex==null){
			//如果图中没有这个顶点，返回null
			return null;
		}
		return vertex.getEdgeIterator();
	}
	
	
	/**在图中加入一条边，如果isDirect为true，则为有向图，则<br>
	 * 建立一条以begin作为标识的节点开始的边，以end作为标识的节点结束，边的权值为weight<br>
	 * 如果isDirect为false，则为无向图，则<br>
	 * 建立两条边，一条以begin开始，到end ，一条以end开始，到begin
	 * @param begin
	 * @param end
	 * @param weight 如果不需要边的权值，可以设为0
	 * @return 如果没有对应的边，则加入对应的边，返回true<br>
	 * 如果有对应的边，则更新weight，返回false
	 * 如果没有以begin或者end标识的顶点，则直接返回false
	 */
	public boolean addEdge(T begin,T end,double weight){
		Vertex beginVertex=vertexMap.get(begin);
		Vertex endVertex=vertexMap.get(end);
		if(beginVertex==null||endVertex==null){
			//如果没有以begin或者end标识的顶点，则直接返回false
			return false;
		}
		//有向图和无向图都要建立begin到end的边
		//如果顶点已经与endVertex连接，那么将会更新权值，result=false
		//如果顶点没有与endVertex相连，则互相连接，result=true
		boolean result=beginVertex.connect(endVertex, weight);
		if(result){
			edgeCount++;
		}
		if(!isDirect){
			//如果不是有向图，则建立两条边,一条以end开始，到begin
			endVertex.connect(beginVertex, weight);
			if(result){
				edgeCount++;
			}
		}				
		return result;
	}
	
	/**在图中删除一条边，如果isDirect为true，则为有向图，则<br>
	 * 删除一条以begin作为标识的节点开始的边，以end作为标识的节点结束<br>
	 * 如果isDirect为false，则为无向图，则<br>
	 * 删除两条边，一条以begin开始，到end ，一条以end开始，到begin
	 * @param begin
	 * @param end
	 * @return 如果有对应的边，则删除对应的边，返回true<br>
	 * 如果没有有对应的边，则直接返回false
	 * 如果没有以begin或者end标识的顶点，则直接返回false
	 */
	public boolean removeEdge(T begin,T end){
		Vertex beginVertex=vertexMap.get(begin);
		Vertex endVertex=vertexMap.get(end);
		if(beginVertex==null||endVertex==null){
			//如果没有以begin或者end标识的顶点，则直接返回false
			return false;
		}
		//有向图和无向图都要删除begin到end的边
		//如果顶点已经与endVertex连接，那么将会删除这条边，返回true
		//如果顶点没有与endVertex连接，则啥都不做，返回false
		boolean result=beginVertex.disconnect(endVertex);
		if(result){
			edgeCount--;
		}
		if(!isDirect){
			//如果不是有向图，则删除两条边,一条以end开始，到begin
			endVertex.disconnect(beginVertex);
			if(result){
				edgeCount--;
			}
		}				
		return result;
	}
	

	//下面与打印相关
	
	/**
	 * 打印图的概况，所有顶点，所有边
	 */
	public void printGraph(){
		Iterator<Vertex<T>> iteratorVertex=getVertexIterator();
		Iterator<Edge> iteratorEdge;
		Vertex<T> vertex;
		Edge edge;
		T label;
		System.out.println("图是否为有向图："+isDirect+"，图的顶点个数："+getVertexCount()+"，图的总边个数："+getEdgeCount());
		while(iteratorVertex.hasNext()){
			vertex=iteratorVertex.next();
			label=vertex.getLabel();
			iteratorEdge=vertex.getEdgeIterator();
			System.out.println("顶点："+label+"，以这个顶点为出发点的边的个数："+getEdgeCount(label)+"，该顶点的权值为："+vertex.getCost());
			while(iteratorEdge.hasNext()){
				edge=iteratorEdge.next();
				System.out.print("边：从 "+label+" 到 "+edge.getEndVertex().getLabel()+" ，权值："+edge.getWeight()+"   ");
			}
			System.out.println();
		}
		System.out.println();
	}
	
	
}

测试

package datastructure.graph.adjacencymatrixgraph;

public class Main {

	public static void main(String[] args) {
		Graph<String> graph=new Graph<>(false);
		graph.addVertex("first", 0);
		graph.addVertex("second", 0);
		graph.addVertex("third", 1);
		graph.addEdge("first", "second", 1);
		graph.addEdge("first", "third", 2);
		
		graph.printGraph();
		
		graph.removeEdge("first", "second");
		graph.printGraph();

	}

}

xushiyu1996818

关注

7
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
图的存储结构与实现总结-java版

目录图的存储结构邻接矩阵邻接表两者区别图的java实现顶点边图测试图的存储结构图的存储结构主要分两种，一种是邻接矩阵，一种是邻接表。邻接矩阵图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：看一个实例，下图...
复制链接

扫一扫