图邻接表实现-C++

已于 2022-07-02 19:22:18 修改
阅读量432 收藏 1
点赞数
文章标签： c++ 算法 图论
于 2022-07-01 11:24:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52564351/article/details/125555418
版权 
namespace Graph
{
	enum GraphKind { DG, DN, UDG, UDN };//图的种类，分别为有向图，有向网，无向图，无向网（带权图称为网）
	class ALGraph
	{
	private:
		struct ArcNode
		{
			int adjvex; //邻接顶点编号
			ArcNode* nextArc; //对应顶点的下一条边
			int weight;//边的权值
			string info;//边的信息
			explicit ArcNode(int adj, ArcNode* nexta = nullptr, int w = 1, const string& inf = string{}) :
				adjvex(adj), nextArc(nexta), weight(w), info(inf) {}
		};
		struct Vnode//顶点表
		{
			string data;//顶点信息
			ArcNode* firstArc; //指向顶点对应边表的第一个结点
		};
		static const int MAX_VERTEX_NUM = 1000; //图的最大顶点数

		Vnode vertices[MAX_VERTEX_NUM]; //顶点表
		int vexnum, arcnum; //分别为图的顶点数和边数
		GraphKind kind; //图的种类

		bool visited[MAX_VERTEX_NUM];
		deque<int> que;
	public:
		explicit ALGraph(int vn = 0, int an = 0, GraphKind k = DG) : //初始化图，提供顶点数，边数和图的种类
			vexnum(vn), arcnum(an), kind(k) 
		{
			for (int i = 0; i < MAX_VERTEX_NUM; i++)//顶点表的指针结点初始化为nullptr
			{
				vertices[i].firstArc = nullptr;
			}
		}

		~ALGraph()//析构函数
		{
			for (int i = 0; i < vexnum; i++) //删除每个顶点对应的边链表。
			{
				ArcNode* deleteArc, *p = vertices[i].firstArc;
				while (p != nullptr)
				{
					deleteArc = p;
					p = p->nextArc;
					delete deleteArc;
				}
			}
		}

		const string& getVex(int n) //求编号为n的顶点的信息，如A/B/C编号为0，1， 2， 则编号为1的顶点返回B
		{
			if (n < 0 || n >= vexnum)
			{
				throw UnderflowException{};
			}
			return vertices[n].data;
		}

		int locateVex(const string& s)
		{
			int ret = -1;
			for (int i = 0; i < vexnum; i++)
			{
				if (vertices[i].data == s)
				{
					ret = i;
					break;
				}
			}
			return ret;
		}

		void putVex(int n, const string& value)//修改顶点编号为n的值
		{
			if (n < 0 || n >= vexnum)
			{
				throw UnderflowException{};
			}
			vertices[n].data = value;
		}

		void insertVex(const string& s)//添加顶点
		{
			if (vexnum > MAX_VERTEX_NUM)
			{
				throw UnderflowException{};
			}
			vertices[vexnum++].data = s;
		}

		void deleteVex(const string& s) //删除顶点
		{
			int k = locateVex(s);
			if (k < 0)
			{
				return;
			}
			for (int i = k + 1; i < vexnum; i++) //调整顶点表
			{
				vertices[i - 1] = vertices[i];
			}
			vexnum--;
			ArcNode* pre = nullptr, * cur = nullptr, * deleteArc = nullptr;
			for (int i = 0; i < vexnum; i++) //对于每个顶点的边表：删除边表中adjvex = k的边，如果边的adjvex > k，将其自减1
			{
				for (cur = vertices[i].firstArc; cur != nullptr;)
				{
					if (cur->adjvex == k)
					{
						deleteArc = cur;
						cur = cur->nextArc;
						if (cur == vertices[i].firstArc)
						{
							vertices[i].firstArc = cur;
						}
						else
						{
							pre->nextArc = cur;
						}
						delete deleteArc;
					}
					else
					{
						if (cur->adjvex > k)
						{
							cur->adjvex -= 1;
						}
						pre = cur;
						cur = cur->nextArc;
					}
				}
			}


		}

		void insertArc(const string& v1, const string& v2, int weight = 1, const string& inf = string{})
		{
			int n1 = locateVex(v1), n2 = locateVex(v2);
			bool flag;
			if (n1 >= 0 && n2 >= 0 && n1 != n2)
			{
				flag = true;
				for (ArcNode* temp = vertices[n1].firstArc; temp != nullptr; temp = temp->nextArc)
				{
					if (temp->adjvex == n2)
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					ArcNode* newArc = new ArcNode(n2, vertices[n1].firstArc, weight, inf);
					vertices[n1].firstArc = newArc;
					if (kind == UDG || kind == UDN)
					{
						ArcNode* copyArc = new ArcNode(n1, vertices[n2].firstArc, weight, inf);
						vertices[n2].firstArc = copyArc;
					}
					arcnum++;
				}
			}
		}

