28 邻接表：构造有权图

最新推荐文章于 2022-05-31 18:41:48 发布

杨骅麟（Patrick Young）

最新推荐文章于 2022-05-31 18:41:48 发布

阅读量515

点赞数

分类专栏：东华大学数据结构OJ 文章标签： p2p 网络协议网络

本文链接：https://blog.csdn.net/Ultravioletrays/article/details/124981365

版权

东华大学数据结构OJ 专栏收录该内容

41 篇文章 27 订阅

订阅专栏

28 邻接表：构造有权图

作者: 冯向阳时间限制: 1S章节: DS:图

截止日期: 2022-06-30 23:55:00

问题描述 :

目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。

内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）使用构造函数，构造一个有权图。

注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）

参考函数原型：

//构造函数构造一个有权图。6个参数的含义：图的类型、结点数、边数、结点集、边集、权集

template<class TypeOfVer, class TypeOfEdge>

adjlist_graph<TypeOfVer, TypeOfEdge>::adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e, const TypeOfEdge w[]);

图的邻接表模板类原型参考如下：

/* 边表的结点定义 */

template<class TypeOfEdge>

struct edgeNode

{

int data;

TypeOfEdge weight;

edgeNode<TypeOfEdge> *next;

edgeNode(const int &d, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（无权图）

//函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

{

next = ptr;

data = d;

}

edgeNode(const int &d, const TypeOfEdge &w, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（带权图）

//函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

{

next = ptr;

data = d;

weight = w;

}

int getData(){ return data;} //取得结点的序号（顶点集）

TypeOfEdge getWeight(){ return weight;} //取得边集中对应边的权值

void SetLink( edgeNode<TypeOfEdge> *link ){ next = link; } //修改结点的next域

void SetData( int value ){ data = value; } //修改结点的序号（顶点集）

void SetWeight(TypeOfEdge value ){ weight = value; } //修改边集中对应边的权值

};

//图的邻接表类

template<class TypeOfVer, class TypeOfEdge>

struct verNode

{

TypeOfVer ver;

edgeNode<TypeOfEdge> *head;

verNode(edgeNode<TypeOfEdge> *h = NULL){head = h;}

TypeOfVer getVer(){ return ver;} //取得结点值（顶点集）

edgeNode<TypeOfEdge> *getHead(){ return head;} //取得对应的边表的头指针

void setVer(TypeOfVer value){ ver = value;} //设置结点值（顶点集）

void setHead(edgeNode<TypeOfEdge> *value){ head = value;} //设置对应的边表的头指针

};

template <class TypeOfVer, class TypeOfEdge>

class adjlist_graph{

private:

int Vers; //顶点数

int Edges; //边数

verNode<TypeOfVer,TypeOfEdge> *verList;

string GraphKind; //图的种类标志

bool Delete_Edge( int u, int v );

bool DFS(int u, int &num, int visited[]); //DFS遍历（递归部分）

public:

adjlist_graph( const string &kd, int vSize, const TypeOfVer d[]); //构造函数构造一个只有结点没有边的图。

adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e); 构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集

adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e, const TypeOfEdge w[]); //构造函数构造一个有权图。

bool GraphisEmpty() { return Vers == 0; } //判断图空否

string GetGraphKind(){ return GraphKind; }

bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值

int GetFirstAdjVex(int u, int &v); //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1

int GetNextAdjVex(int u, int v, int &w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false

bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值

bool InsertVer(const TypeOfVer &data); //往G中添加一个顶点

int LocateVer(TypeOfVer data); //返回G中指定顶点的位置

bool ExistEdge(int u, int v);

bool PrintVer(); //输出顶点集

bool PrintAdjList(); //输出邻接矩阵

int GetVerNum(){ return Vers;} //取得当前顶点数

int GetEdgeNum(){ return Edges;} //取得当前边数

bool Insert_Edge(int u, int v); //无权图插入一条边

bool Insert_Edge(int u, int v, TypeOfEdge w); //有权图插入一条边

bool DeleteVer(const TypeOfVer &data); //往G中删除一个顶点

bool DeleteEdge( int u, int v ); //删除边 (外壳：有向（删除1条边），无向（删除2条边））

void DFS_Traverse(int u); //DFS遍历（外壳部分）

void BFS_Traverse(int u); //BFS遍历

~adjlist_graph(); //析构函数

};

输入说明 :

第一行：图的类型

第二行：结点数

第三行：结点集

第四行：边数

第五行：边集

第六行：权集

输出说明 :

第一行：图的类型

第二行：顶点集

第三行：邻接表

输入范例 :

UDN
6
A B C D E F
6
0 1
0 2
1 3
2 3
3 4
3 5
20 30 40 50 70 80

--------------------------------

UDN
A B C D E F
A->2(30)->1(20)->nullptr
B->3(40)->0(20)->nullptr
C->3(50)->0(30)->nullptr
D->5(80)->4(70)->2(50)->1(40)->nullptr
E->3(70)->nullptr
F->3(80)->nullptr

这道题难度是易，但我觉得这道题很难，可能我是一个新手刚上手有点恶心。

我觉得这道题很恶心的地方在于她的权值输入的格式很恶心

UDN
6
A B C D E F
6
0 1
0 2
1 3
2 3
3 4
3 5
20 30 40 50 70 80

这种输入就很caodan

你如果这样输入的话我的代码量可以少很多

UDN
6
A B C D E F
6
0 1 20
0 2 30
1 3 40
2 3 50
3 4 70
3 5 80

他把权重和边分离输入了所以很难受

下面附上我的代码

我的代码逻辑很简单

首先分为无向网和有向网

各自有两个核心函数

一个是构造邻接表对DN来说就是 creatdirection

对UDN来说就是creatnodirection

------------------------------------------

构造完成后第二个核心函数

给邻接表附上权重

DN来说就是addweight

UDN就是addweight——no——direction

----------------------------

然后各自输出

#include<iostream>
#include<queue>
using namespace std;
int m = 0;
int arr[100][2] = {0};
struct bian
{
	int num;
	int weight;
	bian* next=NULL;
};

struct point
{
	string letter;
	bian* next=NULL;
};

struct graph
{

