<pre name="code" class="cpp">#ifndef Graph_H
#define MAX_VEX_NUM 20
#define OK 1
#define MAX_NAME 3/*顶点字符串的最大长度+1*/
#define MAX_INFO 20/*相关字符串的最大长达+1*/
/结构定义//
//图的种类有向图,有向网,无向图,无向网
typedef enum{DG,DN,AG,AN} GraphKind ;
typedef int InfoType ;
typedef char VertexType[MAX_NAME];
typedef int Status ;
typedef int VRType;
typedef struct ArcNode{
int adjvex; //该弧指向的顶点的位置
struct ArcNode *nextarc; //指向下一条弧的指针
InfoType *info ; //网的权值指针
}ArcNode; /*表结点*/
typedef struct{
VertexType data ; //顶点信息
ArcNode *firstarc; //指向第一条弧
}VNode,AdjList[MAX_VEX_NUM];
typedef struct{
AdjList vertices; //顶点的数组
int vexnum,arcnum ;//图当前顶点的个数和弧数
int kind ; //图的种类
}ALGraph;
//最小生成树
/*辅助结构*/
typedef struct Minimum{ //此结构存放当前过程中V中各节点到U中各节点的最小权值信息
VertexType data; //保存U中与V中该结点相连接的结点值,使V中该结点到U中各节点间权值最小
VRType lowcost; //保存两结点间最小的权值(代价)
int flag; //表示V中该结点在某一过程中是否被更新的标志,flag=0表示尚未更新,flag=1表示已经更新,不用再更新了,图使用邻接表存储时要注意设置此标志,以免某一结点的minimum结构被更新多次,得不到正确的最小权值
}Minimum,closedge[20];
//
操作定义///
int LocateVex(ALGraph G,VertexType u);
Status CreateGraph(ALGraph *G);
void Destory(ALGraph *G);
VertexType* GetVex(ALGraph G ,int v);
Status PutVex(ALGraph *G, VertexType v,VertexType value);
int FirstAdjVex(ALGraph G,VertexType v);
int NextAdjVex(ALGraph G,VertexType v,VertexType w);
void InsertVex(ALGraph *G, VertexType v);
Status DeleteVex(ALGraph *G, VertexType v);
Status InserArc(ALGraph *G, VertexType v,VertexType w);
Status DeleteArc(ALGraph *G,VertexType v,VertexType w);
void DFS(ALGraph G,int v);
void DFSTraverse(ALGraph G);
void BFSTraverse(ALGraph G);
void Display(ALGraph G);
void Visit(char s[]);
int minimum(ALGraph G,closedge MinEdge);
void MinSpanTree(ALGraph G,VertexType u);
//
//队列
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
typedef struct QNode{
QElemType data ;
struct QNode *next ;
}QNode , *QueuePtr;
typedef struct {
QueuePtr front ;
QueuePtr rear ;
}LinkQueue;
//--------基本操作------------
Status InitQueue(LinkQueue &Q);
Status DestroyQueue(LinkQueue &Q);
Status ClearQueue(LinkQueue &Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q,QElemType &e);
Status EnQueue(LinkQueue &Q,QElemType e);
Status DeQueue(LinkQueue &Q,QElemType &e);
bool IsEmpty(LinkQueue Q);
//
#endif
</pre><p></p><p><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"
//操作的具体实现//
int LocateVex(ALGraph G,VertexType u){
/*初始条件:图G存在,u和G中的顶点有相同的特征*/
/*操作结果: 若u在G中,则返回u顶点的位置,否则返回-1*/
int i ;
for(i=0;i<G.arcnum;i++)
if(strcmp(u,G.vertices[i].data)==0)
return i ;
return -1 ;
}
Status CreateGraph(ALGraph *G){
/*采用邻接表存储结构,构造没哟u相关信息的图G(用一个函数构造4中图)*/
int i,j,k;
int w ; /*权重*/
VertexType va,vb ;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d",&((*G).kind));
printf("%d",G->kind);
printf("请输入图的顶点数,边数: ");
scanf("%d,%d",&((*G).vexnum),&((*G).arcnum));
printf("请输入%d个顶点的值(<%d个字符): \n",G->vexnum,MAX_NAME);
/*构造顶点向量*/
for(i=0;i<G->vexnum;i++){
scanf("%s",&(*G).vertices[i].data);
(*G).vertices[i].firstarc=NULL ;
}
if(G->kind==1||G->kind==3)/*网*/
printf("请输入每条弧(边)的权值,弧尾和弧头(以空格作为间隔): \n");
else /*图*/
printf("请顺序输入每条弧的弧尾和弧头(以空格作为间隔): \n");
for(k=0;k<G->arcnum;k++){
if(G->kind==1||G->kind==3)
scanf("%d%s%s",&w,va,vb);
else
scanf("%s%s",va,vb);
i=LocateVex(*G,va); /*弧尾*/
j=LocateVex(*G,vb); /*弧头*/
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
if(G->kind==1||G->kind==3){//网
p->info= (int *)malloc(sizeof(int));
*(p->info)=w;
}else{
p->info=NULL;
}
p->nextarc = G->vertices[i].firstarc;/*插在表头*/
G->vertices[i].firstarc = p;
if(G->kind>=2){/*无向图,或网产生第二个结点*/
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=i;
if(G->kind==3){
p->info=(int *)malloc(sizeof(int));
*(p->info)=w;
}else
p->info=NULL;
p->nextarc = G->vertices[j].firstarc;
G->vertices[j].firstarc=p;
}
}
return OK ;
}
void Destory(ALGraph *G){
/*初始条件:图G存在,操作结果:销毁G*/
int i ;
ArcNode *p,*q;
for(i=0;i<G->vexnum;i++){
p=G->vertices[i].firstarc;
while(p){
q=p->nextarc;
if(G->kind%2){/*网,这与前面的规定顺序有关*/
free(p->info);
}
free(p);
p=q;
}
}
G->arcnum = 0;
G->vexnum = 0;
}
VertexType* GetVex(ALGraph G,int v){
/*初始条件:图G存在,v是图中某个顶点的序号.*/
/*操作结果:返回序号为v顶点的值*/
//1.判断位置,体现程序的健壮性
if(v>G.vexnum||v<0){
printf("位置不正确\n");
exit(-1);
}
return &G.vertices[v].data;
}
Status PutVex(ALGraph *G, VertexType v,VertexType value){
/*初始条件:图G存在,v为图中顶点,value为替换v的值*/
/*操作结果:将图G中的v替换成新的值value*/
int i ;
i= LocateVex(*G,v);
if(i<0){
printf("图G中不存在值为%d的顶点\n",v);
return -1;
}
strcpy(G->vertices[i].data , value) ;
return OK ;
}
int FirstAdjVex(ALGraph G,VertexType v){
/*初始条件:图G存在,v为图G中的某个顶点*/
/*操作结果:返回v的第一个邻接顶点的序号,若不存在则返回-1*/
ArcNode *p;
int v1 ;//顶点v在图G中的序号
v1= LocateVex(G,v);
p=G.vertices[v1].firstarc;
if(p)
return p->adjvex;
return -1 ;
}
int NextAdjVex(ALGraph G,VertexType v,VertexType w){
/*初始条件:图G存在,v是G中的某个顶点,w是v的邻接顶点*/
/*操作结果:返回v(相对于w)的下一个邻接顶点的序号,若w是最后一个节点,返回-1*/
ArcNode *p;
int v1,w1 ;
v1 = LocateVex(G,v);
w1 = LocateVex(G,w);/*w1为w在G中的位置*/
p=G.vertices[v1].firstarc;
while(p&&p->adjvex!=w1)
p=p->nextarc;
if(!p||!p->nextarc)
return -1 ;
else /*p->adjvex=w1*/
return p->nextarc->adjvex;
}
void InsertVex(ALGraph *G, VertexType v){
/*初始条件:图G存在,v和图中顶点相同特征*/
/*操作结果:在图G中增添顶点,不添加与顶点相关的弧,招待InsertArc去做*/
strcpy( G->vertices[G->vexnum].data , v);
G->vertices[G->vexnum].firstarc = NULL;
G->vexnum++; /*图G的顶点数加1*/
}
Status DeleteVex(ALGraph *G, VertexType v){
/*初始条件:图G存在,v是图G中的某个顶点*/
/*操作结果:删除G中的顶点v*/
int i,j;
ArcNode *p,*q ;
j = LocateVex(*G,v);
if(j<0) /*v不是图G中的顶点*/
return -1;
p=G->vertices[j].firstarc;/*删除以v为出度的节点*/
while(p){
q=p;
p=p->nextarc;
if(G->kind%2)/*网*/
free(q->info);
free(q);
G->arcnum--;/*弧或边减少1*/
}
for(i=j;i<G->vexnum;i++)
G->vertices[i]=G->vertices[i+1];/*顶点数组向前移*/
G->vexnum--;/*顶点减少1*/
for(i=0;i<G->vexnum;i++){/*删除以v为入度的弧或边且必要的时候修改表节点的顶点的位置*/
p=G->vertices[i].firstarc;
while(p){/*有弧*/
if(p->adjvex==j){
if(p==G->vertices[i].firstarc){/*待删除的是第一个结点*/
G->vertices[i].firstarc=p->nextarc;
if(G->kind%2) /*网,则销毁info信息*/
free(p->info);
free(p);
p=G->vertices[i].firstarc;
if(G->kind<2)
G->arcnum--;
}else{
q->nextarc=p->nextarc;
if(G->kind%2)
free(p->info);
free(p);
p=q->nextarc;
if(G->kind<2)
G->arcnum--;
}
}else{
if(p->adjvex>j)
p->adjvex--;/*修改表结构的顶点位置值(序号)*/
q=p;
p=p->nextarc;
}
}
}
return OK;
}
Status InserArc(ALGraph *G, VertexType v,VertexType w){
/*初始条件:图G存在,v,w是G中的两个顶点*/
/*操作结果:在G曾增加<v,w>的一条弧,若是无向图则增加另一条<w,v>的弧*/
ArcNode *p ;
int w1,i,j ;
i=LocateVex(*G,v);
j=LocateVex(*G,w);
if(i<0||j<0)
return -1;
G->arcnum++;
if(G->kind%2){/*网*/
printf("请输入弧(边)%s->%s的权值: ");
scanf("%d",&w1);
}
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
if(G->kind%2){/*网*/
p->info = (int *)malloc(sizeof(int));
*(p->info)=w1;
}else{
p->info=NULL;
}
p->nextarc=G->vertices[i].firstarc;
G->vertices[i].firstarc=p;
if(G->kind>=2){/*无向,生成另一条表结点*/
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=i;
if(G->kind==3){/*无向网*/
p->info = (int *)malloc(sizeof(int));
*(p->info)=w1;
}else{
p->info=NULL;
}
p->nextarc=G->vertices[j].firstarc;
G->vertices[j].firstarc=p;
}
return OK ;
}
Status DeleteArc(ALGraph *G,VertexType v,VertexType w){
/*初始条件:图G存在,v和w分别是G中的顶点*/
/*操作结果:删除G中<v,w>的弧或边,若是无向图,则删除另一条<w,v>的边或弧*/
int i,j;
ArcNode *p,*q;
i=LocateVex(*G,v);
j=LocateVex(*G,w);
//健壮性判断
if(i<0||j<0||i==j)
return -1;
p=G->vertices[i].firstarc;/*指向顶点v的第一条弧*/
while(p&&p->adjvex!=j){
q=p;
p=p->nextarc;
}
if(p&&p->adjvex==j)/*找到弧<v,w>*/
{
/*分两种情况分别处理:1.是第一个邻接点2.是后面的邻接点*/
if(p==G->vertices[i].firstarc){
G->vertices[i].firstarc=p->nextarc;
}else{
q->nextarc=p->nextarc;
}
if(G->kind%2)
free(p->info);
free(p);
G->arcnum--;
}
if(G->kind>=2){//无向图或网
p=G->vertices[j].firstarc;/*指向w的第一条弧或边*/
while(p&&p->adjvex!=i){
q=p;
p=p->nextarc;
}
if(p&&p->adjvex==i){
if(p==G->vertices[j].firstarc)
G->vertices[j].firstarc= p->nextarc;
else
q->nextarc=p->nextarc;
if(G->kind==3)
free(p->info);
free(p);
}
}
return OK ;
}
bool visited[MAX_VEX_NUM] ;
void DFS(ALGraph G,int v){
int w ;
VertexType v1,w1;
strcpy(v1,*GetVex(G,v));
visited[v]=true;/*标志已经访问*/
Visit(G.vertices[v].data);
for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
if(!visited[w])
DFS(G,w);
}
void DFSTraverse(ALGraph G){
/*对图深度优先遍历*/
int v;/*顶点的序号*/
for(v=0;v<G.vexnum;v++){
visited[v]=false;
}
for(v=0;v<G.vexnum;v++)
if(!visited[v])
DFS(G,v);
printf("\n");
}
void BFSTraverse(ALGraph G){
/*广度优先搜索(非递归),需要一个辅助队列Q和访问标志visited[]数组*/
int v,u,w ;
VertexType u1,w1 ;
LinkQueue Q ;
for(v=0;v<G.vexnum;v++){
visited[v]=false;
}
InitQueue(Q);
for(v=0;v<G.vexnum;v++){/*若是连通图,v=0就能遍历全部顶点*/
if(!visited[v]){
visited[v]= true;
Visit(G.vertices[v].data);
EnQueue(Q,v);
while(!IsEmpty(Q)){/*队列不空*/
DeQueue(Q,u);
strcpy(u1,*GetVex(G,u));
for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))){
if(!visited[w]){
visited[w]=true;
Visit(G.vertices[w].data);
EnQueue(Q,w);
}
}
}
}
}
printf("\n");
}
/***************最小生成树算法*************/
int minimum(ALGraph G,closedge MinEdge){ //寻找V中各节点到U中各节点间最小的权值,返回结点的编号
int i,j,first,min;
for(i=0;i<G.vexnum;i++){ /*获得MinEdge中第一个lowcost不为0的位置*/
if(MinEdge[i].lowcost!=0){ //MinEdge[i].lowcost==0说明编号为i的结点在U中
min=MinEdge[i].lowcost; /*记当前的第一个lowcost不为0,默认为最小值*/
first=i; /*记住默认最小值的当前位置*/
break;
}
}
k=i;
for(i=first;i<G.vexnum;i++){ /*循环遍历获得最小值为位置*/
if(min>MinEdge[i].lowcost&&MinEdge[i].lowcost!=0){
min=MinEdge[i].lowcost;
k=i;
}
}
return k;
}
void MinSpanTree(ALGraph G,VertexType u){ //从图中结点u开始生成最小生成树的过程
int i,k;
ArcNode *p;
closedge MinEdge;
k=LocateVex(G,u);
for(i=0;i<G.vexnum;i++)
MinEdge[i].flag=0; //访问标志初始化为0
/******初始化MinEdge数组*****/
/*初始化的算法为:*/
for(i=0;i<G.vexnum;i++){
if(i!=k){
strcpy(MinEdge[i].data,u);
for(p=G.vertices[i].firstarc;p!=NULL;p=p->nextarc){
if(p->adjvex==k){ //p->adjvex==k说明编号为i的结点与编号为k的结点间有弧连接,需要把MinEdge的lowcost修改为弧上的权值
MinEdge[i].lowcost=*(p->info);
MinEdge[i].flag=1; //设置标志,表示编号为i的结点在这一过程中已更新过权值
}
else if(MinEdge[i].flag==0)
MinEdge[i].lowcost=100;
}
}
strcpy(MinEdge[k].data,G.vertices[k].data);
MinEdge[k].lowcost=0;
}
for(i=1;i<G.vexnum;i++){
k=minimum(G,MinEdge);
printf("(%s-%s):%d",G.vertices[k].data,MinEdge[k].data,MinEdge[k].lowcost);
MinEdge[k].lowcost=0; //将结点加入U中
for(p=G.vertices[k].firstarc;p!=NULL;p=p->nextarc){
if(MinEdge[p->adjvex].lowcost>*(p->info)){
MinEdge[p->adjvex].lowcost=*(p->info);
strcpy( MinEdge[p->adjvex].data,G.vertices[k].data);
}
}
}
}
/******************************************/
void Display(ALGraph G){
/*输出图的邻接矩阵*/
int i ;
ArcNode *p;
switch(G.kind){
case DG:printf("有向图\n");
break;
case DN:printf("有向网\n");
break ;
case AG:printf("无向图\n");
break;
case AN:printf("无向网\n");
break;
}
printf("%d个顶点: \n",G.vexnum);
for(i=0;i<G.vexnum;i++){
printf("%s",G.vertices[i].data);
}
printf("\n%d条弧(边)",G.arcnum);
for(i=0;i<G.vexnum;i++){
p=G.vertices[i].firstarc;
while(p){
if(G.kind<=1){//有向
printf("%s->%s",G.vertices[i].data,G.vertices[p->adjvex].data);
if(G.kind==DN)/*网*/
printf(":%d",*(p->info));
}else{//无向
if(i<p->adjvex){
printf("%s-%s",G.vertices[i].data,G.vertices[p->adjvex].data);
if(G.kind==AN)
printf(":%d",*(p->info));
}
}
p=p->nextarc;
}
printf("\n");
}
}
void Visit(char str[]){
printf("%s",str);
}
/*****************队列实现******************************/
Status InitQueue(LinkQueue &Q){
Q.front = Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front) exit(OVERFLOW);
Q.front->next = NULL;
return OK ;
}
Status EnQueue(LinkQueue &Q,QElemType e){
QueuePtr p =NULL ;
p= (QueuePtr)malloc(sizeof(QNode));
if(!p) exit(OVERFLOW);
p->data = e ;
Q.rear->next=p;
Q.rear = p;
p->next=NULL;
return OK ;
}
Status DeQueue(LinkQueue &Q,QElemType &e){
if(Q.front==Q.rear)
return ERROR ;//队列为空
QueuePtr p=NULL;
p= Q.front->next;
e= p->data ;
Q.front->next = p->next;
if(Q.rear==p) //队列中只有一个元素
Q.rear=Q.front;
free(p);
return OK ;
}
Status DestroyQueue(LinkQueue &Q){
while(Q.front){
Q.rear = Q.front->next;
free(Q.front);
Q.front = Q.rear;
}
return OK ;
}
int QueueLength(LinkQueue Q){
int length =0 ;
QueuePtr p ;
if(Q.front==Q.rear) return ERROR ;
p= Q.front->next ;
while(p!=NULL){
length++ ;
p=p->next ;
}
return length ;
}
bool IsEmpty(LinkQueue Q)//判断队列是否为空
{
return Q.front == Q.rear ? true : false;
}
/*****************************************************************/
void main(){
ALGraph G ;
CreateGraph(&G);
Display(G) ;
// printf("%c",GetVex(G,3));
// Destory(&G);
// Display(G) ;
// PutVex(&G,'A','F');
// Display(G) ;
// int i= FirstAdjVex(G,"B");
// printf("pos=%d:value=%s\n",i,G.vertices[i].data);
// int i=NextAdjVex(G,"A","C");
// printf("pos=%d:value=%s\n",i,G.vertices[i].data);
// InsertVex(&G, "E");
// Display(G);
// DeleteVex(&G,"A");
// Display(G);
// InserArc(&G,"C","D");
// Display(G);
DFSTraverse(G);
BFSTraverse(G);
MinSpanTree(G,"v1");
}
有向图,十字链表实现: