跳至內容

鄰接表

本頁使用了標題或全文手工轉換
維基百科，自由的百科全書
這是一個無向循環圖，可以用下面幾個表來描述：{a,b}, {a,c}, {b,c}。

在圖論和計算機科學中，鄰接表（英語：adjacency list）是表示了圖中與每一個頂點相鄰的邊集的集合，這裡的集合指的是無序集。

如果是無向圖，那麼每條邊由兩個結點組成，分別代表邊的兩個端點；如果是有向圖，那麼每條邊是一個結點對，分別代表邊的始點和終點。

計算機科學中的應用

上圖的鄰接表表示
a 鄰接於 b,c
b 鄰接於 a,c
c 鄰接於 a,b

在計算機科學中，鄰接表描述一種緊密相關的數據結構，用於表徵圖。在鄰接表的表示中，對於圖中的每個頂點，將保存所有其它與之相連的頂點（即「鄰接表」）。例如，由吉多·范羅蘇姆提出的，使用哈希表將每個頂點和該頂點的鄰接點數組關連起來，就可以看作是上述表示方法的一種實現。又如，在Cormenetal中，頂點數組的每個元素都指向一個鄰接點單鍊表。

鄰接表結構的困難之一是無法明確在什麼地方保存相關邊的長度或花銷。為了解決這個問題，一些算法，如 Goodrich and Tamassia所提出的面向對象鄰接表，有時也稱「關聯度」，它為每個頂點保存一個對象表，每個對象表示指向頂點的那條邊的關聯度。為了完善這個結構，每條邊必須指向兩個組成其端點的頂點。這個額外的邊對象使得它比直接列出所有邊的鄰接表消耗更多的內存，但它不失為一種保存邊相關信息的好方法。



