JAVA数据结构基础--图的两种创建方式

最新推荐文章于 2022-11-08 21:30:27 发布
最新推荐文章于 2022-11-08 21:30:27 发布
阅读量953 收藏 10
点赞数 1
分类专栏： Java数据结构 文章标签： 数据结构 java 有向图 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45351128/article/details/108431417
版权

JAVA数据结构基础–图的两种创建方式

图的邻接矩阵表示在这里插入图片描述
如图示一个有向图转为矩阵表示的例子（矩阵中空格表示无穷大，即无路径到达）。矩阵的行表示起始点，列表示终止点。对角线元素表示自己到自己，全为0。
图左侧的权值（道路长度）为1的路径，由1出发，指向0。在矩阵中表示为Edge[1][0]=1；表示1到0路径长度为1
在这里插入图片描述

以下我分析的是无向图的矩阵表示代码，若改成有向图，改动插入边的函数即可。

完整代码

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

public class Graph {
	private String[] Vertex;// 存储顶点名字
	private int[][] Edge;// 存储边信息
	private int numOfVertex;// 顶点个数
	private int maxOfVertex;// 最大顶点个数
	private int MAX = Integer.MAX_VALUE / 2;//无穷大表示值

	public Graph(int maxOfVertex) {//构造函数
		numOfVertex = 0;
		this.maxOfVertex = maxOfVertex;
		Vertex = new String[maxOfVertex];
		Edge = new int[maxOfVertex][maxOfVertex];

		inti(maxOfVertex);
	}

	public void inti(int maxOfVertex) {//初始化
		maxOfVertex = this.maxOfVertex;
		for (int i = 0; i < maxOfVertex; i++) {
			for (int j = 0; j < maxOfVertex; j++) {
				if (i != j) {
					Edge[i][j] = MAX;
				} else {
					Edge[i][j] = 0;
				}
			}
		}
	}

	public int getNumOfVertex() {// 获取顶点个数
		return numOfVertex;
	}

	public boolean insertVertex(String name) {// 插入顶点
		if (numOfVertex >= maxOfVertex) {
			return false;
		}
		Vertex[numOfVertex++] = name;
		return true;
	}

	public boolean insertEdge(String v1, String v2, int weight) {// 插入边
		int v_1 = findByName(v1);
		int v_2 = findByName(v2);

		if (v_1 < 0 || v_2 < 0) {
			return false;
		}

		Edge[v_1][v_2] = weight;
		Edge[v_2][v_1] = weight;

		return true;
	}

	public int getWeight(int s, int e) {//获得权重，即道路长度
		return Edge[s][e];
	}

	public int findByName(String name) {// 通过名字查找下标
		for (int i = 0; i < numOfVertex; i++) {
			if (Vertex[i].equals(name)) {
				return i;
			}
		}
		return -1;
	}

	public boolean deleteVertex(String name) {// 删除顶点
		int v = findByName(name);

		if (v < 0) {
			return false;
		}

		Vertex[v] = Vertex[numOfVertex - 1];

		for (int i = 0; i < numOfVertex; i++) {
			Edge[v][i] = Edge[numOfVertex - 1][i];
			Edge[i][v] = Edge[i][numOfVertex - 1];
			Edge[numOfVertex - 1][i] = MAX;
			Edge[i][numOfVertex - 1] = MAX;
		}

		Vertex[--numOfVertex] = null;

		return true;
	}

	public boolean deleteEdge(String v1, String v2) {// 删除边
		int v_1 = findByName(v1);
		int v_2 = findByName(v2);

		if (v_1 < 0 || v_2 < 0) {
			return false;
		}

		Edge[v_1][v_2] = MAX;
		Edge[v_2][v_1] = MAX;

		return true;
	}

	public int getEdge(String v1, String v2) {//获取权重
		int v_1 = findByName(v1);
		int v_2 = findByName(v2);
		if (v_1 < 0 ||v_2 < 0) {
			return -1;
		}
		return Edge[v_1][v_2];
	}
}

函数解析

一、图类结构

public class Graph {
	private String[] Vertex;// 存储顶点名字
	private int[][] Edge;// 存储边信息
	private int numOfVertex;// 顶点个数
	private int maxOfVertex;// 最大顶点个数
	private int MAX = Integer.MAX_VALUE / 2;//无穷大表示值
	}

