图的基本操作

最新推荐文章于 2023-04-25 18:11:05 发布
算法第一深情
最新推荐文章于 2023-04-25 18:11:05 发布
阅读量518
点赞数 2
分类专栏：数据结构文章标签：数据结构
本文链接：https://blog.csdn.net/m0_64005495/article/details/127835608
版权
数据结构专栏收录该内容
9 篇文章 0 订阅
订阅专栏
#include <iostream>
#include <stdlib.h>
#include <iomanip>
#include <limits.h> 

#define MVNum 100       //最大顶点数
using namespace std;
//顺序队列结构定义
typedef struct{
	int front;      //队头
	int rear;       //队尾
	char base[MVNum];   //存放队列元素的数组
}SqQueue;
//邻接矩阵存储结构定义
typedef struct{
	char vexs[MVNum];         //存放顶点的数组
	int arcs[MVNum][MVNum];    //存放邻接矩阵的数组
	int vexnum,arcnum;         //顶点数和边（弧）数
}AMGraph;    

//边（弧）结点结构定义
typedef struct ArcNode{
	int adjvex;         //邻接点位置
	struct ArcNode *nextarc;     //指向下一个弧（边）结点的指针
	int weight;   //弧（边）的权值	
}ArcNode;

//顶点类型定义
typedef struct VNode{
	char data;
	ArcNode  *firstarc;   
}VNode,AdjList[MVNum];    //顶点数组类型定义

//邻接表结构定义
typedef struct{
	AdjList vertices;    //顶点数组
	int vexnum,arcnum;   //顶点数和边（弧）数
}ALGraph;

//在以邻接表方式存储的图G中，查找值为ch的顶点的位置
int LocateVex(ALGraph G,char ch)
{
	for(int i=0;i<G.arcnum;i++)
		if(G.vertices[i].data==ch) 
		return i;
	return -1;
}

//以邻接表为存储结构，创建无向图G
void CreateUDG_AL(ALGraph &G)
{
	char v1,v2;
	int i,j,k;
	ArcNode *p1,*p2;
	cin>>G.vexnum>>G.arcnum;
	for(i=0;i<G.vexnum;i++){
		cin>>G.vertices[i].data;
		G.vertices[i].firstarc=NULL;
	}
	for(k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		i=LocateVex(G,v1);j=LocateVex(G,v2);
		if(i==-1||j==-1) continue;
		p1=new ArcNode;
		p1->adjvex=j;
		p1->nextarc=G.vertices[i].firstarc;
		G.vertices[i].firstarc=p1;
		
		p2=new ArcNode;
		p2->adjvex=i;
		p2->nextarc=G.vertices[j].firstarc;
		G.vertices[j].firstarc=p2;
	}
    return ;
}

//输出G的邻接表 
void PrintAdjList(ALGraph G)
{
	for(int i=0;i<G.vexnum;i++){
		cout<<setw(4)<<G.vertices[i].data;
		if(G.vertices[i].firstarc==NULL)
			cout<<setw(4)<<"∧"<<endl;
		else{
			ArcNode *p=G.vertices[i].firstarc;
			while(p){
				cout<<setw(4)<<"→"<<setw(2)<<p->adjvex;
				p=p->nextarc;
			}
		}
		cout<<endl;
	}
} 

//在以邻接矩阵方式存储的图G中，查找值为ch的顶点的位置
int LocateVex1(AMGraph G,char ch)
{
	int i;
	for(i=0;i<G.vexnum;i++)
		if(G.vexs[i]==ch) return i;
	return -1;
}

//以邻接矩阵为存储结构，创建有向图G
void CreateDG_AM(AMGraph &G)
{
	int i,j,k,w;
	char v1,v2;
	cin>>G.vexnum>>G.arcnum;
	for(i=0;i<G.vexnum;i++)
		cin>>G.vexs[i];
	for(i=0;i<G.vexnum;i++)
		for(j=0;j<G.vexnum;j++)
			G.arcs[i][j]=INT_MAX;
	for(k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		i=LocateVex1(G,v1);
		j=LocateVex1(G,v2);
		if(i!=-1&&j!=-1)
		G.arcs[i][j]=1;
	}
}

//输出G的邻接矩阵 
void PrintAM(AMGraph G)
{
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			if(G.arcs[i][j]==INT_MAX)   //输出网的邻接矩阵时，无穷用符号 ∞代替 
				cout<<setw(8)<<"∞";
			else
				cout<<setw(8)<<G.arcs[i][j];
		}
		cout<<endl;
	}
} 

