java图数据结构

最新推荐文章于 2022-10-16 09:23:18 发布
最新推荐文章于 2022-10-16 09:23:18 发布
阅读量809 收藏 6
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44545800/article/details/105326009
版权
本文详细介绍了图数据结构，包括无向图、有向图、完全图和加权图的概念，以及顶点的度、路径、环等基本元素。讨论了图的两种主要实现方式——邻接矩阵和邻接列表，分析了它们的空间复杂度，并对比了各自的优劣。此外，还提及了连通图、生成树和最小生成树等重要概念。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概念：

图G＝（V，E）由一组顶点V和一组边E组成，每一条边是一个元组（v，w），其中v,w属于V中。如果对元组有序的，则图是有向的(directed)。否则图是无向的(undirected)。

在无向图中(undirected graph)，边是没有方向的平面线。在无向图中，可以沿着边任意走一条路。任何无向图都可以表示为有向图，方法是用两条有向边替换每一条无向边。

在有向图中(directed graph)，有向图是指每一条边上的顶点都是有序的图。边是从一个节点指向另一个节点的箭头。<Vi,Vj>：Vi称为尾部，Vj称为头部。在有向图中, 只能按照箭头的方向从一个节点转到另一个节点。这意味着, 在有向图中, 有可能达到死胡同, 也有可能到达一个你不能离开的节点。

完全图(complete graph)是每对顶点之间都有一条边的图。无向完全图：n个顶点和n（n-1）/2条边。有向完全图：n个顶点和n（n-1）边。如果（u，v）是E（G）中的边，则u与v相邻，v与v相邻。

加权图(weoghted graph)：有时边有第三个组成部分, 重量或成本, 其语义是特定于图形的。具有与其边缘关联的值的图称为加权图。该图可以是定向的, 也可以是无方向的。权重可以表示如下内容:两个顶点之间的物理距离。从一个顶点到另一个顶点所需的时间。从顶点到顶点的行程成本是多少。

子图(Subgraph)：子图设G=（V，E）是顶点集V和边集E的图。G的子图是图G'=（V'，E'），其中

  1. V'是V的一个子集。
  2. E'由E中的边（v，w）组成，使得v和w都在V'中(子图中的边要预先存在，并且定点在子图中)

顶点的度(degree)：顶点v的度是连接到顶点v的边数，记为TD(v)。在有向图中，顶点度是进度和出度之和：顶点v的入度是头部为顶点v的边的数目，记为ID(v);顶点v的出度是尾部为顶点v的边数，记为OD(v)

路径的长度是在未加权的图形中沿着路径的边数。它是加权图中路径上弧线的成本之和。

环是在同一顶点处开始和结束的边 (v, v).且其长度大于等于1 。

简单路径是路径上的各顶点均不互相重复。

DAG(定向无环图):无环有向图(图不包含环，若图不包含环，则为无环图)

连通图：连通图是一个无向图，其中有一条从每个顶点到其余另一个顶点的路径。

  1. 强连通图是一个有向图，其中每个顶点之间都有一条路径(考虑方向)
  2. 弱连通图是一个有向图，它不是强连通的，但如果图被转换成无向图，它就会连通（简单地忽略方向）。

图的连通分量( Connected Component)：无向图G的极大连通子图称为G的连通分量。任何连通图的连通分量只有一个，即是其自身，非连通的无向图有多个连通分量。

  1. 有向图的一个强连通分量是一个极大的顶点集(不一定包含所有的顶点，可以是多个)，其中有一条从集合中任何一个顶点到集合中任何其他顶点的路径。
  2. 在非连通的无向图中, 从其中的顶点开始只能访问同一连通分量中的顶点 (最大的连通子图)搜索所有连接的组件搜索图形中的每个顶点。如果已访问该顶点, 则它必须位于连通分量中。否则, 从这个顶点开始遍历图形, 我们将得到另一个连通分量。

生成树：如果连通图G的一个子图是一棵包含G的所有顶点的树，则该子图称为G的生成树。 每个具有 n 个顶点的生成树都包含完全为 n-1 的边。如果我们在树上添加任何边缘, 我们就会得到一个循环。

