用邻接多重表实现图遍历演示

/* c1.h (程序名) */
#include
#include
#include /* malloc()等 */
#include /* INT_MAX等 */
#include /* atoi() */
#include /*文件*/
#include /*字符操作函数*/
#include
#define MAX_NAME 10 /* 顶点字符串的最大长度+1 */
#define FALSE 0
#define TRUE 1
#define OK 1
#define ERROR 0
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int InfoType; /* 权值类型 */
typedef int QElemType;
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef char VertexType[MAX_NAME]; /* 字符串类型 */

/*课本166页无向图的邻接多重表存储表示 */
#define MAX_VERTEX_NUM 30 //最大顶点30
typedef enum{unvisited,visited}VisitIf;

typedef struct EBox /*边集*/
{
VisitIf mark; /* 访问标记 */
int ivex,jvex; /* 该边依附的两个顶点的位置 */
struct EBox *ilink,*jlink; /* 分别指向依附这两个顶点的下一条边 */
InfoType *info; /* 该边信息指针，可指向权值或其他信息 */
}EBox;

typedef struct /*顶点集*/
{
VertexType data;
EBox *firstedge; /* 指向第一条依附该顶点的边 */
}VexBox;

typedef struct /*图 */
{
VexBox adjmulist[MAX_VERTEX_NUM];
int vexnum,edgenum; /* 无向图的当前顶点数和边数 */
}AMLGraph;

typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;


