数据结构实验报告---图的邻接表及其基本算法

最新推荐文章于 2022-07-28 18:23:46 发布
最新推荐文章于 2022-07-28 18:23:46 发布
阅读量3.4k 收藏 35
点赞数 10
分类专栏： 算法 图 最小生成树 文章标签： 数据结构 算法 最短路径 Dijkstra 最小生成树 邻接表 深度 广度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luodeng_/article/details/107235544
版权
算法 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
图
1 篇文章 0 订阅
订阅专栏
最小生成树
1 篇文章 0 订阅
订阅专栏

图的邻接表及其基本算法

邻接表的建立

#include<iostream>
#include<algorithm>
using namespace std;
const int MAX = 20;
typedef char datatype;
//边表结点
struct ArcNode
{
	int adjvex;//结点下标
	int weight;//权重
	ArcNode* next;//下一个表结点
};
//头结点
struct VexNode
{
	datatype data;//头结点数据
	ArcNode* firstedge;//与该头结点相邻的第一条边
};
//邻接表图
typedef struct Graph
{
	int numVertexes;//顶点数
	int numEdges;//边数
	VexNode* vnode;//顶点表
}*GraphAdjList;//图指针
struct Path//存储起点到所有临边的权值
{
	int start;
	int end;
	int weight;
};
Path* myPath;//全局数组保存输入的值

创建邻接表图

有头插法和尾插法两种，这里注释了尾插法。
默认为无向图，可自行注释为有向图

//创建邻接表
void createGraph(GraphAdjList& g)
{
	g = new Graph;
	cout << "输入顶点数与边数：\n";
	cin >> g->numVertexes >> g->numEdges;
	myPath = new Path[g->numEdges];
	g->vnode = new VexNode[g->numVertexes];
	cout << "输入顶点数据：\n";
	for (int i = 0; i < g->numVertexes; i++)
	{
		cin >> g->vnode[i].data;
		g->vnode[i].firstedge = nullptr;
	}
	cout << "请输入每条边之间的顶点编号(顶点编号从0开始),以及该边的权重：\n";
	int start, end, weight;
	for (int i = 0; i < g->numEdges; i++)
	{
		cin >> start >> end >> weight;
		myPath[i].start = start;
		myPath[i].end = end;
		myPath[i].weight = weight;
		ArcNode* p = new ArcNode;//头插法
		p->adjvex = end;
		p->next = g->vnode[start].firstedge;
		p->weight = weight;
		g->vnode[start].firstedge = p;
		//无向图对称
		ArcNode* q = new ArcNode;
		q->adjvex = start;
		q->next = g->vnode[end].firstedge;
		q->weight = weight;
		g->vnode[end].firstedge = q;
		//if (start >= 0 && end >= 0)//尾插法
		//{
		//	ArcNode* h = g->vnode[start].firstedge;
		//	ArcNode* p = new ArcNode;
		//	p->adjvex = end;
		//	p->weight = weight;
		//	p->next = nullptr;
		//	if (!h)
		//	{
		//		g->vnode[start].firstedge = p;
		//	}
		//	else
		//	{
		//		while (h->next)//找到链表最后一个元素
		//		{
		//			h = h->next;
		//		}
		//		h->next = p;
		//	}
		//	//无向图对称
		//	ArcNode* hh = g->vnode[end].firstedge;
		//	ArcNode* q = new ArcNode;
		//	q->adjvex = start;
		//	q->weight = weight;
		//	q->next = nullptr;
		//	if (!hh)
		//	{
		//		g->vnode[end].firstedge = q;
		//	}
		//	else
		//	{
		//		while (hh->next)//找到链表最后一个元素
		//		{
		//			hh = hh->next;
		//		}
		//		hh->next = q;
		//	}
		//}
	}

}

DFS遍历

对于连通图，只需要第一个函数即可，第二个函数是为了解决非连通图