一、Vertex数组：存储图顶点的名字，下标与名字一 一对应；
二、Edge二维数组：图的表示矩阵，即上面图片中矩阵的实例；
三、maxOfVertex：添加顶点总和的最大值；
四、numOfVertex：当前已顶点的个数；
五、MAX：表示无穷大，代表两顶点不通。（这里取整数最大值的一半）；

二、初始化：


	public void inti(int maxOfVertex) {//初始化
		maxOfVertex = this.maxOfVertex;
		for (int i = 0; i < maxOfVertex; i++) {
			for (int j = 0; j < maxOfVertex; j++) {
				if (i != j) {
					Edge[i][j] = MAX;
				} else {
					Edge[i][j] = 0;
				}
			}
		}
	}

当i！=j时，Edge[i][j]=MAX;(在未添加边时，所有顶点都不通)
当i==j时，Edge[i][j]=0;（自己到自己距离为0）

三、插入顶点：

public boolean insertVertex(String name) {// 插入顶点
		if (numOfVertex >= maxOfVertex) {
			return false;
		}
		Vertex[numOfVertex++] = name;
		return true;
	}

一、 if (numOfVertex >= maxOfVertex)：判断当前已添加顶点是否达到最大值。

二、Vertex[numOfVertex++] = name：Vertex数组的第numOfVertex个存入该顶点名字。（该顶点名字与顶点下标存在关联）

四、通过顶点名字找下标：

	public int findByName(String name) {// 通过名字查找下标
		for (int i = 0; i < numOfVertex; i++) {
			if (Vertex[i].equals(name)) {
				return i;
			}
		}
		return -1;
	}

循环次数为已添加顶点个数，即每个顶点依次遍历寻找。
若Vertex数组中存储的顶点信息匹配，返回下标值。

五、插入边

	public boolean insertEdge(String v1, String v2, int weight) {// 插入边
		int v_1 = findByName(v1);
		int v_2 = findByName(v2);

		if (v_1 < 0 || v_2 < 0) {
			return false;
		}

		Edge[v_1][v_2] = weight;
		Edge[v_2][v_1] = weight;

		return true;
	}

一、 先找到俩顶点的下标。
二、if (v_1 < 0 || v_2 < 0)：若不存在两个顶点，返回false；
三、改变表示矩阵中的值。（这里是表示无向图，改变两处。有向图改变一处）
Edge[v_1][v_2] = weight;
Edge[v_2][v_1] = weight;

六、删除顶点：

public boolean deleteVertex(String name) {// 删除顶点
		int v = findByName(name);

		if (v < 0) {
			return false;
		}

		Vertex[v] = Vertex[numOfVertex - 1];

		for (int i = 0; i < numOfVertex; i++) {
			Edge[v][i] = Edge[numOfVertex - 1][i];
			Edge[i][v] = Edge[i][numOfVertex - 1];
			Edge[numOfVertex - 1][i] = MAX;
			Edge[i][numOfVertex - 1] = MAX;
		}

		Vertex[--numOfVertex] = null;

		return true;
	}

图例示范：
在这里插入图片描述
七、删除边

	public boolean deleteEdge(String v1, String v2) {// 删除边
		int v_1 = findByName(v1);
		int v_2 = findByName(v2);

		if (v_1 < 0 || v_2 < 0) {
			return false;
		}

		Edge[v_1][v_2] = MAX;
		Edge[v_2][v_1] = MAX;

		return true;
	}

一、先判断顶点是否存在
二、将表示矩阵中【v1到v2】和【v2到v1】的地方改为MAX。

图的邻接表表示：

在这里插入图片描述
链表存储可以只存出存在的边，节约了空间。

完整代码：

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

public class Graph {

	class Vertex {// 顶点
		protected String name;//顶点名

		Vertex(String N) {
			name = N;
		}
	}

	class Edge {// 边
		protected Vertex Start;// 起始边
		protected Vertex End;// 结束边
		private int weight;// 权重

		Edge(Vertex S, Vertex E, int W) {
			Start = S;
			End = E;
			weight = W;
		}

		protected int getWeight() {
			return weight;
		}
		
		protected Vertex getStart() {
			return Start;
		}
		
		protected Vertex getEnd() {
			return End;
		}
	}

