邻接表实现图论的各个算法

最新推荐文章于 2024-07-28 11:38:06 发布
最新推荐文章于 2024-07-28 11:38:06 发布
阅读量641 收藏
点赞数
分类专栏： 数据结构-图论 文章标签： 图的邻接表表示法 最小生成树 单源最短路径 拓扑排序 深度宽度遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37393514/article/details/78022978
版权
本文通过邻接表详细讲解了图论中的深度宽度遍历、拓扑排序、单源最短路径Dijkstra算法及最小生成树Prim算法的实现。通过对比邻接表与邻接矩阵的构造和析构，强调了邻接表在存储和操作上的优势。
摘要由CSDN通过智能技术生成

/*在这个代码里面，我主要实现的利用邻接表来存储图论，定义了一个类，里面有一个私有的node **a;这个表示的是一维的指针数组，但是在邻接矩阵实现里面也有一个int *aa,这个是动态生成二维数组，注意两者的类的构造函数和析构函数的区别，是个重点！

主要实现算法：深度宽度遍历，拓扑排序，单源最短路径dijkstra，最小生成树（prim）等等

#include<iostream>
#include<queue>
using namespace std;
const int INF = 123123123;
enum resultcode{success,failure,notpresent,overflow,duplicate};
struct node{
	int adjvex;
	node *next;
	int w;
	node(){
		next = NULL;
	}
	node(int adj, int ww, node *ne)
	{
		next = ne;
		w = ww;
		adjvex = adj;
	}
};
class graph{
private:
	int n, e;
	node** a;
	void dfs(int v, bool *visited);
	void bfs(int v, bool *visited);
	void countindegree(int *indegree);
public:
	graph(int size);
	~graph();
	resultcode insert(int u, int v, int w);
	resultcode remove(int u, int v);
	bool exist(int u, int v);
	void bfs();
	void dfs();
	void toposort(int *order);
	bool toposort1(int *order);
	int prim(int k, int *nearest, int *lowcost);
	//void floyd(int **d, int **path);floyd是采用邻接矩阵的方法实现，这个难实现
	void dijsktra(int k, int *d, int *path);//书上dijskstra是采用邻接矩阵来实现的
};
graph::graph(int size)
{
	n = size;
	e = 0;
	a = new node*[n];
	for (int i = 0; i < n; i++)
	{
		a[i] = NULL;
	}
}
graph::~graph()
{
	node *p,*q;
	for (int i = 0; i < n; i++)
	{
		p = a[i];
		q = p;
		while (p)
		{
			p = p->next;
			delete q;
			q = p;
		}
	}
	delete[]a;
}
bool graph::exist(int u, int v)
{
	if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v)
		return false;
	node *p = a[u];
	while (p&&p->adjvex != v)
		p = p->next;
	if (!p)
		return false;
	else
		return true;
}
resultcode graph::insert(int u, int v, int w)
{
	if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v)
		return failure;
	if (exist(u, v))
		return duplicate;
	node *p = new node(v, w, a[u]);//头插法
	a[u] = p;
	e++;
	return success;
}
resultcode graph::remove(int u, int v){
	if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v)
		return failure;
	node *p = a[u];
	node *q = NULL;
	while (p&&p->adjvex != v)
	{
		q = p;
		p = p->next;
	}
	if (p == NULL)
		return notpresent;
	if (q)//非表头
	{
		q->next = p->next;
	}
	else
		a[u] = a[u]->next;
	delete p;
	e--;
	return success;
}
void graph::dfs(int v, bool *visited)
{
	visited[v] = true;
	cout << v << " ";
	for (node *p = a[v]; p; p = p->next)
	{
		if (!visited[p->adjvex])
			dfs(p->adjvex, visited);
	}
}
void graph::dfs(){
	bool *visited = new bool[n];
	for (int i = 0; i < n; i++)
	{
		visited[i] = false;
	}
	for (int i = 0; i < n; i++)
	{
		if (!visited[i])
			dfs(i, visited);
	}
	delete[]visited;
}
void graph::bfs(int v, bool *visited)
{
	visited[v] = true;
	cout << v << " ";
	queue<int> q;
	q.push(v);
	while (!q.empty())
	{
		int t = q.front();
		q.pop();
		for (node *p = a[t]; p; p = p->next)
		{
			if (!visited[p->adjvex]){
				visited[p->adjvex] = true;
				cout << p->adjvex << " ";
				q.push(p->adjvex);
			}
		}
	}
}
void graph::bfs(){
	bool *visited = new bool[n];
	for (int i = 0; i < n; i++)
	{
		visited[i] = false;
	}
	for (int i = 0; i < n; i++)
	{
		if (!visited[i])
			bfs(i, visited);
	}
	delete []visited;
}
void graph::countindegree(int *indegree)
{
	for (int i = 0; i < n; i++)
	{
		for (node *p = a[i]; p; p = p->next)
		{
			indegree[p->adjvex]++;
		}
	}
}
void graph::toposort(int *order)
{
	int *indegree = new int[n];
	for (int i = 0; i < n; i++)
		indegree[i] = 0;
	countindegree(indegree);
	int top = -1;
	for (int i = 0; i < n; i++)
	{
		if (indegree[i] == 0)
		{
			indegree[i] = top;
			top = i;
		}
	}
	for (int i = 0; i < n; i++)
	{
		if (top == -1)
		{
			cout << "存在环路" << endl;
			return;
		}
		int j = top;
		top = indegree[top];
		order[i] = j;
		cout << j << " ";
		for (node *p = a[j]; p; p = p->next)
		{
			int k = p->adjvex;
			indegree[k]--;
			if (!indegree[k])
			{
				indegree[k] = top;
				top = k;
			}
		}
	}
	delete[]indegree;
}
bool graph::toposort1(int *order)
{
	int *indegree = new int[n];
	for (int i = 0; i < n; i++)
		indegree[i] = 0;
	countindegree(indegree);
	queue<int> q;
	for (int i = 0; i < n; i++)
	{
		if (indegree[i] == 0)
			q.push(i);
	}
	int cnt = 0;
	while (!q.empty())
	{
		int t = q.front();
		q.pop();
		order[cnt++] = t;
		cout << t << " ";
		for (node *p = a[t]; p; p = p->next)
		{
			indegree[p->adjvex]--;
			if (indegree[p->adjvex] == 0)
				q.push(p->adjvex);
		}
	}
	delete[]indegree;
	if (cnt != n)
		return false;
	else
		return true;
}
int  graph::prim(int k, int *nearest, int *lowcost)
{
	int ans = 0;
	bool *mark = new bool[n];
	node *p;
	for (int i = 0; i < n; i++)
	{
		mark[i] = false;
		nearest[i] = -1;
		lowcost[i] = INF;
	}
	mark[k] = true;
	nearest[k] = k;
	lowcost[k] = 0;
	for (int i = 1; i < n; i++)
	{
		for (p = a[k]; p; p = p->next)
		{
			if (!mark[p->adjvex] && lowcost[p->adjvex]>p->w)
			{
				lowcost[p->adjvex] = p->w;
				nearest[p->adjvex] = k;
			}
		}
		int MIN = INF;
		for (int j = 0; j < n; j++)
		{
			if (!mark[j] && lowcost[j] < MIN)
			{
				MIN = lowcost[j];
				k = j;
			}
		}
		ans += MIN;
		mark[k] = true;
	}
	delete[]mark;
	return ans;
}
void graph::dijsktra(int k, int *d, int *path)
{
	bool *mark = new bool[n];
	for (int i = 0; i < n; i++)
	{
		d[i] = INF;
		path[i] = -1;
	}
	for (int i = 0; i < n; i++)
	{
		mark[i] = false;
		node *p = a[k];
		for (; p; p = p->next)
		{
			int j = p->adjvex;
			d[j] = p->w;
			path[j] = k;
		}
	}
	mark[k] = true;
	d[k] = 0;
	for (int i = 1; i < n; i++)
	{
		node *p = a[k];
		for (; p; p = p->next)
		{
			if (mark[p->adjvex] == false && d[p->adjvex]>d[k] + p->w)
			{
				d[p->adjvex] = d[k] + p->w;
				path[p->adjvex] = k;
			}
		}
		int MIN = INF;
		for (int j = 0; j < n; j++)
		{
			if (mark[j] == false && d[j] < MIN)
			{
				MIN = d[j];
				k = j;
			}
		}
		mark[k] = true;
	}
	delete[]mark;
}
int main()
{
	/*graph g(6);
	g.insert(0, 1, 6);//检查插入
	g.insert(0, 2, 1);//检查插入
	g.insert(0, 3, 5);
	g.insert(1, 0, 6);
	g.insert(1, 4, 3);
	g.insert(1, 2, 5);
	g.insert(2, 1, 5);
	g.insert(2, 3, 5);
	g.insert(2, 0, 1);
	g.insert(2, 4, 6);
	g.insert(2, 5, 4);
	g.insert(4, 1, 3);
	g.insert(4, 2, 6);
	g.insert(4, 5, 6);
	g.insert(3, 0, 5);
	g.insert(3, 2, 5);
	g.insert(3, 5, 2);
	g.insert(5, 4, 6);
	g.insert(5, 2, 4);
	g.insert(5, 3, 2);
	int *near = new int[6];
	int *low = new int[6];
	cout << g.prim(0, near, low) << endl;
	delete[]near;
	delete[]low;*/
	/*graph g(7);
	g.insert(0, 1, 1);//检查插入
	g.insert(3, 0, 4);
	g.insert(1, 3, 2);
	g.insert(1, 2, 9);
	g.insert(3, 2, 5);
	g.insert(4, 1, 3);
	g.insert(5, 4, 8);
	g.insert(5, 3, 3);
	g.insert(6, 5, 3);
	g.insert(6, 4, 6);*/
	/*graph g(9);
	g.insert(0, 7, 1);//检查插入
	g.insert(0, 2, 1);
	g.insert(1,4,3);
	g.insert(1, 3, 2);
	g.insert(1, 2, 9);
	g.insert(2, 3, 4);
	g.insert(3, 6, 5);
	g.insert(3, 5, 8);
	g.insert(4, 5, 3);
	g.insert(7, 8, 3);
	g.insert(8, 6, 3);*/
	/*if (g.del(1, 4))
	{
	cout << "成功删除" << endl;
	}
	else
	{
	cout << "删除失败" << endl;
	}//检查删除
	if (g.del(2, 0))
	{
	cout << "成功删除" << endl;
	}
	else
	{
	cout << "删除失败" << endl;
	}*/
	/*if (g.exist(6, 5))
	cout << "存在" << endl;
	else
	cout << "不存在" << endl;
	if (g.exist(2, 0))
	cout << "存在" << endl;
	else
	cout << "不存在" << endl;*/
	/*cout << "接下来是宽度遍历" << endl;
	g.bfs();
	cout << endl;
	cout << "接下来是深度遍历" << endl;
	g.dfs();
	cout << endl;
	//拓扑序列
	int *order = new int[9];
	cout << "拓扑序列" << endl;
	g.toposort(order);
	cout << endl;
	delete []order;*/
	graph g(6);
	g.insert(0, 1, 50);//检查插入
	g.insert(0, 2, 10);//检查插入
	g.insert(0, 4, 70);
	g.insert(1, 4, 10);
	g.insert(1, 2, 15);
	g.insert(2, 3, 15);
	g.insert(2, 0, 20);
	g.insert(4, 3, 30);
	g.insert(3, 1, 20);
	g.insert(3, 4, 35);
	g.insert(5, 3, 3);
	int *d = new int[6];
	int *path = new int[6];
	g.dijsktra(0, d, path);
	for (int i = 0; i < 6; i++)
	{
		cout << d[i] << endl;
	}
	system("pause");
	return 0;
}