void DFS(GraphAdjList g, int* visited, int adjvex)
{
	if (!g)
		return;
	visited[adjvex] = 1;
	cout << g->vnode[adjvex].data<<" ";
	ArcNode* p = g->vnode[adjvex].firstedge;//获取当前顶点指针
	while (p)
	{
		if (!visited[p->adjvex])//未访问则递归
			DFS(g, visited, p->adjvex);
		p = p->next;//否则到下一条相邻路径
	}
}
void DFSGraphAdjList(GraphAdjList g)
{
	int* visited = new int[g->numVertexes];
	for (int i = 0; i < g->numVertexes; i++)//初始化
		visited[i] = 0;
	for (int i = 0; i < g->numVertexes; i++)//连通图与非连通图都能全部访问到
		if (!visited[i])
			DFS(g, visited, i);
}

BFS遍历

对于连通图，只需要第一个函数即可，第二个函数是为了解决非连通图

void BFS(GraphAdjList g, int* visited, int adjvex)
{
	if (!g)
		return;
	int queue[MAX], front = -1, rear = -1;//构造一个循环队列
	cout << g->vnode[adjvex].data<<" ";
	visited[adjvex] = 1;
	rear = (++rear) % MAX;//出队入队都先自加1取模数组最大值，充分利用空间
	queue[rear] = adjvex;
	while (front != rear)//队列不为空
	{
		front = (++front) % MAX;//出队保存
		int temp = queue[front];
		ArcNode* q = g->vnode[temp].firstedge;//获取当前顶点指针
		while (q)//非空时循环
		{
			if (!visited[q->adjvex])//如果未访问
			{
				visited[q->adjvex] = 1;//标记输出再入队
				cout << g->vnode[q->adjvex].data<<" ";
				rear = (++rear) % MAX;
				queue[rear] = q->adjvex;
			}
			q = q->next;//否则到下一条相邻路径
		}
	}
}
void BFSGraphAdjList(GraphAdjList g)
{
	int* visited = new int[g->numVertexes];
	for (int i = 0; i < g->numVertexes; i++)//初始化
		visited[i] = 0;
	for (int i = 0; i < g->numVertexes; i++)//连通图与非连通图都能全部访问到
		if (!visited[i])
			BFS(g, visited, i);
}

Prim最小生成树

void Prim(GraphAdjList g, int begin)
{
	Path* path = new Path[g->numVertexes];
	for (int i = 0; i < g->numVertexes; i++)
	{
		path[i].weight = 0x7fffffff;
	}
	ArcNode* p = g->vnode[begin].firstedge;
	while (p)//构建path数组
	{
		path[p->adjvex].start = begin;
		path[p->adjvex].end = p->adjvex;
		path[p->adjvex].weight = p->weight;
		p = p->next;
	}
	path[begin].weight = -1;//将起点置为-1表示已添加到集合
	int sum = 0;
	cout << "\n\nPrim最小生成树：\n";
	for (int i = 1; i < g->numVertexes; i++)
	{
		int min = 0x7fffffff;
		int index=0;
		for (int j = 0; j < g->numVertexes; j++)//找到权重最小边
			if (path[j].weight != -1)//如果未被添加到集合
				if (path[j].weight < min)
				{
					min = path[j].weight;
					index = j;
				}
		//输出最小权重边信息
		cout << g->vnode[path[index].start].data << "--->"
			<< g->vnode[path[index].end].data << " "
			<< path[index].weight << "\n";
		//将该边终点添加到集合
		sum += path[index].weight;
		path[index].weight = -1;
		//更新path数组
		ArcNode* q = g->vnode[path[index].end].firstedge;
		while (q)
		{
			if (path[q->adjvex].weight > q->weight)
			{
				path[q->adjvex].start = index;
				path[q->adjvex].end = q->adjvex;
				path[q->adjvex].weight = q->weight;
			}
			q = q->next;
		}
	}
	cout << "总权值：" << sum << endl;
}

Kruskal最小生成树

这里需要用到并查集
这里选择使用之前输入的数据
可注释掉自行输入