	int maxSize;//最大顶点数
	int numVertex;//当前顶点个数
	int numEdge;//边个数
	Vertex vertex[]; //顶点信息集
	public LinkedList<Edge>[] Edges;//存放顶点相邻边链表的数组


	Graph(int maxSize) {//构造函数
		this.maxSize = maxSize;
		numVertex = 0;
		numEdge = 0;
		Edges = new LinkedList[maxSize+1];
		vertex = new Vertex[maxSize+1];
		for(int i=0;i<maxSize+1;i++){
			Edges[i]=new LinkedList();
		}
	}

	public boolean addEdge(String start, String end, int W) {//添加边
		if(findNum(start)<0||findNum(end)<0) {
			return false;
		}
		Vertex S = vertex[findNum(start)];
		Vertex E = vertex[findNum(end)];
		
		numEdge++;
		Edge edge = new Edge(S, E, W);
		Edges[findNum(S.name)].add(edge);
		return true;
	}

	public void addvertex(String name) {
		Vertex vertexs = new Vertex(name);
		vertex[numVertex] = vertexs;
		numVertex++;
	}

	public int findWeight(String v1, String v2) {
		int v_1 = findNum(v1);
		int v_2 = findNum(v2);
		if(v_1<0||v_2<0) {
			return -1;
		}
		for (int i = 0; i < Edges[v_1].size(); i++) {
			if (findNum(Edges[v_1].get(i).End.name) == v_2) {
				return Edges[v_1].get(i).getWeight();
			}
		}
		return Integer.MAX_VALUE/2;
	}
	
	private int findNum(String name) {
		for(int i=0;i<numVertex;i++) {
			if(name.equals(vertex[i].name)) {
				return i;
			}
		}
		return -1;
	}
	
	public boolean deleteVertex(String name) {
		if(numVertex >= maxSize) {
			return false;
		}
		int v = findNum(name);
		
		vertex[v] = vertex[--numVertex];
		vertex[numVertex] = vertex[maxSize];
		
		Edges[v] = Edges[numVertex];
		Edges[numVertex] = Edges[maxSize];
		
		
		return true;
	}
	
	public boolean deleteEdge(String v1,String v2) {
		int v_1 = findNum(v1);
		int v_2 = findNum(v2);
		int i=0;
		while(findNum(Edges[v_1].get(i).getEnd().name)!=v_2){
			i++;
		}
		Edges[v_1].remove(i);
		numEdge--;
		return true;
	}
	
	
}

代码解析

三个类，图类，边类，定点类。

	class Vertex {// 顶点类
		protected String name;//存储顶点名，
		//与矩阵表示不同，改为顶点类与顶点数组下标对应
		
		Vertex(String N) {//构造函数，赋值顶点名字
			name = N;
		}
	}

	class Edge {// 边类
		protected Vertex Start;// 起始边
		protected Vertex End;// 结束边
		private int weight;// 权重

		Edge(Vertex S, Vertex E, int W) {
			Start = S;//起始顶点
			End = E;//结束顶点
			weight = W;//权重
		}
	}



public class Graph {
	int maxSize;//最大顶点数
	int numVertex;//当前顶点个数
	int numEdge;//边个数
	Vertex vertex[]; //顶点信息集
	public LinkedList<Edge>[] Edges;//存放顶点相邻边链表的数组
	}

LinkedList[] Edges：
首先它是一个数组，存储链表。而每个链表存储的都是边。（详细看边的添加）

构造函数：

Graph(int maxSize) {//构造函数
		this.maxSize = maxSize;
		numVertex = 0;
		numEdge = 0;
		Edges = new LinkedList[maxSize+1];
		vertex = new Vertex[maxSize+1];
		for(int i=0;i<maxSize+1;i++){//省略这步会出现空指针异常
			Edges[i]=new LinkedList();
		}
	}

初始化为maxSize+1的原因是，在删除边和顶点的时候，将删除顶点赋值为最后一个空的数组即可。避免了直接复制null产生空指针的问题。

通过名字寻找顶点下标

	private int findNum(String name) {
		for(int i=0;i<numVertex;i++) {
			if(name.equals(vertex[i].name)) {//与顶点数组中name属性配对返回下标
				return i;
			}
		}
		return -1;
	}

添加顶点

	public void addvertex(String name) {
		Vertex vertexs = new Vertex(name);//new一个顶点对象
		vertex[numVertex] = vertexs;//将顶点集的最后一个未赋值的赋值为新建的对象
		numVertex++;//当前顶点个数加一
	}