		void deleteArc(const string& v1, const string& v2)
		{
			int n1 = locateVex(v1), n2 = locateVex(v2);
			bool flag;
			ArcNode* pre = nullptr, *cur = nullptr, *deleteArc = nullptr;
			if (n1 >= 0 && n2 >= 0 && n1 != n2)
			{
				flag = false; //判断是否删除了边
				cur = vertices[n1].firstArc;
				while (cur != nullptr)
				{
					if (cur->adjvex == n2) //存在这条边
					{
						flag = true;
						deleteArc = cur;
						if (cur == vertices[n1].firstArc)
						{
							vertices[n1].firstArc = cur->nextArc;
						}
						else
						{
							pre->nextArc = cur->nextArc;
						}
						delete deleteArc;

						if (kind == UDG || kind == UDN) //如果是无向图/网，则要额外删除一条边
						{
							cur = vertices[n2].firstArc;
							while (cur != nullptr)
							{
								if (cur->adjvex == n1)
								{
									deleteArc = cur;
									if (cur == vertices[n2].firstArc)
									{
										vertices[n2].firstArc = cur->nextArc;
									}
									else
									{
										pre->nextArc = cur->nextArc;
									}
									delete deleteArc;
								}
								else
								{
									pre = cur;
									cur = cur->nextArc;
								}
							}
						}

						break;
					}
					else
					{
						pre = cur;
						cur = cur->nextArc;
					}
				}
				if (flag)
				{
					arcnum--;
				}
			}
		}

		void createGraph()
		{
			cout << "Enter vertex information:\n";
			for (int i = 0; i < vexnum; i++)//输入顶点表信息，如A/B/C/D
			{
				cout << "vertex " << i << ": ";
				getline(cin, vertices[i].data);
			}
			int containInfo;//用于判断是否要额外提供边的相关信息
			cout << "Whether contain information in arcs(yes 1, no 0): ";
			(cin >> containInfo).get();
			switch (kind)
			{
			case DG: createDG(containInfo); break;
			case DN: createDN(containInfo); break;
			case UDG: createUDG(containInfo); break;
			case UDN: createUDN(containInfo); break;
			}
		}

		void createDG(int cInfo) //生成有向图
		{
			
			string v1, v2, arcInfo = "";
			for (int i = 0; i < arcnum; )
			{
				cout << "enter arc " << i << " <v1,v2>\n";
				cout << "v1: ";
				getline(cin, v1);
				cout << "v2: ";
				getline(cin, v2);
				int n1 = locateVex(v1), n2 = locateVex(v2);
				bool flag; //判断需要添加的边是否已经在邻接表中
				if (n1 != -1 && n2 != -1 && n1 != n2) //边有效
				{
					flag = true;
					for (ArcNode* p = vertices[n1].firstArc; p != nullptr; p = p->nextArc) //确保输入的边不重复
					{
						if (p->adjvex == n2)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						i++;
						if (cInfo)
						{
							cout << "info: ";
							getline(cin, arcInfo);
						}
						ArcNode* newArc = new ArcNode(n2, vertices[n1].firstArc, 1, arcInfo);
						vertices[n1].firstArc = newArc;
					}
				}
			}
		}

		void createDN(int cInfo) //生成有向网
		{

			string v1, v2, arcInfo = "";
			int weight;
			for (int i = 0; i < arcnum; )
			{
				cout << "enter arc " << i << " <v1,v2> and its weight\n";
				cout << "v1: ";
				getline(cin, v1);
				cout << "v2: ";
				getline(cin, v2);
				int n1 = locateVex(v1), n2 = locateVex(v2);
				bool flag;
				if (n1 != -1 && n2 != -1 && n1 != n2)
				{
					flag = true;
					for (ArcNode* p = vertices[n1].firstArc; p != nullptr; p = p->nextArc) //确保输入的边不重复
					{
						if (p->adjvex == n2)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						i++;
						cout << "weight: ";
						(cin >> weight).get();
						if (cInfo)
						{
							cout << "info: ";
							getline(cin, arcInfo);
						}
						ArcNode* newArc = new ArcNode(n2, vertices[n1].firstArc, weight, arcInfo);
						vertices[n1].firstArc = newArc;
					}
				}
			}
		}