bool operator < (const Path& a, const Path& b)//直接写cmp函数使用sort函数也可
{
	return a.weight < b.weight;
}
int Find(int* p, int f)
{
	while (p[f] > 0)
		f = p[f];
	return f;
}
void Kruskal(GraphAdjList g)
{
	int n=g->numVertexes, m=g->numEdges;
	int root1, root2;
	Path* path = new Path[m];
	for (int i = 0; i < m; i++)//复制顶点下标及权重
	{
		path[i].start = myPath[i].start;
		path[i].end = myPath[i].end;
		path[i].weight = myPath[i].weight;
	}
	/*cout << "请输入每条边之间的顶点编号(顶点编号从0开始),以及该边的权重：\n";
	for (int i = 0; i < m; i++)
		cin >> path[i].start >> path[i].end >> path[i].weight;*/
	sort(path, path + m);
	int* b=new int[n];     //存放最小生成树的顶点
	int sum = 0;
	memset(b, 0, sizeof(b));
	cout << "\nKruskal最小生成树：\n";
	for (int i = 0; i < m; i++)
	{
		root1 = Find(b, path[i].start);
		root2 = Find(b, path[i].end);
		if (root1 != root2)         //root1==root2代表会形成环
		{
			sum += path[i].weight;
			b[root1] = root2;
			cout << g->vnode[path[i].start].data << "--->" << g->vnode[path[i].end].data << " " << path[i].weight << endl;
		}
	}
	cout << "总权值：" << sum << endl;
}

Dijkstra最短路径

void Dijkstra(GraphAdjList g, int v)
{
	int n = g->numVertexes;
	int* lens=new int[n];//保存最短长度
	int* path= new int[n];
	int* temp = new int[n];//保存临时最短路径
	const int max = ~(1 << 31);//0x7fffffff有符号整型最大值
	//初始化
	for (int i = 0; i < n; i++)
	{
		//lens表示节点是否已确定最短路径
		//这里用-1表示未确定，确认后用实际的最短路径进行填充。
		lens[i] = -1;
		temp[i] = max;//初始所有节点不可达
		path[i] = -1;//保存源节点到目的节点的路径上，目的节点的前一个节点
	}
	ArcNode* p = g->vnode[v].firstedge;
	//使用源节点的邻接边初始化一部分路径长度以及path
	while (p)
	{
		temp[p->adjvex] = p->weight;
		path[p->adjvex] = v;
		p = p->next;
	}
	lens[v] = 0;
	path[v] = 0;
	//开始主循环，每次求得源点到某个顶点的最短路径，并将此节点加入到已确定最短路径的集合中
	for (int i = 1; i < n; i++)
	{
		int index = -1;
		int min = max;
		//选择一条当前最短路径
		for (int j = 0; j < n; j++)
		{
			if (lens[j] < 0 && temp[j] < min)
			{
				min = temp[j];
				index = j;
			}
		}
		if (index == -1)//若没有可达路径，则退出
			break;
		lens[index] = min;//设置节点最短路径为已确定，并将最短路径保存起来

		//根据新确定最短路径的节点的邻接边，更新临时最短路径
		ArcNode* q = g->vnode[index].firstedge;
		while (q)
		{
			//若更小，则更新
			if (lens[q->adjvex] < 0 && min + q->weight < temp[q->adjvex])
			{
				temp[q->adjvex] = min + q->weight;
				path[q->adjvex] = index;
			}
			q = q->next;
		}
	}
	cout << "\nDijkstra最短路径：\n";
	for (int i = 0; i < n; i++)
		cout << g->vnode[v].data <<"--->"<<g->vnode[i].data<<" "<<lens[i] <<endl;
}

拓扑排序

这里用到之前的全局数组myPath来表示有向图