对于无向图G和一棵树T来说，如果T是G的子图，则称T为G的树，如果T是G的生成子图，则称T是G的生成树。

最小生成树：对于一个边上具有权值的图来说，其边权值和最小的生成树称做图G的最小生成树(包含所有节点)。对于一个图G，如果图中的边权值都不相同，则图的最小生成树唯一。

有向树：在根树T中，出度为零的点称为树叶

  1. 有且仅有一个结点的入度为0；
  2. 除树根外的结点入度为1；
  3. 从树根到任一结点有一条有向通路，T中其他顶点称为内点或支点。在根树中，有时需要考虑同一层上结点的次序，规定了每一层上的结点的次序的根树称为有序树。

实现：

 

数据结构的定义：

由于图中存储了图的顶点和路径信息，所以其数据结构也应该保存相应的信息。

故使用邻接矩阵存储信息，其顶点映射到整数0..N-1，而边则映射成一个N*N的矩阵，定义如下：

对于有向图与无向图而言：

对于加权图而言：

 

代码实现

 第一种方式：矩阵实现

缺点：空间复杂度高，O(N^2),实际生活中们并不适用

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

//浪费空间，有O(N^2)的空间复杂度
public class GraphMatrix<Type> {
	private static int MAXV=10;
	private Vetex<Type>[] vetex;
	private int[][] edges;
	private int currentv;
	public GraphMatrix() {
		this.vetex=new Vetex[MAXV];
		this.edges=new int[MAXV][MAXV];
		currentv=0;
		for(int i=0;i<MAXV;i++) {
			for(int j=0;j<MAXV;j++) {
				this.edges[i][j]=0;
			}
		}
	}
	public boolean isEmpty() {
		return currentv==0;
	}
	public boolean isFull() {
		return this.currentv==MAXV-1;
	}
	public int sizev() {
		return currentv+1;
	}
	public int sizee() {
		int sum=0;
		for(int i=0;i<=this.currentv;i++) {
			for( int j=0;j<=this.currentv;j++) {
				sum+=edges[i][j];
			}
		}
		return sum;
	}
	public void addv(Type data) {
		if(find(data)!=-1) {
			System.out.println("顶点"+data+"已添加");
		}else {
			this.vetex[this.currentv]=new Vetex<>(data);
			this.currentv++;
		}	
	}
	public void adde(Type start,Type end) {
		int start1=find(start);
		int end1=find(end);
		if(start1!=-1 && end1!=-1) {
			this.edges[start1][end1]=1;
			this.edges[end1][start1]=1;
		}else {
			System.out.println(start+"或"+end+"不存在");
		}
	}
	public int find(Type data) {
		System.out.println("长度为："+this.currentv);
		for(int i=0;i<this.currentv;i++) {
			if(data.equals(vetex[i].data)) {
				return i;
			}
		}
		return -1;
	}
	public void print() {
		for( int i=0;i<this.currentv;i++) {
			for( int j=0;j<this.currentv;j++) {
				System.out.print(this.edges[i][j]+" ");
			}
			System.out.println();
		}
	}
	//广度优先遍历
	public void bfs() {
		Queue<Integer> q=new LinkedList<>();
		q.add(0);
		this.vetex[0].isVisited=true;
		System.out.print(this.vetex[0].data+" ");
		while(!q.isEmpty()) {
			int res=q.poll();
			int x;
			while(( x=findFirst(res))!=-1) {
				System.out.print(this.vetex[x].data+" ");
				this.vetex[x].isVisited=true;
				q.add(x);
			}
			
		}
		System.out.println();
		for(int i=0;i<this.currentv;i++) {
			this.vetex[i].isVisited=false;
		}
	}
	//深度优先便利
	public void dfs() {
		Stack<Integer> s=new Stack<>();
		System.out.print(this.vetex[0].data+" ");
		s.push(0);
		vetex[0].isVisited=true;
		while(!s.isEmpty()) {
			int res=findFirst(s.peek());
			if(res==-1) {
				s.pop();
			}else {
				System.out.print(this.vetex[res].data+" ");
				s.push(res);
				this.vetex[res].isVisited=true;
			}
			
		}
		System.out.println();
		for(int i=0;i<this.currentv;i++) {
			this.vetex[i].isVisited=false;
		}
	}
	public int findFirst(int index) {
		for(int i=0;i<this.currentv;i++) {
			if(this.edges[index][i]==1 && (!this.vetex[i].isVisited)) {
				return i;
			}
		}
		return -1;
	}
	
}
class Vetex<Type>{
	public Type data;
	public boolean isVisited;
	public Vetex() {
		this.data=null;
		this.isVisited=false;
	}
	public Vetex(Type data) {
		this.data=data;
		this.isVisited=false;
	}
}

