邻接表怎么写

  数据结构书上表示邻接表比较复杂，一般形式如下：

struct ArcNode{            //边结点
    int adjvex;            //有向边的另一个邻接点的序号
    ArcNode *nextarc;    //指向下一个边结点的指针
};

struct VNode {            //顶点
    int data;            //顶点信息
    ArcNode *head1;        //出边表的表头指针
    ArcNode *head2;        //入边表的表头指针
};

struct LGraph{            //图的邻接表储存结构
    VNode vertes[MAXN];    //顶点数组
    int vexnum,arcnum;    //顶点数和边(弧)数
};
LGraph lg;                //图(邻接表存储)

 输入n,m分别为图的顶点数目和边数

接下来m行输入分表输入一条边的起点和终点

输出每个顶点的出度和入度

#include "iostream"
#include "algorithm"
#include "memory.h"
#include "cmath"
using namespace std;
#define MAXN 111


struct ArcNode{            //边结点
    int adjvex;            //有向边的另一个邻接点的序号
    ArcNode *nextarc;    //指向下一个边结点的指针
};

struct VNode {            //顶点
    int data;            //顶点信息
    ArcNode *head1;        //出边表的表头指针
    ArcNode *head2;        //入边表的表头指针
};

struct LGraph{            //图的邻接表储存结构
    VNode vertes[MAXN];    //顶点数组
    int vexnum,arcnum;    //顶点数和边(弧)数
};
LGraph lg;                //图(邻接表存储)


void CreateLG()                                    //采用邻接表存储表示，构造有向图G
{                                                
    int i = 0;                                    //循环变量
    ArcNode  *pi;                                //用来构造边链表的边结点指针
    int v1,v2;                                    //有向边的两个顶点
    //lg.vexnum = lg.arcnum = 0;                    
    //scanf("%d%d",&lg.vexnum,&lg.arcnum);
    for (int i = 0;i < lg.vexnum; ++ i)            //初始化表头指针为空
        lg.vertes[i].head1 = lg.vertes[i].head2 = NULL;
    for (int i = 0;i < lg.arcnum; ++ i) 
    {
        scanf("%d%d",&v1,&v2);                    //输入一条边的起点和终点
        v1--,v2--;
        pi = new ArcNode;
        pi -> adjvex = v2;
        pi -> nextarc = lg.vertes[v1].head1;    //插入链表
        lg.vertes[v1].head1 = pi;
        pi = new ArcNode;
        pi -> adjvex = v1;
        pi -> nextarc = lg.vertes[v2].head2;    //插入链表
        lg.vertes[v2].head2 = pi;
    }//end of for
}//end of CreateLG

void DeleteLG()
{
    int i;
    ArcNode *pi;
    for (i = 0;i < lg.vexnum; ++ i)
    {
        pi = lg.vertes[i].head1;
        while (pi != NULL)
        {
            lg.vertes[i].head1 = pi -> nextarc;
            delete pi;
            pi = lg.vertes[i].head1;
        }
        pi = lg.vertes[i].head2;
        //释放第i个顶点去边表各边结点所占的存储空间
        while( pi != NULL) 
        {
            lg.vertes[i].head2 = pi->nextarc;
            delete pi;
            pi = lg.vertes[i].head2;
        }
    }
}


int main()
{
    int i;                                        //循环变量
    int id,od;                                    //顶点的入度和出度
    ArcNode *pi;                                //用来遍历边链表的边结点指针
    while (1)
    {
        lg.vexnum = lg.arcnum = 0;
        scanf("%d%d",&lg.vexnum,&lg.arcnum);        
        //首先输入顶点个数和边数
        if (lg.vexnum == 0) break;                //输入数据结束
        CreateLG();                                //构造有向图的邻接表结构
        for (i = 0;i < lg.vexnum; ++ i)            //统计各顶点出度并输出
        {
            od = 0;
            pi = lg.vertes[i].head1;
            while (pi != NULL) 
            {
                od++;
                pi = pi -> nextarc;
            }
            if (i == 0) printf("%d",od);
            else printf(" %d",od);
        }
        puts("");
        for (i = 0;i < lg.vexnum; ++ i)            //统计各顶点入度并输出
        {
            id = 0;
            pi = lg.vertes[i].head2;
            while (pi != NULL)
            {
                id++;
                pi = pi -> nextarc;
            }
            if (i == 0 ) printf("%d",id);
            else printf(" %d",id);
        }
        puts("");
        DeleteLG();                                //释放
    }
    return 0;
}

    其实有种简洁且高效的表示形式：

typedef struct
{
    int to;
    int w;
    int next;
}Edge;
Edge e[MAX];
int pre[MAX];

//初始化
memset(pre,-1,sizeof(pre));

//输入
scanf("%d %d %d",&from,&to,&w1);
e[i].to = to; e[i].w = w1; e[i].next = pre[from]; pre[from] = i;
i++;

 

    上面这段代码中，边的结构体Edge由三个元素组成：弧头结点序号，边权值，下一条边的序号。e[i]指的是第i条边。pre[i]记录的是从当前输入的情况来看，序号为i的弧尾结点发出的第一条边的序号是pre[i]。

    这样，在操作某个结点发出的边时，可以像这么做：

/*now为弧尾结点序号，i为now所发出的边序号，adj为弧头结点序号，w为now-->adj这条边的权值*/
for(i = pre[now]; i != -1; i = edge[i].next)
{
     int adj = edge[i].to;
     int w = edge

[i].w;
     //do something...
}

　　

    其实，对于哈希表这类的存储结构(链表法解决冲突)，与图的邻接表类似，也可以用类似的表示方法：

typedef struct  
{  
    char e[11];    //value  
    char f[11];     //key  
    int next;        //下一个结果(hash冲突)  
}Entry;  
Entry entry[M];  
int hashIndex[M];   //哈希值为M的结果集的第一个在entry中的序号。  
  
//输入：对key进行hash，  
sscanf(str,"%s %s",entry[i].e,entry[i].f);  
int hash = ELFHash(entry[i].f);  
entry[i].next = hashIndex[hash];  
hashIndex[hash] = i;  
i++;  
  
//使用：  
for(int k = hashIndex[hash]; k; k = entry[k].next)  
{  
    //do something..  
}  

以上转自http://yzmduncan.iteye.com/blog/883903

vector建立邻接表

建表
vetcor<int> G[maxn];

插入元素
void Insert()
{
	G[a].pushback(b);
}

遍历元素
void dfs()
{
	for (int i = 0;i < G[u].size();++ i)
		dfs(G[u][i]);
}