void TopologicalSort(GraphAdjList g)//拓扑排序
{
	int count = 0;
	int* myStack = new int[g->numVertexes];//创建简单的栈
	int top = -1;
	int* inPoint = new int[g->numVertexes];//保存各个顶点的入队
	for (int i = 0; i < g->numVertexes; i++)
		inPoint[i] = 0;
	for (int i = 0; i < g->numEdges; i++)//计算所有顶点入度
	{
		inPoint[myPath[i].end]++;
	}
	//for (int i = 0; i < g->numVertexes; i++)
	//	cout << inPoint[i] << " ";
	for (int i = 0; i < g->numVertexes; i++)//入度为0入栈
	{
		if (inPoint[i] == 0)
			myStack[++top] = i;
	}
	cout << "\n拓扑排序：\n";
	while (top != -1)//栈不为空
	{
		int index=myStack[top--];//出栈
		cout << g->vnode[index].data<<" ";
		count++;
		for (int i = 0; i < g->numEdges; i++)//将该出边终点顶点入队减1，减1后为0的入栈
		{
			if (myPath[i].start == index)
			{
				inPoint[myPath[i].end]--;
				if (inPoint[myPath[i].end] == 0)
					myStack[++top] = myPath[i].end;
			}		
		}
	}
	if (count == g->numVertexes)
		cout << "\n能够完成拓扑排序！\n";
	else
		cout<< "\n不能够完成拓扑排序！\n";
}

打印邻接表

void print(GraphAdjList g)
{
	cout << "\n输出邻接表：\n";
	for (int i = 0; i < g->numVertexes; i++)
	{
		cout << g->vnode[i].data << " ";
		ArcNode* p = g->vnode[i].firstedge;
		while (p)
		{
			cout << "<" << g->vnode[i].data << "," << g->vnode[p->adjvex].data << "> =" << p->weight << " ";
			p = p->next;
		}
		cout << "^\n";
	}
}

主函数

int main()
{
	GraphAdjList g;
	createGraph(g);//无向图
	print(g);
	cout << "\n\nDFS:";
	DFSGraphAdjList(g);
	cout << "\n\nBFS:";
	BFSGraphAdjList(g);
	Prim(g, 0);//最小生成树仅针对无向连通图,有向图可能不连通，不能求最小生成树
	Kruskal(g);
	Dijkstra(g, 0);
	TopologicalSort(g);//针对有向图，所以需要处理对称的数据，变成有向图
	return 0;
}
//测试数据
//6 10
//abcdef
//0 1 6
//0 2 1
//0 3 5
//1 2 5
//1 4 3
//2 3 5
//2 4 6
//2 5 4
//3 5 2
//4 5 6

测试结果

在这里插入图片描述

