图的基本操作【严蔚敏】

最新推荐文章于 2021-12-01 21:06:43 发布
最新推荐文章于 2021-12-01 21:06:43 发布
阅读量3.6k 收藏 66
点赞数 16
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 图的基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MooMLu/article/details/70872412
版权

图的基本操作：

ADT Graph{
    数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。
        数据关系R：R={VR}
    VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧，
        谓词P(v,w)定义了弧<v,w>的意义或信息}
    基本操作：
    CreateGraph( &G, V, VR )
    初始条件：V是图的顶点集，VR是图中弧的集合。
    操作结果：按V和VR的定义构造图G。
    DestroyGraph( &G )
    初始条件：图G存在。
    操作结果：销毁图G。
    LocateVex( G, u )
    初始条件：图G存在，u和G中顶点有相同特征。
    操作结果：若G中存在顶点u，则返回该顶点在图中位置；否则返回其它信息。
    GetVex( G, v )
    初始条件：图G存在，v是G中某个顶点。
    操作结果：返回v的值。
    PutVex( &G, v, value )
    初始条件：图G存在，v是G中某个顶点。
    操作结果：对v赋值value。
    FirstAdjVex( G, v )
    初始条件：图G存在，v是G中某个顶点。
    操作结果：返回v的第一个邻接顶点。若顶点在G中没有邻接顶点，则返回“空”。
    NextAdjVex( G, v, w )
    初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点。
    操作结果：返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接点，则返回“空”。
    InsertVex( &G, v )
    初始条件：图G存在，v和图中顶点有相同特征。
    操作结果：在图G中增添新顶点v。
    DeleteVex( &G, v )
    初始条件：图G存在，v是G中某个顶点。
    操作结果：删除G中顶点v及其相关的弧。
    InsertArc( &G, v, w )
    初始条件：图G存在，v和w是G中两个顶点。
    操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<v,w>。
    DeleteArc( &G, v, w )
    初始条件：图G存在，v和w是G中两个顶点。
    操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<v,w>。
    DFSTraverse( G, Visit() )
    初始条件：图G存在，Visit是顶点的应用函数。
    操作结果：对图进行深度优先遍历。在遍历过程中对每个顶点调用函数Visit一次且仅一次。一旦visit()失败，则操作失败。
    BFSTraverse( G, Visit() )
    初始条件：图G存在，Visit是顶点的应用函数。
    操作结果：对图进行广度优先遍历。在遍历过程中对每个顶点调用函数Visit一次且仅一次。一旦visit()失败，则操作失败。
}ADT Graph

具体实现【严蔚敏】：

#define MAX_VERTEX_NUM 20
 enum GraphKind{DG,DN,AG,AN}; // {有向图,有向网,无向图,无向网}
 struct ArcNode
 {
   int adjvex; // 该弧所指向的顶点的位置
   ArcNode *nextarc; // 指向下一条弧的指针
   InfoType *info; // 网的权值指针
 }; // 表结点
 typedef struct
 {
   VertexType data; // 顶点信息
   ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧的指针
 }VNode,AdjList[MAX_VERTEX_NUM]; // 头结点
 struct ALGraph
 {
   AdjList vertices;
   int vexnum,arcnum; // 图的当前顶点数和弧数
   int kind; // 图的种类标志
 };

图的数组表示【严蔚敏】：

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

图的邻接表表示【严蔚敏】：

