数据结构-图的邻接矩阵的实现以及相关的一些算法操作

包含图的结构实现和相关的一些重要算法实现

typedef struct ENode* PtrToENode;
struct ENode{
	Vertex V1,V2;		//有向边<V1,V2> 
	WeightType Weight;	//权重 
};

typedef struct GNode* PtrToGNode;
struct GNode{
	int Nv;			//顶点数 
	int Ne;			//边数 
	WeightType G[MaxVertexNum][MaxVertexNum];		//邻接矩阵 
	DataType Data[MaxVertexNum];					//存顶点的数据
	//注意：很多情况下，顶点无数据，此时Data[]可以不用出现 
}; 
typedef PtrToGNode MGraph;  //以邻接矩阵存储的图类型

#include<iostream>
#include<queue>
using namespace std;

/*图的临界矩阵表示法*/
#define ERROR -1
#define MaxVertexNum 100			//最大顶点数设为100 
#define INFINITY 65536				//设为双字节无符号整数的最大值65535
typedef int Vertex;					//用顶点下标表示顶点，为整形 
typedef int WeightType;				//边的权值设为整形 
typedef char DataType;				//顶点存储的数据结构设为字符型 
bool Visited[MaxVertexNum]={false};
/*边的定义*/
typedef struct ENode* PtrToENode;
struct ENode{
	Vertex V1,V2;		//有向边<V1,V2> 
	WeightType Weight;	//权重 
};
typedef PtrToENode Edge;

/*图结点的定义*/
typedef struct GNode* PtrToGNode;
struct GNode{
	int Nv;			//顶点数 
	int Ne;			//边数 
	WeightType G[MaxVertexNum][MaxVertexNum];		//邻接矩阵 
	DataType Data[MaxVertexNum];					//存顶点的数据
	//注意：很多情况下，顶点无数据，此时Data[]可以不用出现 
}; 
typedef PtrToGNode MGraph;  //以邻接矩阵存储的图类型

MGraph CreateGraph(int VertexNum){
	/*初始化一个有VertexNum个顶点但没有边的图*/
	Vertex V,W;
	MGraph Graph;
	
	Graph=(MGraph)malloc(sizeof(struct GNode));
	Graph->Ne=0;
	Graph->Nv=VertexNum;
	/*初始化邻接矩阵*/
	/*注意：这里默认顶点编号从0开始，到(Graph->Nv-1)*/
	for(V=0;V<Graph->Nv;V++)
		for(W=0;W<Graph->Nv;W++)
			Graph->G[V][W]=INFINITY;
			
	return Graph;			 
} 

void InsertEdge(MGraph Graph,Edge E){
	/*插入边*/
	Graph->G[E->V1][E->V2]=E->Weight;
	/*若是无向图，还要插入边<V2,V1>*/
	Graph->G[E->V2][E->V2]=E->Weight;
}

MGraph BuildGraph(){
	MGraph Graph;
	Edge E;
	Vertex V;
	int Nv,i;
	
	scanf("%d",&Nv); /*读入顶点个数*/
	Graph=CreateGraph(Nv); /*初始化有Nv个顶点但没有边的图*/ 
	
	scanf("%d",&(Graph->Ne)); /*读入边数*/ 
	if(Graph->Ne!=0){
		E=(Edge)malloc(sizeof(struct ENode));
		/*读入边，格式为“起点 终点 权重”，插入邻接矩阵*/ 
		for(i=0;i<Graph->Ne;i++)
			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);
			/*注意：如果权重不是整形，Weight的读入格式要改*/
			InsertEdge(Graph,E);
	}
	
	for(V=0;V<Graph->Nv;V++){
		scanf("%c",&(Graph->Data[V]));
	}
	return Graph;
}
void Visit(Vertex V){
	printf("正在访问顶点%d\n",V);
}
/*邻接矩阵存储的图 - BFS*/
/*IsEdge(Graph ,V,W)检查<V,W>是否图Graph中的一条边，即W是否V的邻接点。*/
/*此函数根据图的不同类型要做不同的实现，关键取决于对不存在的边的表示法*/
/*例如对有权图，如果不存在的边被初始化为INFINITY,则函数实现如下:*/
bool IsEdge(MGraph Graph,Vertex V,Vertex W){
	return Graph->G[V][W]<INFINITY ?true :false;
}
void BFS(MGraph Graph,Vertex S,void(*Visit)(Vertex)){
	/*以S为出发点对临界矩阵存储的图Graph进行BFS搜索*/
	queue<int>Q;
	Vertex V,W;
	Visit(S);
	Visited[S]=true;
	Q.push(S);
	
	while(!Q.empty()){
		V=Q.front();
		Q.pop();
		for(W=0;W<Graph->Nv;W++){
			if(!Visited[W]&&IsEdge(Graph,V,W)){
				
				Visit(W);
				Visited[W]=true;
				Q.push(W);
			}
		}
	} 
} 

/*邻接矩阵存储 - 有权图的单源最短路径算法*/

Vertex FindMinDist(MGraph Graph,int dist[],int collected[]){
	/*返回未被收录顶点中dist最小者*/
	Vertex MinV,V;
	int MinDist=INFINITY;
	
	for(V=0;V<Graph->Nv;V++){
		if(collected[V]==false&&dist[V]<MinDist){
			/*若V未被收录，且dist[V]更小*/
			MinDist=dist[V];/*更新最小距离*/
			MinV=V;/*更新对应顶点*/ 
		}
	} 
	if(MinDist<INFINITY)/*若找到最小dist*/
		return MinV; /*返回对应的顶点下标*/
	else 
		return -1;   /*若这样的顶点不存在，返回错误标记*/
} 