//以邻接矩阵为存储结构，创建有向网G
void CreateDN_AM(AMGraph &G)
{
	int i,j,k,w;
	char v1,v2;
	cin>>G.vexnum>>G.arcnum;
	for(i=0;i<G.vexnum;i++)
		cin>>G.vexs[i];
	for(i=0;i<G.vexnum;i++)
		for(j=0;j<G.vexnum;j++)
			G.arcs[i][j]=INT_MAX;
	for(k=0;k<G.arcnum;k++){
		cin>>v1>>v2;
		i=LocateVex1(G,v1);
		j=LocateVex1(G,v2);
		if(i!=-1&&j!=-1)
		G.arcs[i][j]=1;
	}
	
}

int FirstAdjVex(ALGraph G, int u)
{
    int i;
    
    // 如果u没有被访问过
    if(u >= 0 && u < G.vexnum)
    {
        if(G.vertices[u].firstarc)
            return G.vertices[u].firstarc->adjvex;
    }
 
    return -1;
}
int NextAdjVex(ALGraph G, int u, int w)
{
    ArcNode *p;
    if(u >= 0 && u < G.vexnum && w >= 0 && w < G.vexnum)
    {
        p = G.vertices[u].firstarc;
        while(p->nextarc)
        {
            if(p->adjvex == w)
                return p->nextarc->adjvex;
            else
                p = p->nextarc;
        }
    }
 
    return -1;
}