图的数组(邻接矩阵)存储表示
 #define INFINITY INT_MAX // 用整型最大值代替∞
 #define MAX_VERTEX_NUM 20 // 最大顶点个数
 enum GraphKind{DG,DN,AG,AN}; // {有向图,有向网,无向图,无向网}
 typedef struct
 {
   VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；
           // 对带权图，则为权值类型
   InfoType *info; // 该弧相关信息的指针(可无)
 }ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
 struct MGraph
 {
   VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量
   AdjMatrix arcs; // 邻接矩阵
   int vexnum,arcnum; // 图的当前顶点数和弧数
   GraphKind kind; // 图的种类标志
 };
 int LocateVex(ALGraph G,VertexType u)
 { // 初始条件: 图G存在,u和G中顶点有相同特征
   // 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1
   int i;
   for(i=0;i<G.vexnum;++i)
     if(strcmp(u,G.vertices[i].data)==0)
       return i;
   return -1;
 }

 Status CreateGraph(ALGraph &G)
 { // 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图)
   int i,j,k;
   int w; // 权值
   VertexType va,vb;
   ArcNode *p;
   printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
   scanf("%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 DestroyGraph(ALGraph &G)
 { // 初始条件: 图G存在。操作结果: 销毁图G
   int i;
   ArcNode *p,*q;
   G.vexnum=0;
   G.arcnum=0;
   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;
     }
   }
 }

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

 Status PutVex(ALGraph &G,VertexType v,VertexType value)
 { // 初始条件: 图G存在,v是G中某个顶点
   // 操作结果: 对v赋新值value
   int i;
   i=LocateVex(G,v);
   if(i>-1) // v是G的顶点
   {
     strcpy(G.vertices[i].data,value);
     return OK;
   }
   return ERROR;
 }

 int FirstAdjVex(ALGraph G,VertexType v)
 { // 初始条件: 图G存在,v是G中某个顶点
   // 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1
   ArcNode *p;
   int v1;
   v1=LocateVex(G,v); // v1为顶点v在图G中的序号
   p=G.vertices[v1].firstarc;
   if(p)
     return p->adjvex;
   else
     return -1;
 }

 int NextAdjVex(ALGraph G,VertexType v,VertexType w)
 { // 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点
   // 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。
   //           若w是v的最后一个邻接点,则返回-1
   ArcNode *p;
   int v1,w1;
   v1=LocateVex(G,v); // v1为顶点v在图G中的序号
   w1=LocateVex(G,w); // w1为顶点w在图G中的序号
   p=G.vertices[v1].firstarc;
   while(p&&p->adjvex!=w1) // 指针p不空且所指表结点不是w
     p=p->nextarc;
   if(!p||!p->nextarc) // 没找到w或w是最后一个邻接点
     return -1;
   else // p->adjvex==w
     return p->nextarc->adjvex; // 返回v的(相对于w的)下一个邻接顶点的序号
 }

 void InsertVex(ALGraph &G,VertexType v)
 { // 初始条件: 图G存在,v和图中顶点有相同特征
   // 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待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); // j是顶点v的序号
   if(j<0) // v不是图G的顶点
     return ERROR;
   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
   }
   G.vexnum--; // 顶点数减1
   for(i=j;i<G.vexnum;i++) // 顶点v后面的顶点前移
     G.vertices[i]=G.vertices[i+1];
   for(i=0;i<G.vexnum;i++) // 删除以v为入度的弧或边且必要时修改表结点的顶点位置值
   {
     p=G.vertices[i].firstarc; // 指向第1条弧或边
     while(p) // 有弧
     {
       if(p->adjvex==j)
       {
         if(p==G.vertices[i].firstarc) // 待删结点是第1个结点
         {
           G.vertices[i].firstarc=p->nextarc;
           if(G.kind%2) // 网
             free(p->info);
           free(p);
           p=G.vertices[i].firstarc;
           if(G.kind<2) // 有向
             G.arcnum--; // 弧或边数减1
         }
         else
         {
           q->nextarc=p->nextarc;
           if(G.kind%2) // 网
             free(p->info);
           free(p);
           p=q->nextarc;
           if(G.kind<2) // 有向
             G.arcnum--; // 弧或边数减1
         }
       }
       else
       {
         if(p->adjvex>j)
           p->adjvex--; // 修改表结点的顶点位置值(序号)
         q=p;
         p=p->nextarc;
       }
     }
   }
   return OK;
 }

 Status InsertArc(ALGraph &G,VertexType v,VertexType w)
 { // 初始条件: 图G存在,v和w是G中两个顶点
   // 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v>
   ArcNode *p;
   int w1,i,j;
   i=LocateVex(G,v); // 弧尾或边的序号
   j=LocateVex(G,w); // 弧头或边的序号
   if(i<0||j<0)
     return ERROR;
   G.arcnum++; // 图G的弧或边的数目加1
   if(G.kind%2) // 网
   {
     printf("请输入弧(边)%s→%s的权值: ",v,w);
     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>,若G是无向的,则还删除对称弧<w,v>
   ArcNode *p,*q;
   int i,j;
   i=LocateVex(G,v); // i是顶点v(弧尾)的序号
   j=LocateVex(G,w); // j是顶点w(弧头)的序号
   if(i<0||j<0||i==j)
     return ERROR;
   p=G.vertices[i].firstarc; // p指向顶点v的第一条出弧
   while(p&&p->adjvex!=j) // p不空且所指之弧不是待删除弧<v,w>
   { // p指向下一条弧
     q=p;
     p=p->nextarc;
   }
   if(p&&p->adjvex==j) // 找到弧<v,w>
   {
     if(p==G.vertices[i].firstarc) // p所指是第1条弧
       G.vertices[i].firstarc=p->nextarc; // 指向下一条弧
     else
       q->nextarc=p->nextarc; // 指向下一条弧
     if(G.kind%2) // 网
       free(p->info);
     free(p); // 释放此结点
     G.arcnum--; // 弧或边数减1
   }
   if(G.kind>=2) // 无向,删除对称弧<w,v>
   {
     p=G.vertices[j].firstarc; // p指向顶点w的第一条出弧
     while(p&&p->adjvex!=i) // p不空且所指之弧不是待删除弧<w,v>
     { // p指向下一条弧
       q=p;
       p=p->nextarc;
     }
     if(p&&p->adjvex==i) // 找到弧<w,v>
     {
       if(p==G.vertices[j].firstarc) // p所指是第1条弧
         G.vertices[j].firstarc=p->nextarc; // 指向下一条弧
       else
         q->nextarc=p->nextarc; // 指向下一条弧
       if(G.kind==3) // 无向网
         free(p->info);
       free(p); // 释放此结点
     }
   }
   return OK;
 }

 Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)
 void(*VisitFunc)(char* v); // 函数变量(全局量)
 void DFS(ALGraph G,int v)
 { // 从第v个顶点出发递归地深度优先遍历图G。算法7.5
   int w;
   VertexType v1,w1;
   strcpy(v1,GetVex(G,v));
   visited[v]=TRUE; // 设置访问标志为TRUE(已访问)
   VisitFunc(G.vertices[v].data); // 访问第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(ALGraph G,void(*Visit)(char*))
 { // 对图G作深度优先遍历。算法7.4
   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");
 }
MooMLu
关注
专栏目录
【数据结构 严蔚敏版】 链式栈基本操作
Friday
12-22 7633
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 中文名 栈 外文名 stack 种 类数据结构 #include&l...
数据结构严蔚敏 线性表基本操作C++实现
欢乐佛的博客
03-05 2105
【数据结构（严蔚敏）】 线性表基本操作C++实现 基本代码 vs2017 #pragma once #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;iostream&amp;gt; #include &amp;lt;string.h&amp;gt; using namespace std; typedef int ElemType; # define LISTINCREMENT 2;
图的基本操作实现
05-14
设计程序实现图的任意一种存储结构及相关基本操作，在此基础上实现深度优先遍历和广度优先遍历操作。
图的操作
weixin_34161029的博客
06-17 131
//图 #include <stdio.h> #include <stdlib.h> #define MaxNum 100 typedef char Type; //邻接矩阵类型定义 typedef struct { Type vexs[MaxNum]; int edges[MaxNum][MaxNum]; int Vert...
图的基本操作
深街酒徒的博客
10-23 1649
图的表示方式： 用二维数组表示的邻接矩阵 用数组加链表表示的邻接表 图的基本方法： 建图：（插入图顶点和插入图的边） 图的顶点用ArrayList<String>存储，边用二维数组edges[][] 存储。 ArrayList<String> vertex; int [][]edges; public void insertVertex(String s) {//插入顶点 vertex.add(s); } public void insertEdge(int a
数据结构——图的基本操作实现
BrilliantWilliam的博客
12-01 2万+
数据结构——图的基本操作实现   图的基本操作不算很多，但是从记忆的角度来看算法比较的长，相对而言比较的困难。图的操作以遍历为主，其应用为最小生成树、最短路径、拓扑排序和关键路径求解。其中，最小生成树和最短路径的求法及过程需要大家掌握，而关键路径和拓扑排序只需要掌握过程，算法不要求掌握。这里为了更好的帮助大家理解以及掌握相应的算法，图的每一个操作本人都进行了实现。如果其中有什么不对的地方，还请各位大神指出！ 一、图的类型定义。 1.邻接矩阵存储 typedef struct { VerTexType
数据结构（C语言）（严蔚敏）各章节基本操作实现
07-05
本资料集合了书中各章节的基本操作实现，帮助学习者更好地理解和应用数据结构的理论知识。 首先，我们要理解数据结构的基本概念。数据结构是指一组数据的存储结构，包括数组、链表、栈、队列、树、图等。每种数据...
数据结构严蔚敏 队列基本操作 C语言实现
欢乐佛的博客
03-10 4198
【数据结构严蔚敏】 第三章 队列基本操作C语言 队列基本操作与栈类似，区别是删除元素时根据先进先出原则（FIFO），下面给出链队列的基本操作。 代码部分 1.基本结构定义 typedef int QElemType; //元素类型 typedef int Status; typedef struct QNode { QElemType data; struct QNode *next; }...
数据结构严蔚敏 栈基本操作 C语言实现
欢乐佛的博客
03-08 2644
【数据结构严蔚敏】 第三章 栈基本操作C语言实现 注意部分： 1.*S.top++ = e;= *S=e ; S.top++ ; 若要实现指针所指地址的元素值++，语句应该是（*a）++而不是*a++ 2.关于指针 普通变量如 int a，&amp;amp;amp;a表示变量a所在地址，a表示a所在地址中存储的值 指针变量如 int * a ，a表示a中存储的一个int型变量的地址，*a表示在a存储的地址中存...
用C语言实现图的基本操作
12-31
用C语言实现图的基本操作 typedef struct ArcCell{ VRType adj; //VRType是顶点关系类型。对无权图，用1或0 //表示相邻与否；对带权图，则为权值类型 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;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值