C 實現

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

 /* 图的邻接表存储的基本操作(15个)*/
 #include"bo2-8.c" /* 不带头结点的单链表基本操作 */
 #include"func2-1.c" /* 不带头结点的单链表扩展操作 */
 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;
 }

 void CreateGraph(ALGraph *G)
 { /* 采用邻接表存储结构，构造没有相关信息图或网G(用一个函数构造4种图) */
   int i,j,k,w; /* w是权值 */
   VertexType va,vb; /* 连接边或弧的2顶点 */
   ElemType e;
   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%2) /* 网 */
     printf("请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
   else /* 图 */
     printf("请输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
   for(k=0;k<(*G).arcnum;++k) /* 构造相关弧链表 */
   {
     if((*G).kind%2) /* 网 */
       scanf("%d%s%s",&w,va,vb);
     else /* 图 */
       scanf("%s%s",va,vb);
     i=LocateVex(*G,va); /* 弧尾 */
     j=LocateVex(*G,vb); /* 弧头 */
     e.info=NULL; /* 给待插表结点e赋值，图无权 */
     e.adjvex=j; /* 弧头 */
     if((*G).kind%2) /* 网 */
     {
       e.info=(int *)malloc(sizeof(int)); /* 动态生成存放权值的空间 */
       *(e.info)=w;
     }
     ListInsert(&(*G).vertices[i].firstarc,1,e); /* 插在第i个元素(出弧)的表头，在bo2-8.c中 */
     if((*G).kind>=2) /* 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头 */
     {
       e.adjvex=i; /* e.info不变，不必再赋值 */
       ListInsert(&(*G).vertices[j].firstarc,1,e); /* 插在第j个元素的表头，在bo2-8.c中 */
     }
   }
 }

 void CreateGraphF(ALGraph *G)
 { /* 采用邻接表 存储结构，由文件构造没有相关信息图或网G(用一个函数构造4种图) */
   int i,j,k,w; /* w是权值 */
   VertexType va,vb; /* 连接边或弧的2顶点 */
   ElemType e;
   char filename[13];
   FILE *graphlist;
   printf("请输入数据文件名(f7-1.txt或f7-2.txt)：");
   scanf("%s",filename);
   printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
   scanf("%d",&(*G).kind);
   graphlist=fopen(filename,"r"); /* 以读的方式打开数据文件，并以graphlist表示 */
   fscanf(graphlist,"%d",&(*G).vexnum);
   fscanf(graphlist,"%d",&(*G).arcnum);
   for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
   {
     fscanf(graphlist,"%s",(*G).vertices[i].data);
     (*G).vertices[i].firstarc=NULL; /* 初始化与该顶点有关的出弧链表 */
   }
   for(k=0;k<(*G).arcnum;++k) /* 构造相关弧链表 */
   {
     if((*G).kind%2) /* 网 */
       fscanf(graphlist,"%d%s%s",&w,va,vb);
     else /* 图 */
       fscanf(graphlist,"%s%s",va,vb);
     i=LocateVex(*G,va); /* 弧尾 */
     j=LocateVex(*G,vb); /* 弧头 */
     e.info=NULL; /* 给待插表结点e赋值，图无权 */
     e.adjvex=j; /* 弧头 */
     if((*G).kind%2) /* 网 */
     {
       e.info=(int *)malloc(sizeof(int)); /* 动态生成存放权值的空间 */
       *(e.info)=w;
     }
     ListInsert(&(*G).vertices[i].firstarc,1,e); /* 插在第i个元素(出弧)的表头，在bo2-8.c中 */
     if((*G).kind>=2) /* 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头 */
     {
       e.adjvex=i; /* e.info不变，不必再赋值 */
       ListInsert(&(*G).vertices[j].firstarc,1,e); /* 插在第j个元素的表头，在bo2-8.c中 */
     }
   }
   fclose(graphlist); /* 关闭数据文件 */
 }

 void DestroyGraph(ALGraph *G)
 { /* 初始条件：图G存在。操作结果：销毁图G */
   int i;
   ElemType e;
   for(i=0;i<(*G).vexnum;++i) /* 对于所有顶点 */
     if((*G).kind%2) /* 网 */
       while((*G).vertices[i].firstarc) /* 对应的弧或边链表不空 */
       {
	 ListDelete(&(*G).vertices[i].firstarc,1,&e); /* 删除链表的第1个结点，并将值赋给e */
         if(e.adjvex>i) /* 顶点序号>i(保证动态生成的权值空间只释放1次) */
           free(e.info);
       }
     else /* 图 */
       DestroyList(&(*G).vertices[i].firstarc); /* 销毁弧或边链表，在bo2-8.c中 */
   (*G).vexnum=0; /* 顶点数为0 */
   (*G).arcnum=0; /* 边或弧数为0 */
 }

 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 */
   LinkList p;
   int v1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   p=G.vertices[v1].firstarc;
   if(p)
     return p->data.adjvex;
   else
     return -1;
 }

 Status equalvex(ElemType a,ElemType b)
 { /* DeleteArc()、DeleteVex()和NextAdjVex()要调用的函数 */
   if(a.adjvex==b.adjvex)
     return OK;
   else
     return ERROR;
 }

 int NextAdjVex(ALGraph G,VertexType v,VertexType w)
 { /* 初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点 */
   /* 操作结果：返回v的(相对于w的)下一个邻接顶点的序号。若w是v的最后一个邻接点，则返回-1 */
   LinkList p,p1; /* p1在Point()中用作辅助指针，Point()在func2-1.c中 */
   ElemType e;
   int v1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   e.adjvex=LocateVex(G,w); /* e.adjvex为顶点w在图G中的序号 */
   p=Point(G.vertices[v1].firstarc,e,equalvex,&p1); /* p指向顶点v的链表中邻接顶点为w的结点 */
   if(!p||!p->next) /* 没找到w或w是最后一个邻接点 */
     return -1;
   else /* p->data.adjvex==w */
     return p->next->data.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,k;
   ElemType e;
   LinkList p,p1;
   j=LocateVex(*G,v); /* j是顶点v的序号 */
   if(j<0) /* v不是图G的顶点 */
     return ERROR;
   i=ListLength((*G).vertices[j].firstarc); /* 以v为出度的弧或边数，在bo2-8.c中 */
   (*G).arcnum-=i; /* 边或弧数-i */
   if((*G).kind%2) /* 网 */
     while((*G).vertices[j].firstarc) /* 对应的弧或边链表不空 */
     {
       ListDelete(&(*G).vertices[j].firstarc,1,&e); /* 删除链表的第1个结点，并将值赋给e */
       free(e.info); /* 释放动态生成的权值空间 */
     }
   else /* 图 */
     DestroyList(&(*G).vertices[i].firstarc); /* 销毁弧或边链表，在bo2-8.c中 */
   (*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为入度的弧或边且必要时修改表结点的顶点位置值 */
   {
     e.adjvex=j;
     p=Point((*G).vertices[i].firstarc,e,equalvex,&p1); /* Point()在func2-1.c中 */
     if(p) /* 顶点i的邻接表上有v为入度的结点 */
     {
       if(p1) /* p1指向p所指结点的前驱 */
         p1->next=p->next; /* 从链表中删除p所指结点 */
       else /* p指向首元结点 */
         (*G).vertices[i].firstarc=p->next; /* 头指针指向下一结点 */
       if((*G).kind<2) /* 有向 */
       {
         (*G).arcnum--; /* 边或弧数-1 */
         if((*G).kind==1) /* 有向网 */
           free(p->data.info); /* 释放动态生成的权值空间 */
       }
       free(p); /* 释放v为入度的结点 */
     }
     for(k=j+1;k<=(*G).vexnum;k++) /* 对于adjvex域>j的结点，其序号-1 */
     {
       e.adjvex=k;
       p=Point((*G).vertices[i].firstarc,e,equalvex,&p1); /* Point()在func2-1.c中 */
       if(p)
         p->data.adjvex--; /* 序号-1(因为前移) */
     }
   }
   return OK;
 }

 Status InsertArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件：图G存在，v和w是G中两个顶点 */
   /* 操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<w,v> */
   ElemType e;
   int i,j;
   i=LocateVex(*G,v); /* 弧尾或边的序号 */
   j=LocateVex(*G,w); /* 弧头或边的序号 */
   if(i<0||j<0)
     return ERROR;
   (*G).arcnum++; /* 图G的弧或边的数目加1 */
   e.adjvex=j;
   e.info=NULL; /* 初值 */
   if((*G).kind%2) /* 网 */
   {
     e.info=(int *)malloc(sizeof(int)); /* 动态生成存放权值的空间 */
     printf("请输入弧(边)%s→%s的权值: ",v,w);
     scanf("%d",e.info);
   }
   ListInsert(&(*G).vertices[i].firstarc,1,e); /* 将e插在弧尾的表头，在bo2-8.c中 */
   if((*G).kind>=2) /* 无向，生成另一个表结点 */
   {
     e.adjvex=i; /* e.info不变 */
     ListInsert(&(*G).vertices[j].firstarc,1,e); /* 将e插在弧头的表头 */
   }
   return OK;
 }

 Status DeleteArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件：图G存在，v和w是G中两个顶点 */
   /* 操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<w,v> */
   int i,j;
   Status k;
   ElemType e;
   i=LocateVex(*G,v); /* i是顶点v(弧尾)的序号 */
   j=LocateVex(*G,w); /* j是顶点w(弧头)的序号 */
   if(i<0||j<0||i==j)
     return ERROR;
   e.adjvex=j;
   k=DeleteElem(&(*G).vertices[i].firstarc,&e,equalvex); /* 在func2-1.c中 */
   if(k) /* 删除成功 */
   {
     (*G).arcnum--; /* 弧或边数减1 */
     if((*G).kind%2) /* 网 */
       free(e.info);
     if((*G).kind>=2) /* 无向，删除对称弧<w,v> */
     {
       e.adjvex=i;
       DeleteElem(&(*G).vertices[j].firstarc,&e,equalvex);
     }
     return OK;
   }
   else /* 没找到待删除的弧 */
     return ERROR;
 }

 Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
 void(*VisitFunc)(char* v); /* 函数变量(全局量) */
 void DFS(ALGraph G,int v)
 { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
   int w;
   visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
   VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */
   for(w=FirstAdjVex(G,G.vertices[v].data);w>=0;w=NextAdjVex(G,G.vertices[v].data,G.vertices[w].data))
     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");
 }

 typedef int QElemType; /* 队列元素类型 */
 #include"c3-2.h" /* 链队列的存储结构 */
 #include"bo3-2.c" /* 链队列的基本操作 */
 void BFSTraverse(ALGraph G,void(*Visit)(char*))
 {/*按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。算法7.6 */
   int v,u,w;
   LinkQueue Q;
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的辅助队列Q */
   for(v=0;v<G.vexnum;v++) /* 如果是连通图，只v=0就遍历全图 */
     if(!visited[v]) /* v尚未访问 */
     {
       visited[v]=TRUE;
       Visit(G.vertices[v].data);
       EnQueue(&Q,v); /* v入队列 */
       while(!QueueEmpty(Q)) /* 队列不空 */
       {
         DeQueue(&Q,&u); /* 队头元素出队并置为u */
         for(w=FirstAdjVex(G,G.vertices[u].data);w>=0;w=NextAdjVex(G,G.vertices[u].data,G.vertices[w].data))
           if(!visited[w]) /* w为u的尚未访问的邻接顶点 */
           {
             visited[w]=TRUE;
             Visit(G.vertices[w].data);
             EnQueue(&Q,w); /* w入队 */
           }
       }
     }
   printf("\n");
 }

 void DFS1(ALGraph G,int v,void(*Visit)(char*))
 { /* 从第v个顶点出发递归地深度优先遍历图G。仅适用于邻接表存储结构 */
   ArcNode *p; /* p指向表结点 */
   visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
   Visit(G.vertices[v].data); /* 访问该顶点 */
   for(p=G.vertices[v].firstarc;p;p=p->next) /* p依次指向v的邻接顶点 */
     if(!visited[p->data.adjvex])
       DFS1(G,p->data.adjvex,Visit); /* 对v的尚未访问的邻接点递归调用DFS1 */
 }

 void DFSTraverse1(ALGraph G,void(*Visit)(char*))
 { /* 对图G作深度优先遍历。DFS1设函数指针参数 */
   int v;
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 访问标志数组初始化，置初值为未被访问 */
   for(v=0;v<G.vexnum;v++) /* 如果是连通图，只v=0就遍历全图 */
     if(!visited[v]) /* v尚未被访问 */
       DFS1(G,v,Visit); /* 对v调用DFS1 */
   printf("\n");
 }

 void BFSTraverse1(ALGraph G,void(*Visit)(char*))
 { /* 按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。仅适用于邻接表结构 */
   int v,u;
   ArcNode *p; /* p指向表结点 */
   LinkQueue Q; /* 链队列类型 */
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 置初值为未被访问 */
   InitQueue(&Q); /* 初始化辅助队列Q */
   for(v=0;v<G.vexnum;v++) /* 如果是连通图，只v=0就遍历全图 */
     if(!visited[v]) /* v尚未被访问 */
     {
       visited[v]=TRUE; /* 设v为已被访问 */
       Visit(G.vertices[v].data); /* 访问v */
       EnQueue(&Q,v); /* v入队列 */
       while(!QueueEmpty(Q)) /* 队列不空 */
       {
         DeQueue(&Q,&u); /* 队头元素出队并置为u */
         for(p=G.vertices[u].firstarc;p;p=p->next) /* p依次指向u的邻接顶点 */
           if(!visited[p->data.adjvex]) /* u的邻接顶点尚未被访问 */
           {
             visited[p->data.adjvex]=TRUE; /* 该邻接顶点设为已被访问 */
             Visit(G.vertices[p->data.adjvex].data); /* 访问该邻接顶点 */
             EnQueue(&Q,p->data.adjvex); /* 入队该邻接顶点序号 */
           }
       }
     }
   printf("\n");
 }

 void Display(ALGraph G)
 { /* 输出图的邻接矩阵G */
   int i;
   LinkList p;
   switch(G.kind)
   {
     case DG: printf("有向图\n");
	      break;
     case DN: printf("有向网\n");
              break;
     case UDG:printf("无向图\n");
              break;
     case UDN: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||i<p->data.adjvex) /* 有向或无向两次中的一次 */
       {
         printf("%s→%s ",G.vertices[i].data,G.vertices[p->data.adjvex].data);
	 if(G.kind%2) /* 网 */
           printf(":%d ",*(p->data.info));
       }
       p=p->nextarc;
     }
     printf("\n");
   }
 }