class TestGraphMatrix{
	public static void main(String args[]) {
		GraphMatrix<Character> graph = new GraphMatrix<>();
        graph.addv('A');
        graph.addv('B');
        graph.addv('C');
        graph.addv('D');
        graph.addv('E');
        graph.adde('B', 'C');
        graph.adde('A', 'B');
        graph.adde('C', 'D');
        graph.adde('B', 'E');
        graph.adde('C', 'E');
        graph.print();
        graph.dfs();
         graph.bfs();

	}
}

第二种实现(基于链表的实现)

概念：

无向图邻接矩阵：

  1. 无向图的邻接矩阵是对称的。在邻接列表表示形式中, 如果 (i, j) 是边, 则顶点 j 在顶点 i 列表中, 顶点 i 在顶点 j 列表中。

有向图邻接矩阵：

  1. 在邻接列表中，第i个边列表表示从顶点i开始的所有边。
  2. 在逆邻接列表中，第i个列表中的所有边都以顶点i结束。

代码实现：
 

 

两种实现方式比较：

如果图形是稀疏的, 并且边缘不多, 则邻接列表可能比邻接矩阵更具有空间效率。

如果图形是密集的, 并且边缘的数量是 O(N2), 那么邻接矩阵可能会更有效的空间。

空间复杂度：

矩阵形式：O(V^2)

import java.util.LinkedList;
import java.util.Queue;

import ds.sequence.SeqList;

public class GraphLink<Type> {
	private static int SIZE=10; 
	private SeqList<VetexNode<Type>> graph;
	private int currente;
	public GraphLink() {
		this.graph=new SeqList<>(SIZE);
		this.currente=0;
	}
	public boolean isEmpty() {
		return this.graph.size()==0;
	}
	public void makeEmpty() {
		this.graph.makeEmpty();
	}
	 
	public int sizev() {
		return this.graph.size();
	}
	public int sizee() {
		return this.currente;
	}
	public void addv(Type data) {
		graph.add(this.graph.size(), new VetexNode<>(data));
	}
	public void adde(Type datav,Type datae) {
		int resv=find(datav);
		int rese=find(datae);
		if(resv==-1) {
			addv(datav);
		}
		if(rese==-1) {
			addv(datae);
		}
		if(resv!=-1 && rese!=-1) {
			EdgeNode v=graph.get(find(datav)).nodev;
			if(v==null) {
				graph.get(find(datav)).nodev=new EdgeNode(rese);
			}else {
				while(v.nodee!=null) {
					v=v.nodee;
				}
				v.nodee=new EdgeNode(rese);
			}
			
			EdgeNode v2=graph.get(find(datae)).nodev;
			if(v2==null) {
				graph.get(find(datae)).nodev=new EdgeNode(resv);
			}else {
				while(v2.nodee!=null) {
					v2=v2.nodee;
				}
				v2.nodee=new EdgeNode(resv);
			}
			this.currente++;
		}
	}
	public void bfs() {  //广度遍历
		boolean [] visited = new boolean[graph.size()];   //需要另开辟一个数组，若每一个顶点都保存一个isvisited的话，由于每个节点地址不同，依旧会重复输出。
		for(int i=0;i<visited.length;i++) {
			visited[i]=false;
		}
		Queue<Integer> q=new LinkedList<>();
		q.add(0);
		System.out.print(graph.get(0).data+" ");
		visited[0]=true;
		while(!q.isEmpty()) {
			int res=q.poll();
			EdgeNode v=this.graph.get(res).nodev;
			while(v!=null) {
				if(!visited[v.dest]) {
					q.add(v.dest);
					visited[v.dest]=true;
					System.out.print(graph.get(v.dest).data+" ");
				}
				v=v.nodee;
			}
			
		}
		System.out.println();
		
	}
	