添加边

	public boolean addEdge(String start, String end, int W) {//添加边
		if(findNum(start)<0||findNum(end)<0) {//判断顶点是否存在
			return false;
		}
		Vertex S = vertex[findNum(start)];//获取顶点信息
		Vertex E = vertex[findNum(end)];
		
		numEdge++;//边数+1
		Edge edge = new Edge(S, E, W);//new一个边对象
		Edges[findNum(S.name)].add(edge);
		return true;
	}

Edges[findNum(S.name)].add(edge)：
举个例子，0到1有条边，则为Edges[0].add(边对象);
即Edge下标对应起始顶点。Edge[1]存放所有以1为起始顶点的边。
Edge[]的是链表的数组，用add（）函数添加边对象。

删除边

	public boolean deleteVertex(String name) {
		if(numVertex >= maxSize) {
			return false;
		}
		int v = findNum(name);
		
		vertex[v] = vertex[--numVertex];//将最后一个存在的顶点移动至删除顶点位置
		vertex[numVertex] = vertex[maxSize];//将移动结点赋值为空
		
		Edges[v] = Edges[numVertex];//顶点与顶点数组下标对应，边集也是如此
		Edges[numVertex] = Edges[maxSize];
		
		
		return true;
	}

删除边

	public boolean deleteEdge(String v1,String v2) {
		int v_1 = findNum(v1);
		int v_2 = findNum(v2);
		int i=0;
		while(findNum(Edges[v_1].get(i).getEnd().name)!=v_2){
			i++;
		}
		Edges[v_1].remove(i);//找到此边，删除
		numEdge--;//边条数减一
		return true;
	}