		void createUDG(int cInfo) //生成有向图
		{

			string v1, v2, arcInfo = "";
			for (int i = 0; i < arcnum; )
			{
				cout << "enter arc " << i << " <v1,v2>\n";
				cout << "v1: ";
				getline(cin, v1);
				cout << "v2: ";
				getline(cin, v2);
				int n1 = locateVex(v1), n2 = locateVex(v2);
				bool flag;
				if (n1 != -1 && n2 != -1 && n1 != n2) //边有效
				{
					flag = true;
					for (ArcNode* p = vertices[n1].firstArc; p != nullptr; p = p->nextArc) //确保输入的边不重复
					{
						if (p->adjvex == n2)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						i++;
						if (cInfo)
						{
							cout << "info: ";
							getline(cin, arcInfo);
						}
						ArcNode* newArc1 = new ArcNode(n2, vertices[n1].firstArc, 1, arcInfo),
							* newArc2 = new ArcNode(n1, vertices[n2].firstArc, 1, arcInfo);
						vertices[n1].firstArc = newArc1;
						vertices[n2].firstArc = newArc2;
					}
				}
			}
		}

		void createUDN(int cInfo) //生成有向网
		{

			string v1, v2, arcInfo = "";
			int weight;
			for (int i = 0; i < arcnum; )
			{
				cout << "enter arc " << i << " <v1,v2> and its weight\n";
				cout << "v1: ";
				getline(cin, v1);
				cout << "v2: ";
				getline(cin, v2);
				int n1 = locateVex(v1), n2 = locateVex(v2);
				bool flag;
				if (n1 != -1 && n2 != -1 && n1 != n2)
				{
					flag = true;
					for (ArcNode* p = vertices[n1].firstArc; p != nullptr; p = p->nextArc) //确保输入的边不重复
					{
						if (p->adjvex == n2)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						i++;
						cout << "weight: ";
						(cin >> weight).get();
						if (cInfo)
						{
							cout << "info: ";
							getline(cin, arcInfo);
						}
						ArcNode* newArc1 = new ArcNode(n2, vertices[n1].firstArc, weight, arcInfo),
							* newArc2 = new ArcNode(n1, vertices[n2].firstArc, weight, arcInfo);
						vertices[n1].firstArc = newArc1;
						vertices[n2].firstArc = newArc2;
					}
				}
			}
		}

		const ArcNode* firstNeighbor(int v) const
		{
			if (v < 0 || v > arcnum)
			{
				throw UnderflowException{};
			}
			return vertices[v].firstArc;
		}

		void bfsTraverse()
		{
			cout << "\nBreadth first serach :\n";
			for (int i = 0; i < vexnum; i++)
			{
				visited[i] = false;
			}
			que.clear();
			for (int i = 0; i < vexnum; i++)
			{
				if (!visited[i])
				{
					BFS(i);
				}
			}
		}
		void BFS(int v)
		{
			visited[v] = true;
			que.push_back(v);
			while (!que.empty())
			{
				v = que.front();
				que.pop_front();
				cout << vertices[v].data << endl;
				int w;
				for (const ArcNode* temp = firstNeighbor(v); temp != nullptr; temp = temp->nextArc)
				{
					w = temp->adjvex;
					if (!visited[w])
					{
						visited[w] = true;
						que.push_back(w);
					}
				}
			}
		}

		void dfsTraverse()
		{
			cout << "\nDepth first search:\n";
			for (int i = 0; i < vexnum; i++)
			{
				visited[i] = false;
			}
			for (int i = 0; i < vexnum; i++)
			{
				if (!visited[i])
				{
					DFS(i);
				}
			}
		}
		void DFS(int v)
		{
			visited[v] = true;
			cout << vertices[v].data << endl;
			int w;
			for (const ArcNode* temp = firstNeighbor(v); temp != nullptr; temp = temp->nextArc)
			{
				w = temp->adjvex;
				if (!visited[w])
				{
					DFS(w);
				}
			}
		}