	//输出连通分量   
	public void components() {
		//类似于深度遍历，只不过得把所有的额顶点全部遍历完成
		System.out.println("略");
	}
	
	public int find(Type data) {
		for( int i=0;i<this.graph.size();i++) {
			if(data.equals(this.graph.get(i).data)) {
				return i;
			}
		}
		return -1;
	}
}
class EdgeNode{
	public int dest;
	public int weight;
	public EdgeNode nodee;
	public EdgeNode() {
		this.nodee=null;
	}
	public EdgeNode(int dest) {
		this.dest=dest;
	}
	public EdgeNode(int dest,int weight) {
		this.dest=dest;
		this.weight=weight;
		this.nodee=null;
	}
	public EdgeNode(int dest, int weight, EdgeNode node) {
		this.dest = dest;
		this.weight = weight;
		this.nodee = node;
	}
	
}
class VetexNode<Type>{
	public Type data;
	public EdgeNode nodev;
	public VetexNode() {
		this.data=null;
		this.nodev=null;
	}
	public VetexNode(Type data) {
		this.data=data;
		this.nodev=null;
	}
	public VetexNode(Type data, EdgeNode nodev) {
		this.data = data;
		this.nodev = nodev;
	}
	
}
class TestGraphLink{
	public static void main(String args[]) {
		GraphLink<Character> graph=new GraphLink<>();
		graph.addv('A');
        graph.addv('B');
        graph.addv('C');
        graph.addv('D');
        graph.addv('E');
        graph.adde('B', 'C');
        graph.adde('A', 'B');
        graph.adde('C', 'D');
        graph.adde('B', 'E');
        graph.adde('C', 'E');
        graph.adde('A', 'C');
        System.out.println("共有"+graph.sizee()+"条路径");
         graph.bfs();
	}
}

邻接表形式：O(V+N)

时间复杂度：


 

临界多表

无向图的邻接多表

在无向图的邻接多重表中，每一条边被一个边节点表示。所以遍历图就变得很遍历，而顶点列表是顺序列表。每个节点有两个成员。数据存储有关顶点的信息，从该顶点到第一条边的第一个输出点

结构如下：

eg:

 

有向图的临界多表：

path1：指向与此顶点具有相同源的下一个顶点。
path2：指向与此顶点具有相同目标的下一个顶点。

由节点表示的每个顶点。它是边内列表和边外列表的头
member：存储有关此顶点的信息。
Firstin：指向此顶点的第一个边端点
Firstout：指出此顶点的第一个边端点

eg:

 