權衡

可用於替代鄰接表的主要有鄰接矩陣。用稀疏鄰接矩陣表示鄰接表時，將占用更少的空間。這是因為它能避免為不存在的邊分配任何空間。在一台32位計算機上，如果使用原始的數組結構實現鄰接表，那麼對於一個無向圖來說，它大約需要占用字節的存儲空間，其中表示邊的個數。每條邊都將會在兩個鄰接表中重複出現，並分別占用4字節空間。

相反地，由於鄰接矩陣中的每個元素僅占用一位（bit），故可以以非常緊密的方式來存儲，僅占用個字節，其中代表頂點個數。除了節省空間外，這種緊密存儲也發揚了locality of reference。

注意到一個圖至多能有條邊（允許循環）。令表示圖的緻密度，則由，可知鄰接表將占用更多的空間，準確地說，僅當'以說只有當圖比較稀疏的時候，才有可能以較少的空間來存儲鄰接表。不過，以上分析只有在僅考慮邊的連接性，而不考慮關於邊的任何數值信息時才有效。

除了空間方面的考慮外，不同的數據結構也使得不同的操作變得更容易。在一個鄰接表中，給定一個頂點，可以很容易地找出它的所有鄰邊，因為只需要讀取它的鄰接表就可以了。在一個鄰接矩陣中，相同的操作則需要掃描一行，花費大約（大O標記）時間。而如果你想知道給定的兩個頂點間是否存在有邊，在鄰接矩陣里可以立刻查到，在鄰接表中則需要花費以邊的最小關聯度成比例的時間。

參考資料

取自「https://zh.wikipedia.org/w/index.php?title=邻接表&oldid=67977261」