bool Dijkstra(MGraph Graph,int dist[],int path[],Vertex S){
	int collected[MaxVertexNum];
	Vertex V,W;
	
	/*初始化：此处默认邻接矩阵中不存在的边用INFINITY*/
	for(V=0;V<Graph->Nv;V++){
		dist[V]=Graph->G[S][V];
		if(dist[V]<INFINITY)
			path[V]=S;
		else
			path[V]=-1;
		collected[V]=false; 
	}
	/*先将起点收入集合*/
	dist[S]=0;
	collected[S]=true;
	
	while(1){
		/*V=未被收录顶点中dist最小者*/
		V=FindMinDist(Graph,dist,collected);
		if(V==-1) /*若这样的V不存在*/ 
			break;/*算法结束*/
		collected[V]=true; /*收录V*/
		for(W=0;W<Graph->Nv;W++){/*对图中的没一个顶点W*/
			/*若W是V的邻接点并且未被收录*/
			if(!collected[W]&&Graph->G[V][W]<INFINITY){
				if(Graph->G[V][W]<0)	/*若有负边*/
					return false;  		/*不能正常解决问题返回错误标记*/
				/*若收录V是的dist[W]变小*/
				if(dist[V]+Graph->G[V][W]<dist[W]){
					dist[W]=dist[V]+Graph->G[V][W];/*更新dist[W]*/
					path[W]=V;/*跟新S到W的路径*/ 
				}
			}
				
		}
	} /*while结束*/
	return true;/*算法执行完毕，返回正确标记*/
} 

/*邻接矩阵 - 多源最短路径算法*/
bool Floyd(MGraph Graph,WeightType D[][MaxVertexNum],Vertex path[][MaxVertexNum]){
	Vertex i,j,k;
	/*初始化*/
	for(i=0;i<Graph->Nv;i++)
		for(j=0;j<Graph->Nv;j++){
			D[i][j]=Graph->G[i][j];
			path[i][j]=-1;
		}
	
	for(k=0;k<Graph->Nv;k++)
		for(i=0;i<Graph->Nv;i++)
			for(j=0;j<Graph->Nv;j++){
				if(D[i][k]+D[k][j]<D[i][j]){
					D[i][j]=D[i][k]+D[k][j];
					if(i==j&&D[i][j]<0)/*若发现负值圈*/
						return false;/*不能正确解决，返回错误标记*/
					path[i][j]=k;
				}
			}
	
	return true;/*算法执行完毕，返回正确标记*/
}

/*邻接矩阵 - Prim最小生成树算法*/

Vertex FindMinDist(MGraph Graph,WeightType dist[]){
	Vertex MinV,V;
	WeightType MinDist=INFINITY;
	
	for(V=0;V<Graph->Nv;V++){
		if(dist[V]!=0&&dist[V]<MinDist){
			/*若V未被收录，且dist[V]更小*/
			MinDist=dist[V];/*更新最小距离*/
			MinV=V; /*更新对应顶点*/
		}
	} 
	
	if(MinDist<INFINITY)/*若找到最小dist*/
		return MinV;	/*返回对应的顶点下标*/ 
	else return ERROR; 	/*若这样的顶点不存在，返回-1作为标记*/	
}

int Prim(MGraph Graph,LGraph MST){
	/*将最小生成树保存为邻接表存储的图MST，返回最小权重和*/
	WeightType dist[MaxVertexNum],TotalWeight;
	Vertex parent[MaxVertexNum],V,W;
	int Count;
	Edge V;
	
	/*初始化。默认初始点下标是0*/
	for(V=0;V<Graph->Nv;V++){
		/*假设若V到W没有直接边，则Graph->G[V][W]定义为INFINITY*/
		dist[V]=Graph->G[0][V];
		parent[V]=0;/*暂且定义所有顶点的父节点都是初始结点0*/
	}	
	
	TotalWeight=0;/*初始化权重和*/
	VCount =0; /*初始化收录的顶点数*/
	/*创建包含所有顶点但没有边的图。注意用邻接表版本*/
	MST=CreateGraph(Graph->Nv);
	E=(Edge)malloc(sizeof(struct ENode));/*建立空的边结点*/
	
	/*将初始化点0收进MST*/
	dist[0]=0;
	VCount++;
	parent[0]=-1;/*当前树根是0*/
	
	while(1){
		V=FindMinDist(Graph,dist);
		/*V=未被收录顶点中dist最小者*/
		if(V==ERROR)/*若这样的V不存在*/
			break;	/*算法结束*/
		
		/*将V及相应的边<parent[V],V>收录进MST*/ 
		E->V1=parent[V];
		E->V2=V;
		E->Weight=dist[V];
		InsertEdge(MST,E);
		TotalWeight+=dist[V];
		dist[V]=0;
		VCount++;
		
		for(W=0;W<Graph->Nv;W++){
			if(dist[W]!=0&&Graph->G[V][W]<INFINITY){
				/*若W是V的邻接点并且未被收录*/
				if(Graph->G[V][W]<dist[W]){
					/*若收录V使得dist[W]变小*/
					dist[W]=Graph->G[V][W];/*更新dist[W]*/ 
					parent[W]=V;/*更新树*/ 
				}
			}
		} 
	} /*while结束*/
	
	if(VCount<Graph->Nv)/*MST中收录的顶点不到|V|个*/
		TotalWeight=ERROR;
	return TotalWeight;  /*算法执行完毕，返回最小权重和或错误标记*/ 
}