Java数据结构之图
weixin_44270248的博客
05-14 812
基本概念 图是一种数据元素间具有“多对多”关系的非线性数据结构，由顶点集V和边集E组成，记作G=(V,E)。 无向边 e=(u,v)：表示顶点u到顶点v的一条无向边，简称边，其中(u,v)=(v,u)。 有向边 e=<u,v>：表示顶点u到顶点v的一条有向边，也叫弧，其中u叫始点或弧尾，v叫终点或弧头，<u,v>!=<v,u>。 零图：指E为空集的图，即图中只...
Java实现数据结构---图
最新发布
coding is an art
05-29 1939
图（Graph）一种比线性表和树更加复杂的结构。在图形结构中，顶点（vertex）之间的关系是任意的，途中任意两个顶点之间都有可能关联。
Java数据结构-图
qq_51938362的博客
10-16 3202
Java图
Java数据结构：图
Just For Learning
07-28 521
在写图算法题目时候，题目有各种各样的方式表现成一个图，这种数据结构记录用java的对象封装成一个实现类，在以后调用时直接用。
30.图
weixin_43719015的博客
03-11 309
问题：为什么要有图？ 前面我们学了线性表(一对一)和树(一对多) 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要 表示多对多的关系时， 这里我们就用到了 图 图的举例说明： 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图： 图的常用概念 顶点(verte...
final-graph:Java图形数据结构和GUI
07-11
描述中提到，"图数据结构在Java中的实现"意味着这个项目是关于用Java编程语言构建图的，这可能包括使用类、接口以及可能的数据结构如数组、链表等来表示节点和边。开发者可能已经实现了常见的图操作，比如添加和删除...
Java图数据结构
10-12
Java图数据结构
Java常见数据结构面试题（带答案）
08-29
"Java常见数据结构面试题（带答案）" 以下是对Java常见数据结构面试题的知识点总结： 栈和队列 * 栈和队列的共同特点是只允许在端点处插入和删除元素。 * 栈通常采用的两种存储结构是线性存储结构和链表存储结构...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
JAVA版数据结构.pdf
09-30
文中提到了数据结构（Data Structures）和Java语言的结合，这表明文档可能涉及数据结构在Java中的实现方式，包括基本的结构如数组、链表、栈、队列、树和图等，以及它们的特性、操作方法和应用场景。 2. Java中的...
图解数据结构--使用Java
04-28
全书内容浅显易懂，利用大量且丰富的图示与范例， 详解复杂的抽象理论，从最基本的数据结构概念开始 说明，再以Java工具加以诠释阵列结构、堆栈、链表 、队列、排序、查找等重要的概念，引领读者抓住重 点轻松进入数据结构的学习领域
Java数据结构--图
！不将就的博客
02-16 551
图 一、概述 图是一种数据结构，其中节点可以具有零个或多个相邻元素。两个节点之间的连接称为边，节点也可也以称为顶点 1. 图的常用概念 2. 图的表示方式 2.1 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是row和col表示的1……n个点 2.2 邻接表 邻接矩阵需要为每个顶点分配n个边的空间，很多边都不会存在，会造成空间的浪费 邻接表的实现只关心存在...
java数据结构--图
分享技术，享受生活
08-15 8597
1.    建立图的顶点 package com.jzm.Graph; public class GraphNode { public GraphNode link; public int info; }   2.  建立图的前驱和后继点 pack
java数据结构之图
Joy_Dang的博客
08-20 644
图是一种很复杂的数据结构，为了描述图创造了邻接矩阵的方式来描述它，图和树不一样，构建图，首先必须要有节点，然而树的根节点可以为空，构建图需要先将图描述起来 1.图的节点个数 2.图的节点矩阵 3.图的邻接矩阵 构建一个图 /* * 1.图的构成(顶点数量，顶点数组，顶点的邻接矩阵) * 2.图的遍历 * 深度优先遍历和广度优先遍历 * 深度优先算法：类似于树的前序遍历，一个布尔...
Java-数据结构之图
weixin_48370579的博客
04-04 111
1. 概述 是由一组顶点和一组边组成的数据结构 图-专业术语： 顶点：是图的基本单元也就是下图中的 A,B.C,D,E 相邻顶点：由一条边链接在一起的顶点 度:一个顶点包含相邻顶点的个数 权重：顶点与顶点在连接边上的数值 遍历图的两个算法： 1.广度优先搜索 2.深度优选搜索 无论哪种算法，结果不一定是唯一的，取决于你第一个遍历的是谁 ...
java数据结构导图
悦分享
06-23 471
java数据结构导图 数据结构思维图 线性数据结构 -数组 数组的概念就是把数据码成一排进行存放，数组中存放的元素类型必须一。 因为数组中的元素都是一个一个挨着排放的，所以可以给数组中的元素进行编号，从0开始的。 数组只是代存放元素的空间，数组的容量为N，最后的元素的索引为N-1，可以非常快速的直接访问第i个元素是谁。 -队列 是一种线性表 优先队列的底层是堆，不是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值