一、findNum(Edges[v_1].get(i).getEnd().name：
得到以v1为起始点的边，并获取此边结束顶点的顶点名字。
二、若头匹配，尾巴不匹配，i++，继续匹配下一条以v1为起始点的边。
直到匹配成功，退出while循环，得到下标边对应索引后删除此边。

静静等花开
关注
专栏目录
Java 数据类型 -- Java 语言的 8 种基本数据类型、字符串与数组
栗筝i的博客
06-10 5023
篇文章我们将深入了解 Java 的数据类型，包括 Java 语言的 8 种基本数据类型、字符串与数组。这些数据类型是 Java 程序设计的基础，也是编写高效、可靠代码的关键。
Java创建图结构
m0_56158576的博客
10-16 656
使用邻接矩阵的形式创建 图 import java.util.ArrayList; import java.util.Arrays; public class Demo01 { //需要 arrayList 来存储我们的顶点 private ArrayList<String> vertexList; //这里顶点的数据结构是ArrayList 使用泛型进行了数据类型的规定 private int [][]edges;//二维数组实现我们的矩阵表示 存储图的对
java数据结构和算法——图的创建
小志的博客
10-29 625
一、示例要求 代码实现如下图结构 二、代码实现示例 1、创建图的类 package com.rf.springboot01.dataStructure.graph; import java.util.ArrayList; import java.util.Arrays; /** * @description: 定义一个图 类 * @author: xiaozhi * @create: 2020-10-27 21:58 */ public class Graph { private
图的基本介绍和创建方法（Java）
qq_41291067的博客
10-29 2554
图的基本介绍： 为什么要有图： 前面我们学了线性表和树 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时， 这里我们就用到了图 图的举例说明： 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V(vertex)是图G中顶点的集合，E(edge)是图G中边的集合。 图的常用...
Java图的建立
渣渣
02-15 2928
图在计算机中，是一种非常有用的数据结构，而本博文我们采用java来模拟图（无权图和带权图）。 从数学意义上说，树是图的一种。而在计算机中，图的应用方式与树不一样。图通常有一个固定的形状，由物理或抽象的问题所决定的。而在图中，节点可能代表任务，有向边则代表某个任务必须在另一个任务前完成。故而，图的形状取决于真是世界的具体情况。图的节点叫做顶点。 图的顶点的java： class Vertex
Java数据结构——图的创建
jwz934738949的博客
05-02 353
import java.util.ArrayList; import java.util.Arrays; public class Graph { private ArrayList<String> vertexList; //存储顶点集合 private int[][] edges; //存储邻接矩阵 private int edgesNum; ...
java基础教程----精华版
09-22
- **数据类型**：Java有两大类数据类型，即原始类型（primitives）和引用类型（references）。 - **运算符**：包括算术、比较、逻辑、位、赋值等运算符，用于进行各种计算和判断。 - **流程控制**：如if语句、...
day009 java基础进阶-定时器,数据结构.doc
08-19
- **数据结构的意义**：数据结构不仅用于存储数据，更重要的是提供了高效访问和操作数据的方式，是算法设计的基础。 - **常见数据结构**：数组是最基本的数据结构，用于存储固定数量的同类型元素。而栈和队列分别...
Java-Data-Structures：通过Java收集数据结构示例
02-05
7. **Java数据结构库**： Java标准库提供了多种内置数据结构，如ArrayList、LinkedList、HashSet、HashMap等。了解这些数据结构的特性以及它们在不同场景下的适用性是Java程序员的基本功。 通过这个“Java-Data-...
java源码结构-Data-Structures-and-Algorithms:Java中数据结构和不同算法的源代码
05-24
在Java编程语言中，数据结构和算法是两个非常重要的概念，它们构成了软件开发的基础。"Data-Structures-and-Algorithms"这个项目显然旨在提供一系列Java实现的数据结构和算法的源代码，供学习者参考和实践。下面将...
java 生成图片
11-11
java 根据配置文件,批量生成图片,
java实现图的创建与存储(邻接矩阵)
最新发布
Groot-lin的博客
11-08 672
java实现图的创建即存储(邻接矩阵)
Java实现图的存储和创建
闻风听雨的博客
07-26 1328
带权无向图 存储结构 存储结构选用邻接表。 当一个图为稀疏图时，使用邻接矩阵法显然要浪费大量的存储空间，而图的邻接表法结合了顺序存储和链式存储方法，大大减少了这种不必要的浪费。 当然，即使我们所处理的图不是稀疏图，邻接表法也是能够胜任的。 图、顶点以及边的代码定义 public class graph_t { //邻接表实现的带权无向图 private ArrayList<VNode> vertices; //邻接表 private int vexNum; //顶点
Python 每日一记249>>>Java实现图的创建
教练我想学编程
04-24 168
一、图的基本概念 关于什么是图，为什么要用图，图的要素是什么，创建图的方式，网上的资料很多，就不再多加叙述了，可见下面的视频链接： 图的基本概念及其创建思路 二、Java代码创建图 这里使用邻接矩阵的方法创建图，简单而言就是创建一个矩阵，这个矩阵的值0，1，分别表示顶点的连通状态，0表示不连通，1表示连通，注意行索引名称和列索引名称是假定的，java二维数组是没有行列名称索引的，只有数字索引，从...
java 数组 画图_Java数组
weixin_32823555的博客
02-16 420
例子：一个足球队有很多人，认识某个人的时候先是把他看作某某队的队员，然后再利用他们身上的编号去区分队员Java中是建议在类型后面加[]代表是数组int num[]:是C/C++语言风格的画图工具：ProcessOn数组就是一个对象，因为它是new出来的public class Demo3 {public static void main(String[] args) {int[] arrays =...
java生成结构图_147-图的创建图解和代码实现
weixin_39531582的博客
03-01 389
2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。 本课程针对上述问题，有针对性的进行了升级3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解4)系统多面的讲解了数据结构和算法, 除常用数...
java如何构建图_如何从传递边构建子图？
weixin_42385930的博客
02-16 148
我认为你最好的选择可能是使用subgraph()步骤，因为你通常可能提取边缘引发的子图，然后在该子图上执行一些Gremlin来引入可视化边缘并删除你不想要的东西 .我可以使用TinkerPop打包的现代玩具图表进行演示：gremlin> graph = TinkerFactory.createModern()==>tinkergraph[vertices:6 edges:6]greml...
Java实现基于邻接表的图的建立
Coder_py的博客
05-13 2127
Java实现基于邻接表的图的建立 图类： package graph; /** * * @author linziyu *基于构造好的矩阵进行图结构的建立 */ public class Graph { /*定义边节点*/ public class edgeNode { int ivex;//该边指向的顶点的位置 edgeNode nextNode; //指向下
Java数据结构之图
weixin_44270248的博客
05-14 769
基本概念 图是一种数据元素间具有“多对多”关系的非线性数据结构，由顶点集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为空集的图，即图中只...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值