	point m[100];
	int number_of_point;
	int number_of_bian;
};

void addweight_no_direction(graph &g);
void addweight(graph& g);


void creat_no_directioin(graph &g)
{
	int e;
	int f;
	cin >> e;
	g.number_of_point = e;
	for (int i = 0; i < e; i++)
	{
		cin >> g.m[i].letter;
	}
	//上面是输入的顶点的字母

	cin >> f;
	g.number_of_bian = f;
	for (int i = 0; i < f; i++)
	{
		int v1;
		int v2;
		cin >> v1 >> v2;
		arr[i][0] = v1;
		arr[i][1] = v2;
		bian* p1 = new bian;
		p1->num = v2;
		 p1->next= g.m[v1].next ;
		g.m[v1].next = p1;
		bian* p2 = new bian;
		p2->num = v1;
		 p2->next= g.m[v2].next ;
		g.m[v2].next = p2;
	}

	addweight_no_direction(g);

}
void addweight_no_direction(graph& g)
{
	for (int j = 0; j < g.number_of_bian; j++)
	{
		int temp = 0;
		cin >> temp;
		int number1 = arr[j][0];
		int number2 = arr[j][1];
		bian* p;
		bian* p1;
		p = g.m[number1].next;
		p1 = g.m[number2].next;
		while (p)
		{
			if (p->num == number2)
			{
				p->weight = temp;

			}
			p = p->next;
		}

		while (p1)
		{
			if (p1->num == number1)
			{
				p1->weight = temp;
			}
			p1 = p1->next;
		}
	}
}


void creat_direction(graph &g)
{
	int e;
	int f;
	cin >> e;
	g.number_of_point = e;
	for (int i = 0; i < e; i++)
	{
		cin >> g.m[i].letter;
	}
	//上面是输入的顶点的字母

	cin >> f;
	g.number_of_bian = f;
	for (int i = 0; i < f; i++)
	{
		int v1;
		int v2;
		cin >> v1 >> v2;
		arr[i][0] = v1;
		arr[i][1] = v2;
		bian* p1 = new bian;
		p1->num = v2;
		p1->next=g.m[v1].next;
		g.m[v1].next = p1;
	}


	addweight(g);

}
void addweight(graph& g)
{
	for (int j = 0; j < g.number_of_bian; j++)
	{
		int temp = 0;
		cin >> temp;
		int number1 = arr[j][0];
		int number2 = arr[j][1];
		bian* p;

		p = g.m[number1].next;
		
		while (p)
		{
			if (p->num == number2)
			{
				p->weight = temp;

			}
			p = p->next;
		}		
	}
}




int main()
{

	string kind;
	cin >> kind;
	if (kind == "DN")//
	{
		graph g;
		int m = 0;
		creat_direction(g);





		cout << "DN" << endl;
		for (int h = 0; h < g.number_of_point; h++)
		{
			if (m == 1)
			{
				cout << " ";
			}
			m = 1;
			cout << g.m[h].letter;
		
		}
		cout << endl;
		for (int u = 0; u < g.number_of_point; u++)
		{
			cout << g.m[u].letter;
			
			
			bian* p = g.m[u].next;
			while (p)
			{
				cout << "->";
				cout << p->num << "(" << p->weight << ")";
				p = p->next;
			}
			if (p == NULL)
			{
				cout << "->" << "nullptr" << endl;
			}
		}
	}

	else if (kind == "UDN")//
	{
	
		graph g;
		creat_no_directioin(g);




		cout << "UDN" << endl;
		for (int h = 0; h < g.number_of_point; h++)
		{
			if (m == 1)
			{
				cout << " ";
			}
			m = 1;
			cout << g.m[h].letter;

		}
		cout << endl;
		for (int u = 0; u < g.number_of_point; u++)
		{
			cout << g.m[u].letter;


			bian* p = g.m[u].next;
			while (p)
			{
				cout << "->";
				cout << p->num << "(" << p->weight << ")";
				p = p->next;
			}
			if (p == NULL)
			{
				cout << "->" << "nullptr" << endl;
			}
		}
	}

	

	return 0;
}

杨骅麟（Patrick Young）

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
28 邻接表：构造有权图

28邻接表：构造有权图作者:冯向阳时间限制:1S章节:DS:图截止日期:2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）使用构造函数，构造一个有权图。注意：DG（有向图）, DN（有...
复制链接

扫一扫