萝卜炖着吃
关注
专栏目录
图的邻接表表示的各种算法
11-05
图的邻接表表示的克鲁斯卡尔算法 迪杰斯特拉算法 普里姆算法 c++实现 codeblocks编译通过
图的基本算法实现（邻接矩阵与邻接表两种方法）
热门推荐
阳光岛主
06-21 2万+
本博客前面文章已对图有过简单的介绍，本文主要是重点介绍有关图的一些具体操作与应用阅读本文前，可以先参考本博客 各种基本算法实现小结（四）—— 图及其遍历一、无向图1 无向图——邻接矩阵测试环境：VS2008#include "stdafx.h" #include #include #define MAX_VEX 20 #define INFINITY 65535 int *visited; struct _node { int vex_num; struct _node *next
图的邻接表算法
microsoftwin32的专栏
06-09 1688
#define maxvernum 100//最大顶点数为100 typedef struct node //边表结点 { int adjvex;//邻接点域 struct node * next;//指向下一个邻接点的指针域 }Edgenode; typedef struct vnode//表头结点 { int vertex;//顶点域 Edgenode * link
《数据结构与算法》实验报告——无向图邻接表的构造
无限迭代中......
12-09 5433
《数据结构》实验报告 学号： 2018329621200 机器号 10-414-28 姓名： 申屠志刚 日期： 2019/12/9 程序名： main.cpp ...
数据结构实验报告-图-基于邻接表求连通无向图的DFS与BFS生成树-实验内容与要求.docx
05-03
实验内容及要求： 用字符文件提供数据建立连通无向图邻接表存储结构。编写程序，实现DFS与BFS算法，输出DFS与BFS生成树的每条边。（边用顶点序号组成的无序偶表示） 实验目的：掌握图的邻接表存储结构；掌握图的遍历算法与生成树。
《数据结构与算法》-李春葆 实验报告-基于邻接链表存储的无向图形算法实践-邻接链表
最新发布
12-20
本实验报告旨在介绍基于邻接链表存储的无向图形算法实践，旨在掌握有向图形和无向图形的结构定义和几种典型存储的算法实现，以及掌握图形的遍历方式及相关应用算法的实现。 一、设计人员相关信息 * 设计人员姓名：...
数据结构实验报告-图-求最短回路5分(第13周完成)-实验内容与要求_数据结构课程设计实验报告
12-28
实验报告的主题是“数据结构”，具体涉及图的...总结来说，这个实验报告涵盖了图的存储结构、最短路径算法（迪杰斯特拉和弗洛依德）、深度优先搜索以及程序设计和测试的基本要素，旨在深化学生对数据结构和图论的理解。
数据结构实验报告-图的遍历.doc
07-11
数据结构实验报告主要关注的是图的遍历方法，包括深度优先遍历（DFS）和广度优先遍历（BFS）。图是一种非线性的数据结构，由顶点和边组成，用于表示对象之间的关系。实验的目标是理解和掌握图的逻辑结构（如邻接矩阵...
数据结构实验报告-景点导游系统.doc
08-27
数据结构实验报告-景点导游系统 本实验报告主要介绍了景点导游系统的设计和实现，系统使用数据结构来存储和处理景点信息，包括图的存储结构、最短路径算法和最小生成树算法等。 第一部分：问题描述 本系统的目的...
图的邻接表算法---（附完整代码）
玥玥的博客博客博客
08-15 6608
1.邻接表的数据结构 2.初始化有顶点没有边的图 3.插入边 4.创建图 5.邻接表存储图的深度优先遍历DFS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MaxVertexNum 100 typedef int Vertex; typedef int WeightType; typedef char DataTyp...
C#有向图算法（邻接表包含关键路径、DFS、BFS、拓扑排序）
05-18
该算法是用C#实现的，要用Visual Studio2005
图的邻接矩阵和邻接表表示的各种算法
11-05
图的邻接表 邻接矩阵表示的迪杰斯特拉算法 普里姆算法 克鲁斯卡尔算法 用c++实现 codeblocks编译通过
建立和输出有向图的邻接表的问题
11-18
有兴趣的可以看看,顺便帮我改改不完善的地方
2----------图（邻接表）的相关算法
qq_25956141的博客
12-03 272
走进算法世界的大门，发现算法中的奥秘，让我们一起来探险吧。 图（邻接表）的结构体定义typedef struct ArcNode{ //边表 int adjvex; //边所指向的结点 int data; //边存放的权值 struct ArcNode * next; }ArcNode;typedef struct VNode{ ArcNode * firstar
图的邻接表存储算法（93）
我的博客
12-10 668
图的邻接表存储算法（93）
SDUT图的深度遍历之邻接表算法
一个麻瓜
08-11 468
图的深度遍历 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Discuss Problem Description 请定一个无向图，顶点编号从0到n-1，用深度优先搜索(DFS)，遍历并输出。遍历时，先遍历节点编号小的。 Input 输入第一行为整数n（0 Output 输出有n
输出邻接表
m0_72949559的博客
07-28 725
输入m，n，代表wu向图中有m个点，n条边，接下来输入n行，每行包含三个数据，分别是这条边的起始点，终止点和wu权值。输出邻接表。
链表和邻接表的总结
juruohfl的博客
07-07 603
链表与邻接表
数据结构实验3--图以邻接表为存储结构的初始化，遍历，迪杰斯特拉算法求最短路径（实验内容3~4~5）
VAEaaaa的博客
04-28 540
运行结果： 源文件： #include "邻接表宽度优先遍历的queue.h" //邻接表的初始化 Status Init(LGraph* lg, int nSize) { int i; lg->numofDot = nSize; lg->numofEdge = 0; lg->a = (ENode**)malloc(nSize * sizeof(ENode*)); if (!lg->a) { return ERROR; } else { for (i =
计算机科学与技术专业李响的数据结构实验报告-线性表与二叉树实现
"该资源是一份关于数据结构实验的课程报告，主要涵盖了线性表的顺序存储和链式存储结构的实现，以及二叉链表的二叉树和图的邻接表实现。作者是李响，专业为计算机科学与技术，实验指导教师为李丹。报告中详细描述了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值