无向图的邻接多重表存储

最新推荐文章于 2021-08-13 23:24:35 发布
最新推荐文章于 2021-08-13 23:24:35 发布
阅读量424 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/cpoint/p/3480218.html
版权 
 /* c7-4.h 无向图的邻接多重表存储表示 */
 #define MAX_VERTEX_NUM 20
 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;
 /* bo7-4.c 无向图的邻接多重表存储(存储结构由c7-4.h定义)的基本函数类型(16个) */
 int LocateVex(AMLGraph G,VertexType u)
 { /* 初始条件: 无向图G存在,u和G中顶点有相同特征 */
   /* 操作结果: 若G中存在顶点u,则返回该顶点在无向图中位置;否则返回-1 */
   int i;
   for(i=0;i<G.vexnum;++i)
     if(strcmp(u,G.adjmulist[i].data)==0)
       return i;
   return -1;
 }

 Status CreateGraph(AMLGraph *G)
 { /* 采用邻接多重表存储结构,构造无向图G */
   int i,j,k,l,IncInfo;
   char s[MAX_INFO];
   VertexType va,vb;
   EBox *p;
   printf("请输入无向图G的顶点数,边数,边是否含其它信息(是:1，否:0): ");
   scanf("%d,%d,%d",&(*G).vexnum,&(*G).edgenum,&IncInfo);
   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->jvex=j;
     p->info=NULL;
     p->ilink=(*G).adjmulist[i].firstedge; /* 插在表头 */
     (*G).adjmulist[i].firstedge=p;
     p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
     (*G).adjmulist[j].firstedge=p;
     if(IncInfo) /* 边有相关信息 */
     {
       printf("请输入该弧的相关信息(<%d个字符)：",MAX_INFO);
       gets(s);
       l=strlen(s);
       if(l)
       {
         p->info=(char*)malloc((l+1)*sizeof(char));
         strcpy(p->info,s);
       }
     }
   }
   return OK;
 }

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

 Status PutVex(AMLGraph *G,VertexType v,VertexType value)
 { /* 初始条件: 无向图G存在,v是G中某个顶点 */
   /* 操作结果: 对v赋新值value */
   int i;
   i=LocateVex(*G,v);
   if(i<0) /* v不是G的顶点 */
     return ERROR;
   strcpy((*G).adjmulist[i].data,value);
   return OK;
 }

 int FirstAdjVex(AMLGraph G,VertexType v)
 { /* 初始条件: 无向图G存在,v是G中某个顶点 */
   /* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
   int i;
   i=LocateVex(G,v);
   if(i<0)
     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 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;
   (*G).vexnum++;
   return OK;
 }

 Status DeleteArc(AMLGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 无向图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中删除弧<v,w> */
   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) /* 向后查找弧<v,w> */
     {
       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) /* 找到弧<v,w>(情况1) */
       if(q->ivex==i)
         q->ilink=p->ilink;
       else
         q->jlink=p->ilink;
     else if(p->ivex==j&&p->jvex==i) /* 找到弧<v,w>(情况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;
     if(p->info) /* 有相关信息 */
       free(p->info);
     free(p);
   }
   else if(p->ivex==i) /* 第1条边即为待删除边(情况2) */
   {
     (*G).adjmulist[j].firstedge=p->jlink;
     if(p->info) /* 有相关信息 */
       free(p->info);
     free(p);
   }
   else /* 第1条边不是待删除边 */
   {
     while(p) /* 向后查找弧<v,w> */
       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) /* 找到弧<v,w>(情况1) */
     {
       if(q->ivex==j)
         q->ilink=p->jlink;
       else
         q->jlink=p->jlink;
       if(p->info) /* 有相关信息 */
         free(p->info);
       free(p);
     }
     else if(p->ivex==j&&p->jvex==i) /* 找到弧<v,w>(情况2) */
     {
       if(q->ivex==j)
         q->ilink=p->ilink;
       else
         q->jlink=p->ilink;
       if(p->info) /* 有相关信息 */
         free(p->info);
       free(p);
     }
   }
   (*G).edgenum--;
   return OK;
 }

 Status DeleteVex(AMLGraph *G,VertexType v)
 { /* 初始条件: 无向图G存在,v是G中某个顶点 */
   /* 操作结果: 删除G中顶点v及其相关的边 */
   int i,j;
   VertexType w;
   EBox *p;
   i=LocateVex(*G,v); /* i为待删除顶点的序号 */
   if(i<0)
     return ERROR;
   for(j=0;j<(*G).vexnum;j++) /* 删除与顶点v相连的边(如果有的话) */
   {
     if(j==i)
       continue;
     strcpy(w,*GetVex(*G,j)); /* w是第j个顶点的值 */
     DeleteArc(G,v,w);
   }
   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++) /* 修改顶点的序号 */
   {
     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 DestroyGraph(AMLGraph *G)
 {
   int i;
   for(i=(*G).vexnum-1;i>=0;i--)
     DeleteVex(G,(*G).adjmulist[i].data);
 }

 Status InsertArc(AMLGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 无向图G存在,v和W是G中两个顶点 */
   /* 操作结果: 在G中增添弧<v,w> */
   int i,j,l,IncInfo;
   char s[MAX_INFO];
   EBox *p;
   i=LocateVex(*G,v); /* 一端 */
   j=LocateVex(*G,w); /* 另一端 */
   if(i<0||j<0)
     return ERROR;
   p=(EBox*)malloc(sizeof(EBox));
   p->mark=unvisited;
   p->ivex=i;
   p->jvex=j;
   p->info=NULL;
   p->ilink=(*G).adjmulist[i].firstedge; /* 插在表头 */
   (*G).adjmulist[i].firstedge=p;
   p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
   (*G).adjmulist[j].firstedge=p;
   printf("该边是否有相关信息(1:有 0:无): ");
   scanf("%d%*c",&IncInfo); /* 吃掉回车符 */
   if(IncInfo) /* 边有相关信息 */
   {
     printf("请输入该边的相关信息(<%d个字符)：",MAX_INFO);
     gets(s);
     l=strlen(s);
     if(l)
     {
       p->info=(char*)malloc((l+1)*sizeof(char));
       strcpy(p->info,s);
     }
   }
   (*G).edgenum++;
   return OK;
 }

 Boolean visite[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
 Status(*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,Status(*visit)(VertexType))
 { /* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.4 */
   /* 操作结果: 从第1个顶点起,深度优先遍历图G,并对每个顶点调用函数Visit */
   /*           一次且仅一次。一旦Visit()失败,则操作失败 */
   int v;
   VisitFunc=visit;
   for(v=0;v<G.vexnum;v++)
     visite[v]=FALSE;
   for(v=0;v<G.vexnum;v++)
     if(!visite[v])
       DFS(G,v);
   printf("\n");
 }

 typedef int QElemType; /* 队列类型 */
 #include"c3-2.h" /* BFSTraverse()用 */
 #include"bo3-2.c" /* BFSTraverse()用 */
 void BFSTraverse(AMLGraph G,Status(*Visit)(VertexType))
 { /* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.6 */
   /* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */
   /*           Visit一次且仅一次。一旦Visit()失败,则操作失败。 */
   /*           使用辅助队列Q和访问标志数组visite */
   int v,u,w;
   VertexType w1,u1;
   LinkQueue Q;
   for(v=0;v<G.vexnum;v++)
     visite[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的辅助队列Q */
   for(v=0;v<G.vexnum;v++)
     if(!visite[v]) /* v尚未访问 */
     {
       visite[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
       Visit(G.adjmulist[v].data);
       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(!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<G.vexnum;i++)
   {
     p=G.adjmulist[i].firstedge;
     while(p)
     {
       p->mark=unvisited;
       if(p->ivex==i)
         p=p->ilink;
       else
         p=p->jlink;
     }
   }
 }

 void Display(AMLGraph G)
 { /* 输出无向图的邻接多重表G */
   int i;
   EBox *p;
   MarkUnvizited(G); /* 置边的访问标记为未被访问 */
   printf("%d个顶点：\n",G.vexnum);
   for(i=0;i<G.vexnum;++i)
     printf("%s ",G.adjmulist[i].data);
   printf("\n%d条边:\n",G.edgenum);
   for(i=0;i<G.vexnum;i++)
   {
     p=G.adjmulist[i].firstedge;
     while(p)
       if(p->ivex==i) /* 边的i端与该顶点有关 */
       {
         if(!p->mark) /* 只输出一次 */
         {
           printf("%s－%s ",G.adjmulist[i].data,G.adjmulist[p->jvex].data);
           p->mark=visited;
           if(p->info) /* 输出附带信息 */
             printf("相关信息: %s ",p->info);
         }
         p=p->ilink;
       }
       else /* 边的j端与该顶点有关 */
       {
         if(!p->mark) /* 只输出一次 */
         {
           printf("%s－%s ",G.adjmulist[p->ivex].data,G.adjmulist[i].data);
           p->mark=visited;
           if(p->info) /* 输出附带信息 */
             printf("相关信息: %s ",p->info);
         }
         p=p->jlink;
       }
     printf("\n");
   }
 }
 /* main7-4.cpp 检验bo7-4.cpp的主程序 */
 #include"c1.h"
 #define MAX_NAME 3 /* 顶点字符串的最大长度+1 */
 #define MAX_INFO 80 /* 相关信息字符串的最大长度+1 */
 typedef char InfoType;
 typedef char VertexType[MAX_NAME]; /* 字符串类型 */
 #include"c7-4.h"
 #include"bo7-4.c"
 Status visit(VertexType v)
 {
   printf("%s ",v);
   return OK;
 }

 void main()
 {
   int k,n;
   AMLGraph g;
   VertexType v1,v2;
   CreateGraph(&g);
   Display(g);
   printf("修改顶点的值，请输入原值 新值: ");
   scanf("%s%s",v1,v2);
   PutVex(&g,v1,v2);
   printf("插入新顶点，请输入顶点的值: ");
   scanf("%s",v1);
   InsertVex(&g,v1);
   printf("插入与新顶点有关的边，请输入边数: ");
   scanf("%d",&n);
   for(k=0;k<n;k++)
   {
     printf("请输入另一顶点的值: ");
     scanf("%s",v2);
     InsertArc(&g,v1,v2);
   }
   Display(g);
   printf("深度优先搜索的结果:\n");
   DFSTraverse(g,visit);
   printf("广度优先搜索的结果:\n");
   BFSTraverse(g,visit);
   DestroyGraph(&g);
 }

 

转载于:https://www.cnblogs.com/cpoint/p/3480218.html

aeg84268
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
无向图的邻接多重表结构，存储结构及基本功能实现（最全）
hyymeishi
01-08 4517
邻接多重表结构主要针对的是无向图进行的存储优化。详细概念可百度谷歌下。如果我们在无向图的应用中，关注的重点是顶点，那么邻接表是不错的选择，但如果我们更关注边的操作，比如对已访问过的边做标记，删除某一条边等操作，那就意味着，需要找到这条边的两个边表结点进行操作，这其实还是比较麻烦的。因此，我们也依照十字链表的方式，对表结点进行一下改造：                         [ ivex
邻接多重表存储无向图以及有关操作
lovecontry
11-13 445
数据结构是编程里面最重要的一门基础课之一，所以学多少遍都不可以嫌多，算法的知识当然是融在其中，多练习，多思考，基础打好了，其他的东西学起来也就so easy了。 邻接多重表，是对用邻接表存储无向图的一种压缩存储，当然也是链式存储，邻接多重表的相关概念，可以百度、谷歌、或者看有关书籍。大部分书都没有详细介绍这个结构的应用(至少我目前还没看到有书上有写)，只是说 这个结构在对无向图的边进行操作的时候...
无向图的链式存储结构：邻接多重表
一个搬运知识的笨小孩
08-13 1033
邻接多重表 顶点结构和边表结构 无向图的邻接多重表 无向图的邻接多重表存储表示 #define MAX_VERTEX_NUM 20 typedef enmu{unvisited,visited} VisitIf; //枚举类型，将变量限定在一定范围内 //链表中的边结点 typedef struct EBox{ VisitIf mark; //访问边的标记 int ivex, jvex; //该边依附的两个顶点在一维数组中的下标值 struct EBox *ilink, *jlink; //分别指
无向图的邻接多重表存储实现（第七章 P166）
但行好事，莫问前程
04-20 884
无向图的邻接多重表存储结构： 上图是根据程序定义的无向图的存储结构。程序中基本操作函数 CreateGraph()是在表头插入边结点的。所以，对于给定的图，它的边结点的链表结构也不惟一，与边的输入顺序有关。采用邻接多重表存储结构， 每条边只生成一个结点。而用邻接表存储结构表示无向图，图的每条边生成两个结点。 无向图及其邻接多重表存储结构： ...
邻接多重表实现无向图的存储
皮卡qiu~的博客
10-30 762
一、图 二、程序 (与十字链表差不多) /* 项目名称：邻接多重表存储无向图 编译环境：VC++ 2008 作者相关：。。。 最后修改：2019.10.30 学习目标：1.掌握邻接多重表存储无图的基本操作 注意事项：1.测试所有功能是否正常 遇到问题： */ #include <stdio.h> #include <stdlib.h> #define MA...
数据结构C语言版-无向图的邻接多重表存储表示和实现(完整版).doc
最新发布
11-30
数据结构C语言版-无向图的邻接多重表存储表示和实现 本文档详细介绍了无向图的邻接多重表存储表示和实现，使用C语言编写。无向图是一种常见的数据结构，广泛应用于计算机科学和信息技术领域。 一、邻接多重表存储...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
总之，这个程序设计任务要求我们理解并实现无向图的两种主要遍历方法，以及如何利用邻接表或邻接矩阵存储图。通过这些方法，我们可以有效地探索图的结构，找出路径，解决许多实际问题，如搜索、最短路径计算等。
linjiejuzhen.rar_邻接多重表
09-23
对任意给定的图（顶点数不小于20，边数不少于30，图的类型可以是有向图、无向图、有向网、无向网），能够输入图的顶点和边（或弧）的信息，并存储到相应存储结构（邻接矩阵、邻接表、十字链表、邻接多重表，任选其中...
用邻接多重表实现图遍历演示
10-23
很不错的啊 邻接多重表实现的，功能很多的
multi-table-graph-.rar_Table_邻接多重表
09-24
标题中的"multi-table-graph-.rar_Table_邻接多重表"暗示了我们正在处理一个与图论相关的编程项目，特别是关于无向图的邻接多重表的实现。邻接多重表是一种常用的图数据结构，用于存储图中顶点之间的连接关系。 在...
无向图的邻接多重链表存储算法（98）
我的博客
12-12 620
无向图的邻接多重链表存储算法（98）
40. 数据结构笔记之四十图的邻接多重链表表示实现
badman250的专栏
09-21 5285
40. 数据结构笔记之四十图的邻接多重链表表示实现 “一个人的价值 , 应当看他贡献什么 , 而不应当看他取得什么。-- 爱因斯坦” 1.  邻接多重表 邻接多重表(AdjacencyMultilist)主要用于存储无向图。因为，如果用邻接表存储无向图，每条边的两个边结点分别在以该边所依附的两个顶点为头结点的链表中，这给图的某些操作带来不便。例如，对已访问过的边做标记，或者要删除图中某
无向图的邻接表
热门推荐
烟敛寒林的博客
12-24 3万+
  如何根据无向图画出邻接表呢？ 比如： 第一排的v1，与v2和v4相连，因此两个黄色方框内的数字分别代表v2和v4的下标； 第二排的v2，与v1、v3和v5相连，因此三个绿色方框内的数字分别代表v1和v3和v5的下标； 以此类推。 同时反过来推测： 第一排的三个红边方框，“1” “2” “3”：代表v0与v1、v2、v3相连； 第二排的两个红边方框，“0” “2”：代表v1与...
图的链式存储结构解析（邻接表、逆邻接表、十字链表、邻接多重表）
LRY89757的博客
07-07 8261
图的矩阵表示法比较消耗空间，需要花费$n2n^2n2$个单元存储边（弧）。在边数较少的情况下比较浪费。我们这里来讨论图的链式存储结构。 图的链式结构主要有四类：邻接表、逆邻接表、十字链表、邻接多重表。 前两个算比较好理解的，后两个更复杂一点。 目录邻接表无向图的邻接表有向图的邻接表逆邻接表十字链表存储结构构造十字链表十字链表结构性质邻接多重表存储结构构造邻接多重表 邻接表 实际上邻接表都是使用数组来存储顶点，然后对每一个顶点建立一个单链表，第i个但链表中的节点表示依附于顶点vi的边（对有向图是以vi为尾的
无向图顶点邻接多重表表示法
weixin_45580106的博客
11-04 639
无向图顶点邻接多重表表示法 #include<iostream> using namespace std; #define MAX_VERTEX_NUM 20 typedef int VertexType; typedef int InfoType; typedef enum { unvisted, visted, }VisitIf; typedef struct Ebox {//边节点 VisitIf mark; //访问标志 int ivex, jvex;//该边依附的两个顶点的位置
无向图的邻接多重表存储结构
weixin_30545285的博客
08-29 702
// c7-4.h 无向图的邻接多重表存储结构(见图7.42) #define MAX_VERTEX_NUM 20 enum VisitIf{unvisited,visited}; struct EBox { VisitIf mark; // 访问标记 int ivex,jvex; // 该边依附的两个顶点的位置 EBox *ilink,*jlink; // 分别指向依附这两个顶点的...
【数据结构学习笔记】6：无向图的邻接多重表存储结构
LauZyHou的笔记
04-30 2614
邻接多重表的实现。这次研讨确实有难度，除了实现这个还要完成最小生成树。 直接上代码吧。 边节点Arc.h #ifndef ARC_H #define ARC_H #ifndef NULL #define NULL 0 #endif struct Arc { bool tag; int weight; int adjVex1, adjVex2; Arc* nextArc1; A...
数据结构：无向图的邻接多重表存储表示 （c实现）
憧憬，思考，奋斗，飞翔
05-08 3224
/******************************************************************* 程序：无向图的邻接多重表存储表示 完成时间：2013年6月11日 完成者：小单 *******************************************************************
无向图的邻接多重表存储表示解析
"无向图的邻接多重表存储表示-数据结构图" 在数据结构领域，图是一种重要的抽象数据类型，它用于表示对象之间的复杂关系。无向图是图的一种类型，其中任意两个顶点间的关系是双向的，即如果有一条从顶点A到顶点B的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值