int LocateVex(AMLGraph G,VertexType u)
{ /* 初始条件：无向图G存在，u和G中顶点有相同特征 */
/* 操作结果：若G中存在顶点u，则返回该顶点在无向图中位置；否则返回-1 */
int i;
for(i=0;iif(strcmp(u,G.adjmulist[i].data)==0)
return i;
return -1;
}

void CreateGraph(AMLGraph *G)
{ /* 采用邻接多重表存储结构，构造无向图G */
int i,j,k;
VertexType va,vb;
EBox *p;
printf("请输入无向图的(顶点数,边数): ");
scanf("%d,%d",&(*G).vexnum,&(*G).edgenum);
printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
{
scanf("%s",(*G).adjmulist[i].data);
(*G).adjmulist[i].firstedge=NULL;
}
printf("请顺序输入每条边的两个端点(以空格作为间隔):\n");
for(k=0;k<(*G).edgenum;++k) /* 构造表结点链表 */
{
scanf("%s%s%*c",va,vb); /* %*c吃掉回车符 */
i=LocateVex(*G,va); /* 一端 */
j=LocateVex(*G,vb); /* 另一端 */
p=(EBox*)malloc(sizeof(EBox));
p->mark=unvisited; /* 设初值 */
p->ivex=i;
p->ilink=(*G).adjmulist[i].firstedge; /* 插在表

头 */
(*G).adjmulist[i].firstedge=p;
p->jvex=j;
p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
(*G).adjmulist[j].firstedge=p;
}
}

int FirstAdjVex(AMLGraph G,VertexType v)
{ /* 初始条件：无向图G存在，v是G中某个顶点 */
/* 操作结果：返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点，则返回-1 */
int i;
i=LocateVex(G,v);
if(i<0) /* G中不存在顶点v */
return -1;
if(G.adjmulist[i].firstedge) /* v有邻接顶点 */
if(G.adjmulist[i].firstedge->ivex==i)
return G.adjmulist[i].firstedge->jvex;
else
return G.adjmulist[i].firstedge->ivex;
else
return -1;
}

int NextAdjVex(AMLGraph G,VertexType v,VertexType w)
{ /* 初始条件：无向图G存在，v是G中某个顶点，w是v的邻接顶点 */
/* 操作结果：返回v的(相对于w的)下一个邻接顶点的序号。若w是v的最后一个邻接点，则返回-1 */
int i,j;
EBox *p;
i=LocateVex(G,v); /* i是顶点v的序号 */
j=LocateVex(G,w); /* j是顶点w的序号 */
if(i<0||j<0) /* v或w不是G的顶点 */
return -1;
p=G.adjmulist[i].firstedge; /* p指向顶点v的第1条边 */
while(p)
if(p->ivex==i&&p->jvex!=j) /* 不是邻接顶点w(情况1) */
p=p->ilink; /* 找下一个邻接顶点 */
else if(p->jvex==i&&p->ivex!=j) /* 不是邻接顶点w(情况2) */
p=p->jlink; /* 找下一个邻接顶点 */
else /* 是邻接顶点w */
break;
if(p&&p->ivex==i&&p->jvex==j) /* 找到邻接顶点w(情况1) */
{
p=p->ilink;
if(p&&p->ivex==i)
return p->jvex;
else if(p&&p->jvex==i)
return p->ivex;
}
if(p&&p->ivex==j&&p->jvex==i) /* 找到邻接顶点w(情况2) */
{
p=p->jlink;
if(p&&p->ivex==i)
return p->jvex;
else if(p&&p->jvex==i)
return p->ivex;
}
return -1;
}



Status PutVex(AMLGraph *G,VertexType v,VertexType value)
{ /* v赋新值value */
int i;
i=LocateVex(*G,v);
if(i<0) /* v不是G的顶点 */
return ERROR;
strcpy((*G).adjmulist[i].data,value);
return OK;
}

Status InsertVex(AMLGraph *G,VertexType v)
{ /* 初始条件：无向图G存在，v和G中顶点有相同特征 */
/* 操作结果：在G中增添新顶点v(不增添与顶点相关的弧，留待InsertArc()去做) */
if((*G).vexnum==MAX_VERTEX_NUM) /* 结点已满，不能插入 */
return ERROR;
if(LocateVex(*G,v)>=0) /* 结点已存在，不能插入 */
return ERROR;
strcpy((*G).adjmulist[(*G).vexnum].data,v);
(*G).adjmulist[(*G).vexnum++].firstedge=NULL;
return OK;
}

Status InsertArc(AMLGraph *G,VertexType v,VertexType w)
{ /* 初始条件：无向图G存在，v和W是G中两个顶点。操作结果：在G中增添弧 */
int i,j;
EBox *p;
i=LocateVex(*G,v); /* 一端 */
j=LocateVex(*G,w); /* 另一端 */

if(i<0||j<0||i==j)
return ERROR;
p=(EBox*)malloc(sizeof(EBox));
p->mark=unvisited;
p->ivex=i;
p->ilink=(*G).adjmulist[i].firstedge; /* 插在表头 */
(*G).adjmulist[i].firstedge=p;
p->jvex=j;
p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
(*G).adjmulist[j].firstedge=p;
(*G).edgenum++;
return OK;
}


Status DeleteArc(AMLGraph *G,VertexType v,VertexType w)
{ /* 初始条件：无向图G存在，v和w是G中两个顶点。操作结果：在G中删除弧 */
int i,j;
EBox *p,*q;
i=LocateVex(*G,v);
j=LocateVex(*G,w);
if(i<0||j<0||i==j)
return ERROR; /* 图中没有该点或弧。以下使指向待删除边的第1个指针绕过这条边 */
p=(*G).adjmulist[i].firstedge; /* p指向顶点v的第1条边 */
if(p&&p->jvex==j) /* 第1条边即为待删除边(情况1) */
(*G).adjmulist[i].firstedge=p->ilink;
else if(p&&p->ivex==j) /* 第1条边即为待删除边(情况2) */
(*G).adjmulist[i].firstedge=p->jlink;
else /* 第1条边不是待删除边 */
{
while(p) /* 向后查找弧 */
if(p->ivex==i&&p->jvex!=j) /* 不是待删除边 */
{
q=p;
p=p->ilink; /* 找下一个邻接顶点 */
}
else if(p->jvex==i&&p->ivex!=j) /* 不是待删除边 */
{
q=p;
p=p->jlink; /* 找下一个邻接顶点 */
}
else /* 是邻接顶点w */
break;
if(!p) /* 没找到该边 */
return ERROR;
if(p->ivex==i&&p->jvex==j) /* 找到弧(情况1) */
if(q->ivex==i)
q->ilink=p->ilink;
else
q->jlink=p->ilink;
else if(p->ivex==j&&p->jvex==i) /* 找到弧(情况2) */
if(q->ivex==i)
q->ilink=p->jlink;
else
q->jlink=p->jlink;
} /* 以下由另一顶点起找待删除边且删除之 */
p=(*G).adjmulist[j].firstedge; /* p指向顶点w的第1条边 */
if(p->jvex==i) /* 第1条边即为待删除边(情况1) */
(*G).adjmulist[j].firstedge=p->ilink;
else if(p->ivex==i) /* 第1条边即为待删除边(情况2) */
(*G).adjmulist[j].firstedge=p->jlink;
else /* 第1条边不是待删除边 */
{
while(p) /* 向后查找弧 */
if(p->ivex==j&&p->jvex!=i) /* 不是待删除边 */
{
q=p;
p=p->ilink; /* 找下一个邻接顶点 */
}
else if(p->jvex==j&&p->ivex!=i) /* 不是待删除边 */
{
q=p;
p=p->jlink; /* 找下一个邻接顶点 */
}
else /* 是邻接顶点v */
break;
if(p->ivex==i&&p->jvex==j) /* 找到弧(情况1) */
if(q->ivex==j)
q->ilink=p->jlink;
else
q->jlink=p->jlink;
else if(p->ivex==j&&p->jvex==i) /* 找到弧(情况2) */
if(q->ivex==j)
q->ilink=p->ilink;
else
q->jlink=p->ilink;
}
free(p); /* 释放

结点 */
(*G).edgenum--; /* 边数-1 */
return OK;
}

Status DeleteVex(AMLGraph *G,VertexType v)
{ /* 初始条件：无向图G存在，v是G中某个顶点。操作结果：删除G中顶点v及其相关的边 */
int i,j;
EBox *p;
i=LocateVex(*G,v); /* i为待删除顶点的序号 */
if(i<0)
return ERROR;
for(j=0;j<(*G).vexnum;j++) /* 删除与顶点v相连的边(如果有的话) */
DeleteArc(G,v,(*G).adjmulist[j].data); /* 如果存在此弧，则删除 */
for(j=i+1;j<(*G).vexnum;j++) /* 排在顶点v后面的顶点的序号减1 */
(*G).adjmulist[j-1]=(*G).adjmulist[j];
(*G).vexnum--; /* 顶点数减1 */
for(j=i;j<(*G).vexnum;j++) /* 修改序号大于i的顶点在表结点中的序号 */
{
p=(*G).adjmulist[j].firstedge;
if(p)
if(p->ivex==j+1)
{
p->ivex--;
p=p->ilink;
}
else
{
p->jvex--;
p=p->jlink;
}
}
return OK;
}


void visit(VertexType v)
{
printf("%s ",v);
}
//以下课本169页算法
Boolean visite[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
void(*VisitFunc)(VertexType v);

void DFS(AMLGraph G,int v)
{
int j;
EBox *p;
VisitFunc(G.adjmulist[v].data);
visite[v]=TRUE;
p=G.adjmulist[v].firstedge;
while(p)
{
j=p->ivex==v?p->jvex:p->ivex;
if(!visite[j])
DFS(G,j);
p=p->ivex==v?p->ilink:p->jlink;
}
}


void DFSTraverse(AMLGraph G,void(*visit)(VertexType))
{ /* 初始条件：图G存在，Visit是顶点的应用函数。算法7.4 */
/* 操作结果：从第1个顶点起，深度优先遍历图G，并对每个顶点调用函数Visit一次且仅一次 */
int v;
int j ;
char t[20];
VisitFunc=visit;
for(v=0;vvisite[v]=FALSE;
printf("深度优先起点：");
scanf("%s",t);
j=LocateVex(G,t); //第一个访问的节点
printf("结果：");
for(v=j;vif(!visite[v])
DFS(G,v);
printf("\n");
}


Status QueueEmpty(LinkQueue Q)
{ /* 若Q为空队列，则返回TRUE，否则返回FALSE */
if(Q.front->next==NULL)
return TRUE;
else
return FALSE;
}

void EnQueue(LinkQueue *Q,QElemType e)
{ /* 插入元素e为Q的新的队尾元素 */
QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
if(!p) /* 存储分配失败 */
exit(ERROR);
p->data=e;
p->next=NULL;
(*Q).rear->next=p;
(*Q).rear=p;
}

Status DeQueue(LinkQueue *Q,QElemType *e)
{ /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */
QueuePtr p;
if((*Q).front==(*Q).rear)
return ERROR;
p=(*Q).front->next;
*e=p->data;
(*Q).front->next=p->next;
if((*Q).rear==p)
(*Q).rear=(*Q).front;
free(p);
return OK;
}

void InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
(*Q).front=(*Q).rear=(QueuePtr)ma

lloc(sizeof(QNode));
if(!(*Q).front)
exit(ERROR);
(*Q).front->next=NULL;
}

void BFSTraverse(AMLGraph G,void(*Visit)(VertexType))
{ /* 初始条件：图G存在，Visit是顶点的应用函数。算法7.6 */
/* 操作结果：从第1个顶点起，按广度优先非递归遍历图G，并对每个顶点调用函数 */
/* Visit一次且仅一次。使用辅助队列Q和访问标志数组visite */
int v,u,w,j;
char t[20];
LinkQueue Q;
for(v=0;vvisite[v]=FALSE; /* 置初值 */
InitQueue(&Q); /* 置空的辅助队列Q */
printf("广度优先起点：");
scanf("%s",t);
j=LocateVex(G,t); //第一个访问的节点
printf("结果：");
for(v=j;vif(!visite[v]) /* v尚未访问 */
{
visite[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
Visit(G.adjmulist[v].data);
EnQueue(&Q,v); /* v入队列 */
while(!QueueEmpty(Q)) /* 队列不空 */
{
DeQueue(&Q,&u); /* 队头元素出队并置为u */
for(w=FirstAdjVex(G,G.adjmulist[u].data);w>=0;w=NextAdjVex(G,G.adjmulist[u].data,G.adjmulist[w].data))
if(!visite[w]) /* w为u的尚未访问的邻接顶点的序号 */
{
visite[w]=TRUE;
Visit(G.adjmulist[w].data);
EnQueue(&Q,w);
}
}
}
printf("\n");
}


void MarkUnvizited(AMLGraph G)
{ /* 置边的访问标记为未被访问 */
int i;
EBox *p;
for(i=0;i{
p=G.adjmulist[i].firstedge;
while(p)
{
p->mark=unvisited;
if(p->ivex==i)
p=p->ilink;
else
p=p->jlink;
}
}
}

void Save(AMLGraph G)
{ int i;
EBox *p;
FILE *fp;
char filename[30]; /*指向文件的指针*/
MarkUnvizited(G); /* 置边的访问标记为未被访问 */
printf("请输入数据文件名：");
scanf("%s",filename);
if((fp=fopen(filename,"wb"))==NULL) /*打开文件，并判断打开是否正常*/
{
printf("不能打开文件\n"); /*没打开*/
exit(1); /*退出*/
}
printf("保存文件\n"); /*输出提示信息*/
fprintf(fp,"%-2d",G.vexnum); /*顶点数写入文件*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
fprintf(fp,"%-2d",G.edgenum); /*边数写入文件*/
fprintf(fp,"\r\n");
for(i=0;i{ fprintf(fp,"%-10s",G.adjmulist[i].data);
fprintf(fp,"\r\n"); } /*将换行符号写入文件*/
/*以下把边的名字写入文件*/
for(i=0;i{
p=G.adjmulist[i].firstedge;
while(p)
if(p->ivex==i) /* 边的i端与该顶点有关 */
{
if(!p->mark) /* 只输出一次 */
{
fprintf(fp,"%-10s%-10s ",G.adjmul

ist[i].data,G.adjmulist[p->jvex].data);
fprintf(fp,"\r\n");
p->mark=visited;
}
p=p->ilink;
}
else /* 边的j端与该顶点有关 */
{
if(!p->mark) /* 只输出一次 */
{
fprintf(fp,"%-10s%-10s ",G.adjmulist[p->ivex].data,G.adjmulist[i].data);
fprintf(fp,"\r\n");
p->mark=visited;
}
p=p->jlink;
}
}
fclose(fp); /*关闭文件*/
printf(" ****祝贺你！保存成功***\n");
}

void Load(AMLGraph *G)
{ int i,j,k;
VertexType va,vb;
EBox *p;
char filename[30];
FILE *fp; /*指向文件的指针*/
printf("请输入数据文件名(1.2.txt)：");
scanf("%s",filename);
if((fp=fopen(filename,"rb"))==NULL) /*打开文件，并判断打开是否正常*/
{
printf("不能打开文件\n"); /*没打开*/
exit(1); /*退出*/
}
fscanf(fp,"%2d",&G->vexnum); /*读入记录数*/
fscanf(fp,"%2d",&G->edgenum);

for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
{
fscanf(fp,"%10s",&G->adjmulist[i].data);
(*G).adjmulist[i].firstedge=NULL;
}
// printf("请顺序输入每条边的两个端点(以空格作为间隔):\n");
for(k=0;k<(*G).edgenum;++k) /* 构造表结点链表 */
{
fscanf(fp,"%10s%10s%",va,vb);
i=LocateVex(*G,va); /* 一端 */
j=LocateVex(*G,vb); /* 另一端 */
p=(EBox*)malloc(sizeof(EBox));
p->mark=unvisited; /* 设初值 */
p->ivex=i;
p->ilink=(*G).adjmulist[i].firstedge; /* 插在表头 */
(*G).adjmulist[i].firstedge=p;
p->jvex=j;
p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
(*G).adjmulist[j].firstedge=p;
}

fclose(fp); /*关闭文件*/
printf(" 祝贺你成功读入文件内容！！！\n");
/*返回记录数*/
}

void Display(AMLGraph G)
{ /* 输出无向图的邻接多重表G */
int i;
EBox *p;
MarkUnvizited(G); /* 置边的访问标记为未被访问 */
printf("有%d个顶点：\n",G.vexnum);
for(i=0;iprintf("%s\n",G.adjmulist[i].data);
printf("\n有%d条边:\n",G.edgenum);
for(i=0;i{
p=G.adjmulist[i].firstedge;
while(p)
if(p->ivex==i) /* 边的i端与该顶点有关 */
{
if(!p->mark) /* 只输出一次 */
{
printf("%s－%s \n",G.adjmulist[i].data,G.adjmulist[p->jvex].data);
p->mark=visited;
}
p=p->ilink;
}
else /* 边的j端与该顶点有关 */
{
if(!p->mark) /* 只输出一次 */
{
printf("%s－%s \n",G.adjmulist[p->ivex].data,G.adjmulist[i].data);
p->mark=visited;
}

p=p->jlink;
}
}
}




/*菜单函数，函数返回值为整数，代表所选的菜单项*/
menu_select()
{
char s[80];
int c;

printf("press any key enter menu......\n");/*提示压任意键继续*/
getch(); /*读入任意字符*/
system("cls"); /*清屏*/

printf("\n ┏━━━━━━━━━━━菜单━━━━━━━━━━━━━┓\n");
printf(" ┃☆ §№0. 创建图 ☆┃\n");
printf(" ┃☆ §№1. 打印关系图 ☆┃\n");
printf(" ┃☆ §№2. 深度优先搜索 ☆┃\n");
printf(" ┃☆ §№3. 广度优先搜索 ☆┃\n");
printf(" ┃☆ §№4. 修改顶点的值 ☆┃\n");
printf(" ┃☆ §№5. 插入新顶点 ☆┃\n");
printf(" ┃☆ §№6. 删除一条边 ☆┃\n");
printf(" ┃☆ §№7. 删除顶点及相关的边 ☆┃\n");
printf(" ┃☆ §№8. 读入文件信息 ☆┃\n");
printf(" ┃☆ §№9. 以文件保存信息 ☆┃\n");
printf(" ┃☆ §№10. 程序结束 ☆┃\n");
printf(" ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
do{
printf("\n 请选择(№0~~~№10):"); /*提示输入选项*/
scanf("%s",s);
c=atoi(s); /*将输入的字符串转化为整型数*/
}while(c<0||c>10); /*选择项不在0~10之间重输*/
return c; /*返回选择项*/
}


/******主函数开始*******/
main()
{ int k,n;
AMLGraph g;
VertexType v1,v2;
system("cls") ; /*清屏*/

for(;;)/*无限循环*/
{
switch(menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/
{
case 0:CreateGraph(&g);break; /*输入记录*/
case 1:Display(g);break; /*显示全部记录*/
case 2:printf("采用深度优先搜索的方法\n");
DFSTraverse(g,visit);break; /**/
case 3:printf("采用广度优先搜索的方法:\n");
BFSTraverse(g,visit);;break; /*广度优先搜索*/
case 4:printf("修改顶点的值，请输入原值 新值: ");
scanf("%s%s",v1,v2); //修改顶点的值
PutVex(&g,v1,v2);;break; /*插入记录*/
case 5:printf("插入新顶点，请输入顶点的值: ");
scanf("%s",v1);
InsertVex(&g,v1);
printf("插入与新顶点有关的边，请输入边数: ");
scanf("%d",&n);
for(k=0;k{
printf("请

输入另一顶点的值: ");
scanf("%s",v2);
InsertArc(&g,v1,v2);
};break; /*显示即将过期的送货单*/
case 6:printf("删除一条边，请输入待删除边的两顶点(以空格作为间隔)：");
scanf("%s%s",v1,v2);
DeleteArc(&g,v1,v2);;break; /**/
case 7:printf("删除顶点及相关的边，请输入顶点的值: ");
scanf("%s",v1);
DeleteVex(&g,v1);; break; /**/
case 8:Load(&g);break; /**/
case 9:Save(g);break;
case 10:exit(0); /*如返回值为10则程序结束*/
}
}
}