数据结构图的代码填写
void TransforMtoAL(MGraph G1,ALGraph &G2)
麻烦帮忙改改这个函数,编译没有问题,但是运行结果出错
请用c语言的
运行结果
整段代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
int ERROR=0,OK=1,TRUE=1,FALSE=0;
#define INFINITY 10000 /* 用整型最大值代替∞ */
#define MAX_VERTEX_NUM 20 /* 最大顶点个数 */
#define MAX_NAME 5 /* 顶点字符串的最大长度+1 */
#define MAX_INFO 20 /* 相关信息字符串的最大长度+1 */
typedef int VRType;
typedef int Status;
typedef char InfoType;
typedef char VertexType[MAX_NAME];
typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */
/* 定义邻接矩阵类型 */
typedef struct
{
VRType adj; /* 顶点关系类型。对无权图,用1(是)或0(否)表示相邻否; */
/* 对带权图,c则为权值类型 */
InfoType *info; /* 该弧相关信息的指针(可无) */
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
VertexType vexs[MAX_VERTEX_NUM]; /* 顶点向量 */
AdjMatrix arcs; /* 邻接矩阵 */
int vexnum,arcnum; /* 图的当前顶点数和弧数 */
GraphKind kind; /* 图的种类标志 */
}MGraph;
/* 定义邻接表类型 */
typedef struct ArcNode
{
int adjvex; /* 该弧所指向的顶点的位置 */
struct ArcNode *nextarc; /* 指向下一条弧的指针 */
VRType adj;
InfoType *info; /* 网的权值指针) */
}ArcNode; /* 表结点 */
typedef struct
{
VertexType data; /* 顶点信息 */
ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
}VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */
typedef struct
{
AdjList vertices;
int vexnum,arcnum; /* 图的当前顶点数和弧数 */
int kind; /* 图的种类标志 */
}ALGraph;
typedef struct
{ /* 记录从顶点集U到V-U的代价最小的边的辅助数组定义 */
VertexType adjvex;
VRType lowcost;
}minside[MAX_VERTEX_NUM];
void DFS(MGraph G,int v);
int minimum(minside SZ,MGraph G)
{ /* 求closedge.lowcost的最小正值 */
int i=0,j,k,min;
while(!SZ[i].lowcost)
i++;
min=SZ[i].lowcost; /* 第一个不为0的值 */
k=i;
for(j=i+1;j<G.vexnum;j++)
if(SZ[j].lowcost>0)
if(min>SZ[j].lowcost)
{
min=SZ[j].lowcost;
k=j;
}
return k;
}
int LocateVex(MGraph G,VertexType u)
{ /* 初始条件:图G存在,u和G中顶点有相同特征 */
/* 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
int i;
for(i=0;i<G.vexnum;++i)
if(strcmp(u,G.vexs[i])==0)
return i;
return -1;
}
/* 建立图的邻接矩阵 */
Status CreateAN(MGraph &G)
{ /* 采用数组(邻接矩阵)表示法,构造无向网G。*/
int i,j,k,w,IncInfo;
char s[MAX_INFO],*info;
VertexType va,vb;
printf("请输入无向网G的顶点数,边数,边是否含其它信息(是:1,否:0): ");
scanf("%d,%d,%d",&G.vexnum,&G.arcnum,&IncInfo);
printf("请输入%d个顶点的值(%d个字符):\n",G.vexnum,MAX_NAME);
for(i=0;i<G.vexnum;++i) /* 构造顶点向量 */
scanf("%s",G.vexs[i]);
for(i=0;i<G.vexnum;++i) /* 初始化邻接矩阵 */
for(j=0;j<G.vexnum;++j)
{
G.arcs[i][j].adj=INFINITY; /* 网 */
G.arcs[i][j].info=NULL;
}
printf("请输入%d条边的顶点1 顶点2 权值(以空格作为间隔): \n",G.arcnum);
for(k=0;k<G.arcnum;++k)
{
scanf("%s%s%d%*c",va,vb,&w); /* %*c吃掉回车符 */
i=LocateVex(G,va);
j=LocateVex(G,vb);
G.arcs[i][j].adj=G.arcs[j][i].adj=w; /* 无向 */
if(IncInfo)
{
printf("请输入该边的相关信息(<%d个字符): ",MAX_INFO);
gets(s);
w=strlen(s);
if(w)
{
info=(char*)malloc((w+1)*sizeof(char));
strcpy(info,s);
G.arcs[i][j].info=G.arcs[j][i].info=info; /* 无向 */
}
}
}
G.kind=AN;
return OK;
}
void Display_MGraph(MGraph G)
{ /* 输出邻接矩阵G */
int i,j;
char s[7],s1[3];
switch(G.kind)
{
case DG: strcpy(s,"有向图\0");
strcpy(s1,"弧\0");
break;
case DN: strcpy(s,"有向网\0");
strcpy(s1,"弧\0");
break;
case AG: strcpy(s,"无向图\0");
strcpy(s1,"边\0");
break;
case AN: strcpy(s,"无向网\0");
strcpy(s1,"边\0");
}
printf("%d个顶点%d条%s的%s\n",G.vexnum,G.arcnum,s1,s);
for(i=0;i<G.vexnum;++i) /* 输出G.vexs */
printf("G.vexs[%d]=%s\n",i,G.vexs[i]);
printf("G.arcs.adj:\n"); /* 输出G.arcs.adj */
for(i=0;i<G.vexnum;i++)
{
for(j=0;j<G.vexnum;j++)
printf("%6d",G.arcs[i][j].adj);
printf("\n");
}
printf("G.arcs.info:\n"); /* 输出G.arcs.info */
printf("顶点1(弧尾) 顶点2(弧头) 该%s信息:\n",s1);
if(G.kind<2) /* 有向 */
for(i=0;i<G.vexnum;i++)
for(j=0;j<G.vexnum;j++)
{
if(G.arcs[i][j].info)
printf("%5s %11s %s\n",G.vexs[i],G.vexs[j],G.arcs[i][j].info);
}
else /* 无向 */
{
for(i=0;i<G.vexnum;i++)
for(j=i+1;j<G.vexnum;j++)
if(G.arcs[i][j].info)
printf("%5s %11s %s\n",G.vexs[i],G.vexs[j],G.arcs[i][j].info);
}
}
void Display_ALGraph(ALGraph G)
{ /* 输出图的邻接矩阵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");
}
printf("%d个顶点:\n",G.vexnum);
for(i=0;i<G.vexnum;++i)
printf("%s ",G.vertices[i].data);
printf("\n%d条弧(边):\n",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->adj));
}
}
p=p->nextarc;
}
printf("\n");
}
}
Status(*VisitFunc)(VertexType);
Status visited[MAX_VERTEX_NUM];
void DFSTraverse(MGraph G,Status(*Visit)(VertexType))
{ /* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.4 */
/* 操作结果: 从第1个顶点起,深度优先遍历图G,并对每个顶点调用函数Visit */
/* 一次且仅一次。一旦Visit()失败,则操作失败 */
int v;
VisitFunc=Visit; /* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
for(v=0;v<G.vexnum;v++)
visited[v]=FALSE; /* 访问标志数组初始化(未被访问) */
for(v=0;v<G.vexnum;v++)
if(!visited[v])
DFS(G,v); /* 对尚未访问的顶点调用DFS */
printf("\n");
}
void DFS(MGraph G,int v)
{
int w;
visited[v]=TRUE;
VisitFunc(G.vexs[v]);
for(w=0;w<G.vexnum;w++)
{
if(G.arcs[v][w].adj!=INFINITY)
if(!visited[w])
DFS(G,w);
}
}
Status visit(VertexType i)
{
printf("%s ",i);
return OK;
}
void TransforMtoAL(MGraph G1,ALGraph &G2)
{
/*建立一个以邻接矩阵存储的图的邻接表存储结构*/
int i=0,j,x;
ArcNode *p;
ArcNode *q;
G2.vexnum=G1.vexnum;
G2.arcnum=G1.arcnum;
for(i=0;i<G1.vexnum;i++)
strcpy(G2.vertices[i].data,G1.vexs[i]);
G2.vertices[i].firstarc=NULL;
for(j=0;j<G2.vexnum;j++)
{
x=G1.arcs[i][j].adj;
if(x!=INFINITY)
{
p=(ArcNode *)malloc(sizeof(ArcNode));
p->adj=x;
p->nextarc=NULL;
p->adjvex=j;
if(!G2.vertices[i].firstarc)
q=G2.vertices[i].firstarc=p;
else
q->nextarc=p;
q=p;
}
}
}
void MiniSpanTree_PRIM(MGraph G,VertexType u)
{ /* 用普里姆算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边 算法7.9 */
minside closedge;
int i, j, k;
k = LocateVex(G, u);
for(j=0; j<=G.vexnum; j++) //辅助数组初始化
{
if(j!=k)
{
strcpy(closedge[j].adjvex,u);
closedge[j].lowcost = G.arcs[k][j].adj;
}
}
closedge[k].lowcost = 0;
for(i=1; i<=G.vexnum-1; i++) //总共需要G.vexnum-1次寻找最小边
{
k = minimum(closedge, G);
printf("%s--%s \n", closedge[k].adjvex, G.vexs[k]);
closedge[k].lowcost = 0;
for(j=1; j<=G.vexnum; j++)
if(G.arcs[k][j].adj < closedge[j].lowcost)
{
strcpy(closedge[j].adjvex,G.vexs[k]);
closedge[j].lowcost = G.arcs[k][j].adj;
}
}
}
void main()
{
MGraph G;
ALGraph G2;
CreateAN(G);
printf("深度优先搜索的结果:\n");
DFSTraverse(G,visit);
Display_MGraph(G);
TransforMtoAL(G,G2);
Display_ALGraph(G2);
MiniSpanTree_PRIM(G,G.vexs[0]);
}
/*
6, 10,0
A B C D E F
A B 5
A C 1
B C 5
B D 2
C D 4
C E 6
C F 5
D E 6
E F 3
A F 6
*/