bool visited[MVNum];   //存放图中顶点访问标志的数组
//从图中的第v个顶点出发，深度遍历图G（以邻接表为存储结构）
void DFS(ALGraph G,int v)
{
	int w,u;
	cout<<v;
	visited[v]=true;
	for(int w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
	if(!visited[w])
	DFS(G,w);
}

//深度遍历图G
void DFSTraverse(ALGraph G)
{
	int v;
	for(v=0;v<G.vexnum ;v++)   //初始化所有顶点的访问标志位false
		visited[v]=false;
	for(v=0;v<G.vexnum ;v++)   //逐一检查每个顶点的访问标志，找一个未被访问过的顶点v为出发点，对图G进行深度遍历
	{
		if(visited[v]==false)
			DFS(G,v);
	}
}

//从图中的第v个顶点出发，广度遍历图G（以邻接表为存储结构）
//初始化队列
void InitQueue(SqQueue &Q)
{
	Q.front=Q.rear=0;
}

//判断队列Q是否为空，为空返回true，非空返回false
bool QueueEmpty(SqQueue Q)
{
	if(Q.rear==Q.front )
		return true;
	else
		return false;
}

//入队操作，将n插入顺序队列Q的尾部
void EnQueue(SqQueue &Q,int n)
{
	if(Q.rear-Q.front==MVNum)  //队满时，不能执行入队操作
		exit(-1);
	else
	{
		Q.base[Q.rear]=n;
		Q.rear++;
	}
}

//出队操作，删除队列Q的队头元素，被删元素用n返回
void DeQueue(SqQueue &Q,int &n)
{
	if(QueueEmpty(Q))     //若队列为空，不能执行出队操作
		exit(-1);
	else
	{
		n=Q.base [Q.front];
		Q.front++;
	}
}


void BFS(ALGraph G,int v)
{
	SqQueue Q;
	int u;
	cout<<v;
	visited[v]=true;
	InitQueue(Q);
	EnQueue(Q,v);
	while(!QueueEmpty(Q)){
		DeQueue(Q,u);
	}
	for(int w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
	if(!visited[w]){
		cout<<w;
		visited[w]=true;
		EnQueue(Q,w); 
	}
	
}

//广度遍历图G
void BFSTraverse(ALGraph G)
{
	int v;
	for(v=0;v<G.vexnum ;v++)     //初始化所有顶点的访问标志位false
		visited[v]=false;
	for(v=0;v<G.vexnum ;v++)     //逐一检查每个顶点的访问标志，找一个未被访问过的顶点v为出发点，对图G进行广度遍历
	{
		if(visited[v]==false)
			BFS(G,v);
	}
}

//使用迪杰斯特拉算法求第v0个顶点到其它顶点的最短路径并输出 
//可以使用下面的模板，也可以按照自己的方式实现 
void ShortestPath_DIJ(AMGraph G,int v0)
{
	int D[MVNum],Path[MVNum],i,v,w,min;  //数组D存储源点到其它顶点的最短路径长度,Path数组存放每个顶点的前驱顶点
	bool S[MVNum];    //每个顶点是否已求得最短路径的标志存放在数组S中
	//初始化三个数组
	for(v=0;v<G.vexnum ;v++)
	{
		S[v]=false; 
		D[v]=G.arcs[v0][v];
		if(D[v]<INT_MAX)
		Path[v]=v0;
		else
		Path[v]=-1;
	}
	//将第v0个顶点设置为源点
	S[v0]=true;
	D[v0]=0;
	//循环G.vexnum-1次,求第v0个顶点到图中其它顶点的最短距离
	for(i=1;i<G.vexnum ;i++)
	{
		min=INT_MAX;//寻找距离源点最近的第v个顶点
		for(w=0;w<G.vexnum;w++)
		if(!S[w]&&D[w]<min){
			v=w;
			min=D[w];
		}	
		S[v]=true;      //将第v个顶点加入到S中，S表示已求得最短路径的顶点集合
		//更新源点到其它顶点的最短距离
		for(w=0;w<G.vexnum ;w++)
		{
			if(!S[w]&&(D[w]+G.arcs[v][w]<D[w]))
			Path[w]=v;		
		}//for(w)
	}//for(i)
	
	//输出源点到其它顶点的最短路径及路径长度
	for(i=1;i<G.vexnum;i++)
	{
		ShortestPath_DIJ(G,G.vexs[i]);
		cout<<endl<<"顶点"<<G.vexs[v0]<<"到顶点"<<G.vexs[i]<<"的最短路径长度为"<<D[i]<<",路径为：";

		//从第i个顶点回溯，输出第i个顶点到源点的最短路径
		//请同学们在此处根据注释，补充该操作，输出源点到其它顶点的最短路径	
	}
}

//操作菜单
void showmenu()
{	
	cout<<endl;
	cout<<"**************************图的创建*************************"<<endl;
	cout<<"1、创建无向图（基于邻接表存储方式）,并输出其邻接表，深度遍历序列和广度遍历序列"<<endl;
	cout<<"2、创建有向图（基于邻接矩阵存储方式）,并输出其邻接矩阵"<<endl;
	cout<<"3、创建有向网（基于邻接矩阵存储方式），并使用迪杰斯特拉算法求其最短路径"<<endl;
	cout<<"4、退出程序"<<endl;
	cout<<endl;
}

int main() 
{
	int k,i;
	char ch;
	ALGraph G1;   //G1为以邻接表方式存储的无向图
	AMGraph G2;   //G2为以邻接矩阵方式存储的有向图 
	AMGraph G3;   //G3为以邻接矩阵方式存储的无向网 
	//循环显示菜单，完成构造图的一系列操作
	do{
		showmenu();    
		cout<<"请选择要执行的操作序号"<<endl;
		cin>>k;    //k表示用户选择的操作序号
		switch(k)
		{
		case 1:    //创建无向图（基于邻接表存储方式）	
			cout<<"该操作完成无向图的创建(基于邻接表存储方式)，输出无向图的邻接表、深度遍历序列和广度遍历序列"<<endl;
			CreateUDG_AL(G1);     //创建无向图G
			cout<<"该图的邻接表为："<<endl;
			PrintAdjList(G1);
			cout<<"该图的深度遍历序列为："<<endl;
			DFSTraverse(G1);  //深度遍历图G1
			cout<<"该图的广度遍历序列为："<<endl;
			BFSTraverse(G1);  //广度遍历图G1 
			break;
		case 2:   //创建有向图（基于邻接矩阵存储方式）	
			cout<<"该操作完成有向图的创建(基于邻接矩阵存储方式)，并输出其邻接矩阵"<<endl;
			CreateDG_AM(G2);     //创建无向图G
			cout<<"该图的邻接矩阵为："<<endl;
			PrintAM(G2);
			break;
		case 3:   //创建有向网（基于邻接矩阵存储方式）	
			cout<<"该操作完成有向网的创建(基于邻接矩阵存储方式)，并使用迪杰斯特法方法求其最短路径"<<endl;
			CreateDN_AM(G3);     //创建无向图G
			cout<<"该网的邻接矩阵为："<<endl;
			PrintAM(G3);
			//以下操作使用迪杰斯特拉算法求指定的源点到图中其它顶点的最短路径 
			cout<<"请输入源点："<<endl;
			cin>>ch;                  //输入源点     
			i=LocateVex1(G3,ch);       //求源点在G3中的位置i
			ShortestPath_DIJ(G3,i);    //使用迪杰斯特拉算法求第i个顶点到其它顶点的最短路径
			break;
		case 4:
			cout<<"谢谢使用，再见！"<<endl;
			break;
		default:
			cout<<"操作序号错误，请输入正确的操作序号！"<<endl;
			break; 		
		}//switch
	}while(k!=4);
	return 0;
}