题目描述:
目的:使用C++模板设计并逐步完善图的邻接表抽象数据类型(ADT)。
内容:
(1)请参照图的邻接矩阵模板类原型,设计并逐步完善图的邻接表ADT。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。)
(2)设计并实现一个算法,在已存在的图中返回G中指定顶点u的第一个邻接顶点的位序(顶点集)。若顶点在G中没有邻接顶点,则返回-1。图的存储结构采用邻接表。将其加入到ADT中。
注意:DG(有向图), DN(有向网), UDG(无向图), UDN(无向网)
参考函数原型:
//返回G中指定顶点u的第一个邻接顶点的位序(顶点集)。若顶点在G中没有邻接顶点,则返回false
template<class TypeOfVer, class TypeOfEdge>
int adjlist_graph<TypeOfVer, TypeOfEdge>::GetFirstAdjVex(int u, int &v);
输入说明 :
建图的输入数据格式参见建图的算法说明。
第一行:图的类型
第二行:结点数
第三行:结点集
第四行:边数
第五行:边集
第六行:指定顶点的位序
输出说明 :
第一行:顶点集
第二行:邻接表
空行
第三行:第一个邻接顶点的位序(如无邻接顶点,则输出-1)
输入范例 :
DG
6
A B C D E F
6
0 1
0 2
0 3
1 4
2 4
3 5
0
输出范例 :
A B C D E F
A->3->2->1->nullptr
B->4->nullptr
C->4->nullptr
D->5->nullptr
E->nullptr
F->nullptr
(空行)
3
#include<iostream>
#include<vector>
#include<string>
#include<sstream>
#include<queue>
#include<stack>
#include<cmath>
using namespace std;
string b[10001];//用来存放顶点集
//DG(有向图) DN(有向网) UDG(无向图) UDN(无向网)
//图的邻接表模板类原型参考如下:
//边表的顶点定义
template<class TypeOfEdge>//这个就是在边上的顶点定义
struct edgeNode{
int data;
TypeOfEdge weight;
edgeNode<TypeOfEdge> *next;
//构造函数,用于构造其他顶点(无权图)
//函数参数表中的形参允许有默认值,但是带默认值的参数需要放后面
edgeNode(int d,edgeNode<TypeOfEdge> *ptr=NULL){
data=d;next=ptr; }
//构造函数,用于构造其他顶点(带权图)
//函数参数表中的形参允许有默认值,但是带默认值的参数需要放后面
edgeNode(int d,TypeOfEdge w,edgeNode<TypeOfEdge> *ptr=NULL){
data=d; weight=w; next=ptr;
}
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;//边数
string GraphKind;//图的种类标志
verNode<TypeOfVer,TypeOfEdge> *verList;//按顺序存储结构存储顶点集
bool Delete_Edge(int u,int v);
bool DFS(int u,int num,int visited[]);//DFS遍历(递归部分)
public:
//构造函数构造一个只有顶点没有边的图
//3个参数的含义:图的类型、顶点数、顶点值
adjlist_graph(string kd,int vSize,TypeOfVer d[]){
GraphKind=kd;
Vers=vSize;
verList=new verNode<TypeOfVer,TypeOfEdge> [Vers];//建立顶点值
for(int i=0;i<Vers;++i){
verList[i].ver=d[i];
verList[i].head=NULL;//一开始构造的时候顶点还没有相邻的顶点
}
}
//构造函数构造一个无权图
//5个参数的含义:图的类型、顶点数、顶点集、 边数和边集
adjlist_graph(string kd,int vSize,TypeOfVer d[],int eSize,int **e){
GraphKind=kd;
Vers=vSize;
Edges=eSize;
verList=new verNode<TypeOfVer,TypeOfEdge> [Vers];//建立顶点值
for(int i=0;i<Vers;++i){
verList[i].ver=d[i];
verList[i].head=NULL;//一开始构造的时候顶点还没有相邻的顶点
}
for(int i=0;i<Edges;++i){
//从边开始构造顶点
for(int j=0;j<Vers;++j){
if(e[i][0]==j){
if(Insert_Edge(e[i][0],e[i][1]))
break;
}
}
}
}
//构造函数构造一个有权图
adjlist_graph(string kd,int vSize,int eSize,TypeOfVer d[],int **e,TypeOfEdge w[]);
bool GraphisEmpty(){
return Vers==0; }//判断图空否
string GetGraphKind(){
return GraphKind; }//返回图的类型
int GetVerNum(){
return Vers; }//取得当前顶点数
int GetEdgeNum(){
return Edges; } //取得当前边数
bool GetVer(int u,TypeOfVer &data){
//取得G中指定顶点的值
return true;
}
//返回G中指定顶点u的第一个邻接顶点的位序(顶点集)
//若顶点在G中没有邻接顶点,则返回-1
int GetFirstAdjVex(int u,int &v){
if(verList[u].head!=NULL){
v=verList[u].head->data;
return v;
}
v=-1;
return -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);
//输出顶点集
void PrintVer(){
for(int i=0;i<Vers;++i){
if(i==0)
cout<<verList[i].ver;
else
cout<<" "<<verList[i].ver;
}
cout<<endl;
}
//输出邻接表
void PrintAdjList(){
for(int i=0;i<Vers;++i){
cout<<verList[i].ver;
if(verList[i].head!=NULL){
edgeNode<TypeOfEdge> *p=verList[i].head;//从顶点开始遍历
while(p){
cout<<"->"<<p->data;
p=p->next;
}
cout<<"->nullptr"<<endl;
}
else
cout<<"->nullptr"<<endl;
}
}
//无权图插入一条边
bool Insert_Edge(int u,int v){
//u是起点,v是终点
edgeNode<TypeOfEdge> *x=new edgeNode<TypeOfEdge>(v);//直接使用构造函数赋值
//x.data=v;不要这么写
x->next=verList[u].head;//这里面都没有->next 这个指针!!!!!!!
verList[u].head=x;
return true;
}
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(); //析构函数
};
template<class TypeOfVer,class TypeOfEdge>
void shuchu(adjlist_graph<TypeOfVer,TypeOfEdge> &tu,int n){
//cout<<tu.GetGraphKind()<<endl;
TypeOfVer x;
//TypeOfEdge we;
//we=tu.GetEdgeNum();//返回第一个边数
tu.PrintVer();
//cout<<endl<<we<<endl;
tu.PrintAdjList();//输出邻接表
}
int main(){
string str;//图的类型
int n,m;//顶点数和边数
getline(cin,str);
cin>>n;//输入顶点个数
for(int i=0;i<n;++i)
cin>>b[i];//输入顶点集合
cin>>m;//输入边数
int **e;
e=new int* [m];
for(int i=0;i<m;++i)
e[i]=new int [2];
for(int i=0;i<m;++i)
cin>>e[i][0]>>e[i][1];//输入边集
adjlist_graph<string,int> tu(str,n,b,m,e);
int no;//指定的顶点
cin>>no;
shuchu(tu,n);
cout<<endl;
int we;
tu.GetFirstAdjVex(no,we);
cout<<we<<endl;
return 0;
}
好了,在上一道题的基础上我又补充了一些函数的实现。
表是由2个部分组成的:
1.表头顶点表
2.边表
首先我们要知道:用模板和ADT写这个题其中一共有2个结构体和1个类。
2个结构体分别是struct verNode
和struct edgeNode
第一个 结构体表示顶点的结点,第二个结点表示边的结点。
顶点结构体我们用到的就是这两个成员:
TypeOfVer ver;//存放顶点名称
edgeNode<TypeOfEdge> *head;//顶点的指针
比如说ver就是A,而红色箭头就是名为head的指针!!!!
所以使用head指针的时候不需要再写head->next这样的语句,因为它本身就是指针了,如果这样写的话,程序肯定会崩的,空指针不能指向某个地方。
(估计是因为我蠢才以为错的)
第二个结构体就是表示边上的结点了,有值data
权值weight
和指向下一个的结点next
指针。
类中的成员都很容易理解,就忽略了。
表头顶点表是用顺序存储结构储存的,就是adjlist_graph类中的verNode<TypeOfVer,TypeOfEdge> * verList;
然后这个顺序存储结构它是储存verNode<TypeOfVer,TypeOfEdge>
顶点的。
边表是储存head指针开始由结点连接成的链表。