		void shortestPath_dij(const string& s0)
		{
			int v;
			bool flag;//如果找不到最短距离时，退出查找最短路径的循环。
			vector<int> dist(vexnum, INT_MAX); //记录最短距离
			vector<int> path(vexnum); //用于记录最短路径
			int v0 = locateVex(s0); //找到顶点对应的编号
			if (v0 < 0) //顶点编号无效
			{
				throw UnderflowException{};
			}
			for (int i = 0; i < vexnum; i++) //集合S初始为空
			{
				visited[i] = false;
			}
			dist[v0] = 0; //v0到v0的距离为0，所以循环开始选择顶点v0
			for (int i = 0; i < vexnum; i++)
			{
				flag = false;
				int min = INT_MAX;
				int w;
				for (w = 0; w < vexnum; ++w)//选择源点通过集合S到集合V - S中每个的点最短路径Dk（k∈V-S）（简称最短距离集合）
				{
					if (!visited[w])//查找min{Dk|k∈V-S}
					{
						if (dist[w] < min)
						{
							v = w;
							min = dist[w];
							flag = true;
						}
					}
				}
				if (flag)//如果可以找到最小的Dk则继续循环
				{
					visited[v] = true; //假设最短路径为Dv，将v加入集合S
					for (const ArcNode* temp = firstNeighbor(v); temp != nullptr; temp = temp->nextArc) //更新最短距离集合
					{
						w = temp->adjvex;
						if (!visited[w] && (long(min) + temp->weight < dist[w]))
						{
							dist[w] = min + temp->weight;
							path[w] = v;//记录边的另一个顶点。用于追溯到源点。
						}
					}
				}
				else
				{
					break;
				}
			}
			vector<int> route; //用于记录最小距离的路径
			for (int i = 0; i < vexnum; i++)//输出最短距离
			{
				if (i != v0)
				{
					cout << "\nshortest path from " << vertices[v0].data << " to " << vertices[i].data << ":\n";
					cout << "Distance: ";
					cout << dist[i] << endl;
					cout << "Path: ";
					if (dist[i] < INT_MAX) //假设有最短路径
					{
						route.clear();
						int k = i;
						while (k != v0)//追溯到v0
						{
							route.push_back(k);
							k = path[k];
						}
						route.push_back(v0);
						reverse(begin(route), end(route));//由于路径是反序排列，所以需要反转。
						for (int j = 0; j < route.size(); j++)//打印路径
						{
							cout << vertices[route[j]].data << " ";
						}
					}
					cout << endl;
				}
			}
		}



	};


}
Kriti Chen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++实现有向图的邻接表表示
12-20
本文实例为大家分享了C++有向图的邻接表表示，供大家参考，具体内容如下 一、思路： 有向图的插入有向边、删除边、删除顶点和无向图的有区别。其他的和无向图的类似。 1.插入有向边 只需要插入边就行，不需要插入...
图的存储及基本操作总结（邻接矩阵、邻接表）及C/C++代码实现
z135733的博客
04-22 4274
图是一种比较复杂的数据结构，每个结点之间可以有多种关系。所以，一个图可以呈现出千奇百怪的形式。对于不同的形式的图，我们可以用不同的存储方式来进行存储。对于边比较少而结点很多的图，我们需要把更多的存储空间用于存放顶点的信息，如果两个顶点之间不存在边，那么就不需要花费存储空间来说明这个地方没有边。对于边比较多而顶点相对没那么多的图，在每一个顶点之间，都很有可能存在边，如果每一条边都单独考虑，会显得比较繁琐。对于插入和删除边的操作做的比较多的图。
C++图的建立---邻接矩阵-----邻接表
m0_63064861的博客
11-09 4990
C++图的建立---邻接矩阵-----邻接表
数据结构之图（邻接表实现）（C++）
碣石观海的博客
07-17 2万+
一、图的邻接表实现 1.实现了以顶点顺序表、边链表为存储结构的邻接表； 2.实现了图的创建（有向/无向/图/网）、边的增删操作、深度优先递归/非递归遍历、广度优先遍历的算法； 3.采用顶点对象列表、边（弧）对象列表的方式，对图的创建进行初始化；引用 "ObjArrayList.h"头文件，头文件可参看之前博文“数据结构之顺序列表（支持对象元素）”代码； 4.深度优先遍历分别采用递归/非递归...
C++实现图—邻接矩阵，邻接表，深度遍历，广度遍历
终为nullptr
05-16 3559
图的两种实现方式和两种遍历方式，邻接矩阵和邻接表，深度遍历和广度遍历！
C++实现的邻接表
二哈
06-17 9173
1. 在学习图的存储方式中，邻接矩阵和邻接表是两种比较常用的存储图的方式，下面使用的是C语言实现的邻接表 2. 具体的实现过程如下： ① 首先使用结构体声明图的结构体，图中顶点的结构体，以及指向下一条边的结构体，这些可以参照严蔚敏版的数据结构来写出具体的数据结构： typedef struct ArcNode{ int adjvex;//该边所指向的节点的位置 struct ArcN...
数据结构与算法实验（C++）：图的邻接表实验-代码
最新发布
01-18
1）熟练掌握图的邻接表存储结构的实现； 2）熟练掌握基于邻接表的图的基本操作算法实现； 3）灵活使用有向图来解决具体的问题。 （2）实验内容： 1）定义有向图的邻接表类，封装图的基本操作算法，包括： a.创建、...
C++实现有向图邻接表的构建
08-19
C++实现有向图邻接表的构建 本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是...
图的邻接表实现.rar
05-25
在实际应用中，使用邻接表实现的图可以有效地进行深度优先搜索（DFS）和广度优先搜索（BFS），并支持多种图算法，如最短路径计算（Dijkstra算法或Floyd-Warshall算法）、拓扑排序等。此外，由于类模板的使用，此实现...
C++数据结构之实现邻接表
08-19
图的邻接表实现 邻接表是一种基于链表的数据结构，以顶点顺序表和边链表为存储结构。该实现方式可以高效地存储图的结构信息，并且可以快速地访问某个顶点的邻接顶点。 主要特点 1. 实现了以顶点顺序表、边链表为...
邻接表来实现图的存储
09-01
采用邻接表来实现图的存储，并输入输出邻接表的信息，并用邻接表来实现图的广度优先遍历。
图的实现：邻接表
08-01
使用邻接表实现图结构，无向的、有向的、无权的和有权的都可支持。
图的邻接表c++表示
08-12
通过输入顶点数和边数，自动构造用邻接表表示的图，并显示。
数据结构C++使用邻接表实现图
Lei Gong's blog
01-20 1638
定义邻接表存储的图类。 [实验要求] （1）创建一个邻接表存储的图； （2）返回图中指定边的权值； （3）插入操作：向图中插入一个顶点，插入一条边； （4）删除操作：从图中删除一个顶点，删除一条边； （5）图的广度优先遍历； （6）基于迪杰斯特拉算法求最短路径。【选作】 [截图] 实验例图 邻接表 操作截图 [实现代码] 一共四个文件 ：AQueue.h、Graph_Li...
邻接表详解（C/C++）
热门推荐
莫浅子的博客
08-24 4万+
一、概念 二、分类 1）无向图的邻接表 2）有向图的邻接表（出弧） 3）有向图的逆邻接表（入弧） 三.步骤 四、代码
图的基本运算算法（基于邻接表）——C/C++
有人_295的博客
06-29 4381
一、概念 图（Graph）结构是一种非线性的数据结构，图在实际生活中有很多例子，比如交通运输网，地铁网络，社交网络，计算机中的状态执行（自动机）等等都可以抽象成图结构。图结构比树结构复杂的非线性结构。 图结构构成 1.顶点（vertex）：图中的数据元素。 2.边（edge）：图中连接这些顶点的线。 所有的顶点构成一个顶点集合，所有的边构成边的集合，一个完整的图结构就是由顶点集合和边集合组成。图...
图论基础： 邻接矩阵与邻接表（c++实现）
ylh的博客
01-14 1715
设G=(顶点，边)：G=(V,E)是一个图。其中V={v1,v2,…,vn} [1]。表示法相类似，是一种顺序分配和链式分配相结合的存储结构。临界矩阵的结构分为两部分：V和E集合，其中，V是顶点，E是边。邻接矩阵（Adjacency Matrix）是表示。邻接矩阵又分为有向图邻接矩阵和无向图邻接矩阵。邻接表，是一种链式存储结构，存储方法跟树的。（边或弧）的数据，这个。
c++数据结构：图（邻接表）
qq_45303986的博客
10-19 2292
想更容易的找到入度的话，可以构建逆邻接表：（指向反转）邻接表是图的一种链式结构。
C++ 图结构邻接表简单实现
chenxl929的博客
04-15 8531
参照严蔚敏老师的《数据结构》一书，第7章实现 图结构的邻接表实现方式 表节点： 邻接点域(adjvex),链域(nextarc),数据域(info)。 头结点： 顶点信息(data),链域(firstarc)。 其中，表头节点通常以顺序结构的形式存储，以便于随机访问任一顶点。 下面是具体的实现：#ifndef GRAPHMAT_H #define GRAPHMAT_H#include
C++用邻接表实现无向图
05-26
实现无向图的基本思路是使用邻接表来存储每个顶点的邻居节点。邻接表是指一个数组，每个数组元素对应一个顶点，数组元素的值是一个链表，链表中存储了与该顶点相邻的所有顶点。 下面是用 C++ 实现无向图的代码： `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值