*/

爱抠脚的coder
关注
专栏目录
图应用之最小生成树之邻接表实现kruskal算法(java实现)
klz
12-30 493
文章目录kruskal算法过程代码实现过程代码实现 kruskal算法过程 查找最小的权值边 判断生成树是否形成环 G = (V,E) 表示一个网，也可以写成 N = (V,E) U： 存放顶点的集合 T: 存放边的集合 最小生成树可能不指一个 第1步：找出最小的权值边(A,B)和(A,C)，二选一，将(A,C)加入T，T = {(A,B)} 第2步：找出最小的权值边(A,C)，将(A,C)加入T，T = {(A,B),(A,C)} 第3步：找出最小的权值边(B,D)，将(B,D)加入T
【算法笔记】图论 邻接表
Ronaldo7_ZYB的博客
12-24 1458
1.关于图论： 这篇博客主要写邻接表，邻接表的意义我在这里就不细说了，到时候直接看程序的注释就好。 2.田野上的环 题目描述 FJ 让他的N (1 c2). FJ要求奶牛们与1号奶牛相连.现在你要帮助FJ找出所有没有与1号奶牛相连的奶牛.这里的相连既可以是直接的,也可以是间接的(特别的,1号奶牛总是与自己相连).将没有与1号奶牛相连的奶牛的编号升序输出.如果你找不到
图的邻接表存储 c实现
This is bill的专属博客
12-26 1647
图的邻接表存储 c实2011-10-07 10:34 4047人阅读 评论(2) 收藏 举报 存储cstruct数据结构null编程   用到的数据结构是 一个是顶点表，包括顶点和指向下一个邻接点的指针 一个是边表， 数据结构跟顶点不同，存储的是顶点的序号，和指向下一个的指针 刚开始的时候把顶点表初始化，指针指向null。然后边表插入进来，是
图论之常用算法
最新发布
风间琉璃的博客
07-28 711
介绍图论中常用的相关算法
图论算法总结(邻接表描述)
rommel1的专栏
03-06 1263
<br />package ds; //图论算法 import java.util.LinkedList; import java.util.List; public class graph{ List<vertex> v=new LinkedList<vertex>(); int d[]=new int [8]; public void addvertex(int index){ v.add(new vertex(index, 0, false)); } public
图论：邻接表
JAN6055的博客
01-03 332
#include <bits/stdc++.h> using namespace std; //邻接表的存储 int head[10],ver[10],edge[10],net[10]; void add(int x,int y,int z){ static int tot=0; tot++; ver[tot]=y; edge[tot]=z; net[tot]=head[x]; head[x]=tot; } int main() { m.
图论之邻接表
咸鱼很渴的博客
12-24 4335
本文介绍了图的邻接表存储方法，使用邻接表存储图要稍微复杂一些，但能够提高空间利用率。本文给出了两种实现方法，一种是链式前向星，另一种是链表实现，链式前向星是利用数组来模拟链表，并且在最后给出了邻接表的一种打印方法。
tulunsuanfa.rar_图论_图论算法_图论算法实现_算法
09-20
**图论算法实现**涉及数据结构、递归、动态规划和贪心策略。在“图论算法集锦.pdf”中，作者提供了详细的代码示例，帮助读者理解每种算法的逻辑和工作原理。这些实现对于学习者来说是一份宝贵的资源，有助于他们将...
图论算法理论实现_图论及其_图论算法_图论_图论知识_
09-30
图论是数学的一个分支，主要研究点（顶点）与线（边）组成的结构，它在计算机科学中有着广泛的应用，特别是在...《图论算法理论实现及其应用》这本书无疑是一份宝贵的资源，它将帮助读者深入理解这一领域的核心内容。
linjiebiao.rar_dijkstra_dijkstra算法_邻接表_邻接表 dijkstra
09-23
在Dijkstra算法的实现中，邻接表是一种非常重要的数据结构。相较于邻接矩阵，邻接表在处理稀疏图（边的数量远小于顶点数量的平方）时，空间效率更高。邻接表由一系列链表或队列组成，每个链表或队列代表图中一个顶点...
图的邻接矩阵和邻接表实现
11-26
Dijkstra算法适用于没有负权边的图，可以配合邻接矩阵或邻接表实现。对于邻接矩阵，可以直接访问权重；对于邻接表，可以使用优先队列（如二叉堆）来快速找到最小距离的节点。 总结来说，邻接矩阵和邻接表是图的主要...
图的邻接矩阵实现 floyd算法 迪杰斯特拉算法
12-27
实现最小生成树 最短路径 floyd 广搜 深搜 迪杰斯特拉算法
图论——邻接表
LiuRenyou的博客
01-18 1189
文章目录图论——邻接表邻接表表示代码复杂度分析 图论——邻接表 邻接表表示 对于上图的邻接表如下 0：1->2 意思是顶点0保持着一个链表，链表里存放顶点0的邻接顶点 1：0->3 意思是顶点1保持着一个链表，链表里存放顶点1的邻接顶点 2：0->3 3：1->2 代码 public class AdjList { private int V;//顶点数 ...
图论 邻接表建图+dfs
横济沧海的博客
07-28 432
上一篇用的是邻接矩阵建图：点击打开链接 所以dfs(&G,0)结果为0 2 3 4 1 dfs(&G,1)结果为1 2 3 4 dfs(&G,2)结果为2 3 4 dfs(&G,3)结果为 3 4  dfs(&G,4)结果为4 #include #include #include #include using namespace std;
数据结构之图论（邻接表）
weixin_55850954的博客
11-25 729
数据结构之图论（邻接表） 这篇文章是对上一篇文章的补充，暂时还没有总结完毕，在阅读中如果对算法的用途有所疑问的，可参考上一篇：数据结构之图论（邻接矩阵） 文章还未总结完毕，后续会进一步补充和修改。 文章目录数据结构之图论（邻接表）图的创建拓扑排序无权最短路径DijkstraFloydDFSBellman_FordSPFA总结 图的创建 template<typename T> class Graph { private: struct Node { T value;//值 int
【图论】关于邻接表建图
Fograinの小窝
10-19 729
邻接表 作为一名现役Oier在做过无数图论题目和搜索题目之后，可以说是相当熟悉了，但是今天做的一道题，让我对于邻接表表示直接懵逼，原来在跑最短路的时候还是明白每个数组各自的作用的，然而一旦在其它题目中遇到就不会了，所以今天特意复习，并决定好好整理一下，以后别再懵逼了…
数据结构之图论之邻接表
xizi_ghq的博客
09-14 296
还是插入一段代码来解释邻接表的建立过程。 //自己建立一个邻接表 //边表结点 typedef struct { int adjvex;//该边的头结点 int weight;//权值 EdgeNode *next;//该边尾结点的下一条边 }EdgeNode; //顶点结点 typedef struct { int data;//顶点结点的数据 EdgeNode *f...
poj 3275 邻接表优化Floyd
NeighThorn的博客
07-11 1696
lalala
图论的存储之邻接表
毕宿五
07-23 422
稀疏图的的边没有那么多，为了节省空间我们使用邻接表去存储。这种法中每个节点i都有一条链表，里面保存着从i出发的所有边。对于无向图来说，每条边会在临接表出现两次。这里用数组实现临接表：首先给每条边编号，然后用first[u]保存结点u的第一条边的编号，next[e]表示编号为e的边的“下一条边”的编号。const int maxn=; //最大结点数 int n,m;
有向网邻接表实现与图论算法详解
《有向网及其邻接表存储表示 - 艾默生ups电源nx系列（30-200kva）》是一本深入讲解图论算法的书籍，由王桂平、王衍和任嘉辰编著，专为计算机科学特别是图论相关的课程设计，适合高等院校学生以及ACM/ICPC竞赛参与者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值