`

图的邻接矩阵存储

c数据结构图的邻接矩阵存储 
阅读更多 
 /* algo7-1.c 调用算法7.7、7.8 */
 #include"c1.h"
 #define MAX_NAME 2 /* 顶点字符串的最大长度+1 */
 typedef char ElemType[MAX_NAME];
 typedef ElemType TElemType;
 #include"c6-5.h"
 typedef int InfoType;
 typedef char VertexType[MAX_NAME];
 #include"c7-2.h"
 #include"bo7-2.c"

 void DFSTree(ALGraph G,int v,CSTree *T)
 { /* 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8 */
   Boolean first=TRUE;
   int w;
   CSTree p,q;
   VertexType v1,w1;
   visited[v]=TRUE;
   strcpy(v1,*GetVex(G,v));
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w)))) /* w依次为v的邻接顶点 */
     if(!visited[w]) /* w顶点不曾被访问 */
     {
       p=(CSTree)malloc(sizeof(CSNode)); /* 分配孩子结点 */
       strcpy(p->data,*GetVex(G,w));
       p->firstchild=NULL;
       p->nextsibling=NULL;
       if(first)
       { /* w是v的第一个未被访问的邻接顶点 */
         (*T)->firstchild=p;
         first=FALSE; /* 是根的第一个孩子结点 */
       }
       else /* w是v的其它未被访问的邻接顶点 */
	 q->nextsibling=p; /* 是上一邻接顶点的兄弟姐妹结点 */
       q=p;
       DFSTree(G,w,&q); /* 从第w个顶点出发深度优先遍历图G,建立子生成树q */
     }
 }

 void DFSForest(ALGraph G,CSTree *T)
 { /* 建立无向图G的深度优先生成森林的(最左)孩子(右)兄弟链表T。算法7.7 */
   CSTree p,q;
   int v;
   *T=NULL;
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 赋初值 */
   for(v=0;v<G.vexnum;++v) /* 从第0个顶点找起 */
     if(!visited[v])
     { /* 第v顶点为新的生成树的根结点 */
       p=(CSTree)malloc(sizeof(CSNode)); /* 分配根结点 */
       strcpy(p->data,*GetVex(G,v));
       p->firstchild=NULL;
       p->nextsibling=NULL;
       if(!*T) /* 是第一棵生成树的根(T的根) */
         *T=p;
       else /* 是其它生成树的根(前一棵的根的＂兄弟＂) */
         q->nextsibling=p;
       q=p; /* q指示当前生成树的根 */
       DFSTree(G,v,&p); /* 建立以p为根的生成树 */
     }
 }

 void PreOrderTraverse(CSTree T,void(*Visit)(TElemType))
 { /* 先根遍历孩子－兄弟二叉链表结构的树T(bo6-5.c改) */
   if(T)
   {
     Visit(T->data); /* 先访问根结点 */
     PreOrderTraverse(T->firstchild,Visit); /* 再先根遍历长子子树 */
     PreOrderTraverse(T->nextsibling,Visit); /* 最后先根遍历下一个兄弟子树 */
   }
 }

 void print(char *i)
 {
   printf("%s ",i);
 }

 void main()
 {
   ALGraph g;
   CSTree t;
   printf("请选择无向图\n");
   CreateGraph(&g);
   Display(g);
   DFSForest(g,&t);
   printf("先根遍历生成森林：\n");
   PreOrderTraverse(t,print);
   printf("\n");
 }

  /* c7-1.h 图的数组(邻接矩阵)存储表示 */ #define INFINITY INT_MAX /* 用整型最大值代替∞ */ #define MAX_VERTEX_NUM 20 /* 最大顶点个数 */ 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;

 

 /* bo7-1.c 图的数组(邻接矩阵)存储(存储结构由c7-1.h定义)的基本操作(20个) */
 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 CreateFAG(MGraph *G)
 { /* 采用数组(邻接矩阵)表示法,由文件构造没有相关信息的无向图G */
   int i,j,k;
   char filename[13];
   VertexType va,vb;
   FILE *graphlist;
   printf("请输入数据文件名(f7-1.dat)：");
   scanf("%s",filename);
   graphlist=fopen(filename,"r");
   fscanf(graphlist,"%d",&(*G).vexnum);
   fscanf(graphlist,"%d",&(*G).arcnum);
   for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
     fscanf(graphlist,"%s",(*G).vexs[i]);
   for(i=0;i<(*G).vexnum;++i) /* 初始化邻接矩阵 */
     for(j=0;j<(*G).vexnum;++j)
     {
       (*G).arcs[i][j].adj=0; /* 图 */
       (*G).arcs[i][j].info=NULL; /* 没有相关信息 */
     }
   for(k=0;k<(*G).arcnum;++k)
   {
     fscanf(graphlist,"%s%s",va,vb);
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=1; /* 无向图 */
   }
   fclose(graphlist);
   (*G).kind=AG;
   return OK;
 }

 Status CreateDG(MGraph *G)
 { /* 采用数组(邻接矩阵)表示法,构造有向图G */
   int i,j,k,l,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=0; /* 图 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("请输入%d条弧的弧尾 弧头(以空格作为间隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%*c",va,vb);  /* %*c吃掉回车符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=1; /* 有向图 */
     if(IncInfo)
     {
       printf("请输入该弧的相关信息(<%d个字符): ",MAX_INFO);
       gets(s);
       l=strlen(s);
       if(l)
       {
         info=(char*)malloc((l+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=info; /* 有向 */
       }
     }
   }
   (*G).kind=DG;
   return OK;
 }

 Status CreateDN(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条弧的弧尾 弧头 权值(以空格作为间隔): \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=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=info; /* 有向 */
       }
     }
   }
   (*G).kind=DN;
   return OK;
 }

 Status CreateAG(MGraph *G)
 { /* 采用数组(邻接矩阵)表示法,构造无向图G */
   int i,j,k,l,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=0; /* 图 */
       (*G).arcs[i][j].info=NULL;
     }
   printf("请输入%d条边的顶点1 顶点2(以空格作为间隔): \n",(*G).arcnum);
   for(k=0;k<(*G).arcnum;++k)
   {
     scanf("%s%s%*c",va,vb); /* %*c吃掉回车符 */
     i=LocateVex(*G,va);
     j=LocateVex(*G,vb);
     (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=1; /* 无向图 */
     if(IncInfo)
     {
       printf("请输入该边的相关信息(<%d个字符): ",MAX_INFO);
       gets(s);
       l=strlen(s);
       if(l)
       {
         info=(char*)malloc((l+1)*sizeof(char));
         strcpy(info,s);
         (*G).arcs[i][j].info=(*G).arcs[j][i].info=info; /* 无向 */
       }
     }
   }
   (*G).kind=AG;
   return OK;
 }

 Status CreateAN(MGraph *G)
 { /* 采用数组(邻接矩阵)表示法,构造无向网G。算法7.2 */
   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;
 }

 Status CreateGraph(MGraph *G)
 { /* 采用数组(邻接矩阵)表示法,构造图G。算法7.1 */
   printf("请输入图G的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
   scanf("%d",&(*G).kind);
   switch((*G).kind)
   {
     case DG: return CreateDG(G); /* 构造有向图 */
     case DN: return CreateDN(G); /* 构造有向网 */
     case AG: return CreateAG(G); /* 构造无向图 */
     case AN: return CreateAN(G); /* 构造无向网 */
     default: return ERROR;
   }
 }

 void DestroyGraph(MGraph *G)
 { /* 初始条件: 图G存在。操作结果: 销毁图G */
   int i,j;
   if((*G).kind<2) /* 有向 */
     for(i=0;i<(*G).vexnum;i++) /* 释放弧的相关信息(如果有的话) */
     {
       for(j=0;j<(*G).vexnum;j++)
         if((*G).arcs[i][j].adj==1&&(*G).kind==0||(*G).arcs[i][j].adj!=INFINITY&&(*G).kind==1) /* 有向图的弧||有向网的弧 */
           if((*G).arcs[i][j].info) /* 有相关信息 */
           {
             free((*G).arcs[i][j].info);
             (*G).arcs[i][j].info=NULL;
           }
     }
   else /* 无向 */
     for(i=0;i<(*G).vexnum;i++) /* 释放边的相关信息(如果有的话) */
       for(j=i+1;j<(*G).vexnum;j++)
         if((*G).arcs[i][j].adj==1&&(*G).kind==2||(*G).arcs[i][j].adj!=INFINITY&&(*G).kind==3) /* 无向图的边||无向网的边 */
           if((*G).arcs[i][j].info) /* 有相关信息 */
           {
             free((*G).arcs[i][j].info);
             (*G).arcs[i][j].info=(*G).arcs[j][i].info=NULL;
           }
   (*G).vexnum=0;
   (*G).arcnum=0;
 }

 VertexType* GetVex(MGraph G,int v)
 { /* 初始条件: 图G存在，v是G中某个顶点的序号。操作结果: 返回v的值 */
   if(v>=G.vexnum||v<0)
     exit(ERROR);
   return &G.vexs[v];
 }

 Status PutVex(MGraph *G,VertexType v,VertexType value)
 { /* 初始条件: 图G存在，v是G中某个顶点。操作结果: 对v赋新值value */
   int k;
   k=LocateVex(*G,v); /* k为顶点v在图G中的序号 */
   if(k<0)
     return ERROR;
   strcpy((*G).vexs[k],value);
   return OK;
 }

 int FirstAdjVex(MGraph G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
   int i,j=0,k;
   k=LocateVex(G,v); /* k为顶点v在图G中的序号 */
   if(G.kind==DN||G.kind==AN) /* 网 */
     j=INFINITY;
   for(i=0;i<G.vexnum;i++)
     if(G.arcs[k][i].adj!=j)
       return i;
   return -1;
 }

 int NextAdjVex(MGraph G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
   /* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号, */
   /*           若w是v的最后一个邻接顶点,则返回-1 */
   int i,j=0,k1,k2;
   k1=LocateVex(G,v); /* k1为顶点v在图G中的序号 */
   k2=LocateVex(G,w); /* k2为顶点w在图G中的序号 */
   if(G.kind==DN||G.kind==AN) /* 网 */
     j=INFINITY;
   for(i=k2+1;i<G.vexnum;i++)
     if(G.arcs[k1][i].adj!=j)
       return i;
   return -1;
 }

 void InsertVex(MGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v和图G中顶点有相同特征 */
   /* 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做) */
   int i;
   strcpy((*G).vexs[(*G).vexnum],v); /* 构造新顶点向量 */
   for(i=0;i<=(*G).vexnum;i++)
   {
     if((*G).kind%2) /* 网 */
     {
       (*G).arcs[(*G).vexnum][i].adj=INFINITY; /* 初始化该行邻接矩阵的值(无边或弧) */
       (*G).arcs[i][(*G).vexnum].adj=INFINITY; /* 初始化该列邻接矩阵的值(无边或弧) */
     }
     else /* 图 */
     {
       (*G).arcs[(*G).vexnum][i].adj=0; /* 初始化该行邻接矩阵的值(无边或弧) */
       (*G).arcs[i][(*G).vexnum].adj=0; /* 初始化该列邻接矩阵的值(无边或弧) */
     }
     (*G).arcs[(*G).vexnum][i].info=NULL; /* 初始化相关信息指针 */
     (*G).arcs[i][(*G).vexnum].info=NULL;
   }
   (*G).vexnum+=1; /* 图G的顶点数加1 */
 }

 Status DeleteVex(MGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点。操作结果: 删除G中顶点v及其相关的弧 */
   int i,j,k;
   VRType m=0;
   k=LocateVex(*G,v); /* k为待删除顶点v的序号 */
   if(k<0) /* v不是图G的顶点 */
     return ERROR;
   if((*G).kind==DN||(*G).kind==AN) /* 网 */
     m=INFINITY;
   for(j=0;j<(*G).vexnum;j++)
     if((*G).arcs[j][k].adj!=m) /* 有入弧或边 */
     {
       if((*G).arcs[j][k].info) /* 有相关信息 */
         free((*G).arcs[j][k].info); /* 释放相关信息 */
       (*G).arcnum--; /* 修改弧数 */
     }
   if((*G).kind==DG||(*G).kind==DN) /* 有向 */
     for(j=0;j<(*G).vexnum;j++)
       if((*G).arcs[k][j].adj!=m) /* 有出弧 */
       {
         if((*G).arcs[k][j].info) /* 有相关信息 */
           free((*G).arcs[k][j].info); /* 释放相关信息 */
         (*G).arcnum--; /* 修改弧数 */
       }
   for(j=k+1;j<(*G).vexnum;j++) /* 序号k后面的顶点向量依次前移 */
     strcpy((*G).vexs[j-1],(*G).vexs[j]);
   for(i=0;i<(*G).vexnum;i++)
     for(j=k+1;j<(*G).vexnum;j++)
       (*G).arcs[i][j-1]=(*G).arcs[i][j]; /* 移动待删除顶点之后的矩阵元素 */
   for(i=0;i<(*G).vexnum;i++)
     for(j=k+1;j<(*G).vexnum;j++)
       (*G).arcs[j-1][i]=(*G).arcs[j][i]; /* 移动待删除顶点之下的矩阵元素 */
   (*G).vexnum--; /* 更新图的顶点数 */
   return OK;
 }

 Status InsertArc(MGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和W是G中两个顶点 */
   /* 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v> */
   int i,l,v1,w1;
   char *info,s[MAX_INFO];
   v1=LocateVex(*G,v); /* 尾 */
   w1=LocateVex(*G,w); /* 头 */
   if(v1<0||w1<0)
     return ERROR;
   (*G).arcnum++; /* 弧或边数加1 */
   if((*G).kind%2) /* 网 */
   {
     printf("请输入此弧或边的权值: ");
     scanf("%d",&(*G).arcs[v1][w1].adj);
   }
   else /* 图 */
     (*G).arcs[v1][w1].adj=1;
   printf("是否有该弧或边的相关信息(0:无 1:有): ");
   scanf("%d%*c",&i);
   if(i)
   {
     printf("请输入该弧或边的相关信息(<%d个字符)：",MAX_INFO);
     gets(s);
     l=strlen(s);
     if(l)
     {
       info=(char*)malloc((l+1)*sizeof(char));
       strcpy(info,s);
       (*G).arcs[v1][w1].info=info;
     }
   }
   if((*G).kind>1) /* 无向 */
   {
     (*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
     (*G).arcs[w1][v1].info=(*G).arcs[v1][w1].info; /* 指向同一个相关信息 */
   }
   return OK;
 }

 Status DeleteArc(MGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中删除弧<v,w>,若G是无向的,则还删除对称弧<w,v> */
   int v1,w1;
   v1=LocateVex(*G,v); /* 尾 */
   w1=LocateVex(*G,w); /* 头 */
   if(v1<0||w1<0) /* v1、w1的值不合法 */
     return ERROR;
   if((*G).kind%2==0) /* 图 */
     (*G).arcs[v1][w1].adj=0;
   else /* 网 */
     (*G).arcs[v1][w1].adj=INFINITY;
   if((*G).arcs[v1][w1].info) /* 有其它信息 */
   {
     free((*G).arcs[v1][w1].info);
     (*G).arcs[v1][w1].info=NULL;
   }
   if((*G).kind>=2) /* 无向,删除对称弧<w,v> */
   {
     (*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
     (*G).arcs[w1][v1].info=NULL;
   }
   (*G).arcnum--;
   return OK;
 }

 Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
 Status(*VisitFunc)(VertexType); /* 函数变量 */
 void DFS(MGraph G,int v)
 { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
   VertexType w1,v1;
   int w;
   visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
   VisitFunc(G.vexs[v]); /* 访问第v个顶点 */
   strcpy(v1,*GetVex(G,v));
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
     if(!visited[w])
       DFS(G,w); /* 对v的尚未访问的序号为w的邻接顶点递归调用DFS */
 }

 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");
 }

 typedef VRType QElemType; /* 队列类型 */
 #include"c3-2.h" /* BFSTraverse()用 */
 #include"bo3-2.c" /* BFSTraverse()用 */
 void BFSTraverse(MGraph G,Status(*Visit)(VertexType))
 { /* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.6 */
   /* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */
   /*           Visit一次且仅一次。一旦Visit()失败,则操作失败。 */
   /*           使用辅助队列Q和访问标志数组visited */
   int v,u,w;
   VertexType w1,u1;
   LinkQueue Q;
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的辅助队列Q */
   for(v=0;v<G.vexnum;v++)
     if(!visited[v]) /* v尚未访问 */
     {
       visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
       Visit(G.vexs[v]);
       EnQueue(&Q,v); /* v入队列 */
       while(!QueueEmpty(Q)) /* 队列不空 */
       {
         DeQueue(&Q,&u); /* 队头元素出队并置为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]) /* w为u的尚未访问的邻接顶点的序号 */
           {
             visited[w]=TRUE;
             Visit(G.vexs[w]);
             EnQueue(&Q,w);
           }
       }
     }
   printf("\n");
 }

 void Display(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);
   }
 }

 

 /* main7-1.c 检验bo7-1.c的主程序 */
 #include"c1.h"
 #define MAX_NAME 5 /* 顶点字符串的最大长度+1 */
 #define MAX_INFO 20 /* 相关信息字符串的最大长度+1 */
 typedef int VRType;
 typedef char InfoType;
 typedef char VertexType[MAX_NAME];
 #include"c7-1.h"
 #include"bo7-1.c"

 Status visit(VertexType i)
 {
   printf("%s ",i);
   return OK;
 }

 void main()
 {
   int i,j,k,n;
   VertexType v1,v2;
   MGraph g;
   CreateFAG(&g);
   Display(g);
   printf("修改顶点的值，请输入原值 新值: ");
   scanf("%s%s",v1,v2);
   PutVex(&g,v1,v2);
   printf("深度优先搜索的结果:\n");
   DFSTraverse(g,visit);
   printf("广度优先搜索的结果:\n");
   BFSTraverse(g,visit);
   printf("删除一条边或弧，请输入待删除边或弧的弧尾 弧头：");
   scanf("%s%s",v1,v2);
   DeleteArc(&g,v1,v2);
   Display(g);
   DestroyGraph(&g);
   printf("请顺序选择有向图,有向网,无向图,无向网\n");
   for(i=0;i<4;i++) /* 验证4种情况 */
   {
     CreateGraph(&g);
     Display(g);
     printf("插入新顶点，请输入顶点的值: ");
     scanf("%s",v1);
     InsertVex(&g,v1);
     printf("插入与新顶点有关的弧或边，请输入弧或边数: ");
     scanf("%d",&n);
     for(k=0;k<n;k++)
     {
       printf("请输入另一顶点的值: ");
       scanf("%s",v2);
       if(g.kind<=1) /* 有向 */
       {
         printf("对于有向图或网，请输入另一顶点的方向(0:弧头 1:弧尾): ");
         scanf("%d",&j);
         if(j)
           InsertArc(&g,v2,v1);
         else
           InsertArc(&g,v1,v2);
       }
       else /* 无向 */
         InsertArc(&g,v1,v2);
     }
     Display(g);
     printf("删除顶点及相关的弧或边，请输入顶点的值: ");
     scanf("%s",v1);
     DeleteVex(&g,v1);
     Display(g);
     DestroyGraph(&g);
   }
 }

 

分享到：
| 树的二叉链表(孩子－兄弟)存储
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    无向图的邻接矩阵存储及输出

    ### 无向图的邻接矩阵存储及输出详解 在计算机科学中，图是一种重要的数据结构，用于表示对象之间的关系。图由顶点（或节点）和边组成，其中边可以是有向的或无向的。本文将详细介绍无向图的邻接矩阵存储方式以及...

    头歌数据结构图的邻接矩阵存储及遍历操作

    ### 头歌数据结构图的邻接矩阵存储及遍历操作 #### 一、邻接矩阵存储 在数据结构中，图是一种常见的非线性结构，用于表示对象间的关系。根据边是否有方向，图可以分为有向图和无向图。而根据边是否具有权重值，又...

    图的邻接矩阵存储和邻接表存储

    图是数据结构中的一种重要...综上所述，`createadjlist.cpp`和`creatematix.cpp`文件分别实现了图的邻接表和邻接矩阵存储，为理解和操作图提供基础。通过阅读和理解这些代码，你可以更好地掌握这两种重要的图数据结构。

    数据结构C语言版_图的邻接矩阵存储表示和实现

    ### 数据结构C语言版_图的邻接矩阵存储表示和实现 #### 1. 图的邻接矩阵存储表示概述 图是一种重要的非线性数据结构，由顶点集和边集组成，用数学符号表示为 G = (V, E)，其中 V 是顶点集合，E 是边集合。在计算机...

    图的邻接矩阵存储代码

    图邻接矩阵的存储代码 是我话了一个晚上编写的，足够全面

    利用邻接矩阵存储图，并用深度优先算法遍历二叉树

    邻接矩阵存储图和深度优先算法遍历二叉树 邻接矩阵是一种常用的图存储方式，它将图中的边信息存储在一个矩阵中，每个元素对应两个顶点之间的边的存在情况。利用邻接矩阵存储图可以方便地进行图的遍历和搜索。 在...

    数据库课程设计(无向图邻接矩阵存储+邻接表和约瑟夫环的模拟) MFC

    在邻接矩阵存储方法中，我们用一个二维数组来表示图中各个节点之间的连接情况。如果节点i与节点j之间有边，则邻接矩阵的[i][j]和[j][i]位置都是1，否则为0。这种存储方式适合处理稠密图，即边的数量接近于所有可能边...

    定义采用邻接矩阵存储的图结构封装DFS、BFS算法

    定义采用邻接矩阵存储的图结构封装DFS、BFS算法

    有向图邻接矩阵c++运算操作

    有向图邻接矩阵c++运算操作 基本操作 邻接矩阵 c++实现

    邻接矩阵存储简单路径

    用C写的用邻接矩阵存储的图的简单路径，数据结构用

    建立有向图G的邻接矩阵存储

    通过上述分析可以看出，该程序有效地实现了有向图的邻接矩阵存储，并能够正确地输入和输出顶点及边的信息。这种方式不仅简单直观，而且便于理解和操作，是图数据结构中非常常见的一种存储方式。

    无向网的邻接矩阵存储

    无向网的邻接矩阵存储 无向网的邻接矩阵存储是指使用邻接矩阵来存储无向网的结构信息。在计算机科学中，邻接矩阵是一种常用的数据结构，用于描述图或网的结构信息。无向网是指没有方向的网，即每条边都可以双向通过...

    基于邻接矩阵存储的图的最小生成树的Prime算法

    基于邻接矩阵存储的图的最小生成树的Prime算法，对学习C++和数据结构很有帮助

    邻接矩阵存储的无向图广度和深度遍历文件操作

    在处理无向图时，我们经常使用邻接矩阵作为存储方式，因为它提供了对图中边的存在与否的直观表示。本话题将深入探讨如何使用邻接矩阵来实现无向图的广度优先搜索（BFS）和深度优先搜索（DFS）的文件操作。 首先，...

    实现图的邻接矩阵和邻接表存储

    在编程中，有多种方法来存储图，其中两种常用的方法是邻接矩阵和邻接表。这两种方法各有优缺点，适用于不同类型的图和不同的操作需求。 邻接矩阵是一种二维数组，其中的每个元素代表两个顶点之间是否存在边。如果...

    无向图邻接矩阵存储结构 先深及先广搜索

    用邻接矩阵建立图的存储结构，并进行深度优先搜索、广度优先搜索。

    图的邻接矩阵

    3. 图的邻接矩阵的建立：图的邻接矩阵可以通过用户输入来建立，例如，用户输入顶点数目、边数目、顶点字符和边的权值等信息，然后将这些信息存储到图的邻接矩阵中。 4. 图的邻接矩阵的查找顶点：可以使用一个函数来...

    基于邻接矩阵存储的图的最短路径问题

    基于邻接矩阵存储的图的最短路径问题，可以很好的学习C++和数据结构

    图的邻接矩阵实现

    图的邻接矩阵实现，用邻接矩阵实现了图，基本操作，主要算法

    C语言实现图的邻接矩阵存储操作

    利用邻接矩阵容易判定任意两个顶点之间是否有边（或弧）相连，并容易求得各个顶点的度。 c语言代码实现如下： #include #include #define MAX_VER_NUM 50 typedef char VertexType; typedef enum { DG,UDG }...

Magicbox
Global site tag (gtag.js) - Google Analytics