图

一、邻接矩阵（不多说了）  G[u][v]

二、邻接表

                  1、动态链表（指针）      一个数组表头（u）+ struct结点（v），相链，若有权值等信息再在结点里加相应域。

                  2、静态链表（数组）      first数组（模拟表头、u）+ 边集数组（编号e，u、v）+ next数组（模拟指针相指）。这个跟1看似有点区别（前者链的是点，后者链的是边），其实是没区别，因为要用数组实现链表，所以对1中所有结点实行e编号，意义就是“边”。

通常实现方法： 开五个数组 first[MAXN]; u[MAXM], v[MAXM], w[MAXM], next[MAXM]。

三、边集数组

就是把所有边放在一个数组里，这样就可以完成遍历所有边的操作了（很土吧= =）。通常要根据实际需要做一些辅助储存。

1、上面的数组实现邻接表就是边集数组再加上first数组和next数组。

2、前向星。跟1很相似的，区别是他对边集数组按u点（前一个端点）升序排序，使得由同一个点出发的边都集中在一起了。再加上辅助数组 f[MAXN]（跟前面first数组类似的作用），存 结点i 出发的第一个边在边集数组里的位置。 

所以注意到，前向星其实就是做了一个紧缩存储的处理，并且通过一次排序，省掉了next数组（静态邻接表）。当然也可以不排序，多维护一个next数组。

通常实现方法：开四个数组 f[MAXN]; u[MAXM], v[MAXM], w[MAXM]。

附：

①静态邻接表+Dijkstra+heap

[cpp]  view plain copy

1. //  Dijkstra+静态邻接表  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<iostream>  
5. #include<queue>  
6. using namespace std;  
7.   
8. #define MAXN 100  
9. #define MAXM 100  
10. #define INF 1<<30  
11. typedef pair<int, int> pii;       //(dist[v], v)  
12. priority_queue<pii, vector<pii>, greater<pii> > q;  
13. int first[MAXN];  
14. int u[MAXM], v[MAXM], w[MAXM], next[MAXM];  
15. int dist[MAXN], ins[MAXN];  //  ins[]  是否在s集合中  
16. int n, m;  
17.   
18. void dijkstra(int st)  
19. {  
20.     for(int i=0; i<n; i++) dist[i] = i==st? 0: INF;  
21.     memset(ins, 0, sizeof(ins));  
22.     q.push(make_pair(dist[st], st));  
23. //  ins[st] = 1;                        //别跟spfa inq弄混，在优先队列里取出来才算是ins了  
24.     while(!q.empty())  
25.     {  
26.         pii p = q.top();    q.pop();  
27.         int x = p.second;  
28.         if(!ins[x])  
29.         {  
30.             ins[x] = 1;  
31.             for(int i=first[x]; i!=-1; i=next[i])  
32.             {  
33.                 if(dist[v[i]] > dist[x]+w[i])        //relax  
34.                 {  
35.                     dist[v[i]] = dist[x] + w[i];  
36.                     q.push(make_pair(dist[v[i]], v[i]));  
37.                 }  
38.             }  
39.         }  
40.     }//end of while  
41. }  
42.   
43. void read_graph()  
44. {  
45.     scanf("%d%d", &n, &m);  
46.     memset(first, -1, sizeof(first));  
47.     for(int i=0; i<m; i++)  
48.     {  
49.         scanf("%d%d%d", &u[i], &v[i], &w[i]);  
50.         next[i] = first[u[i]];  
51.         first[u[i]] = i;  
52.     }  
53. }  
54.   
55. int main()  
56. {  
57.     read_graph();  
58.     int st;  
59.     dijkstra(scanf("%d", &st));  
60.     for(int i=0; i<n; i++)  
61.     {  
62.         printf("[%d,%d]=%d\n", st, i, dist[i]);  
63.     }  
64. }  

②静态邻接表+spfa

[cpp]  view plain copy

1. #include<cstdio>  
2. #include<cstring>  
3. #include<iostream>  
4. #include<queue>  
5. using namespace std;  
6. #define MAXN 100  
7. #define MAXM 100  
8. #define INF 1<<30  
9. queue<int> q;  
10. int first[MAXN], next[MAXM];  
11. struct edge  
12. {  
13.     int u, v, w;  
14. }a[MAXM];  
15. int dist[MAXN], inq[MAXN];  
16. int n, m;  
17.   
18. void spfa(int st)  
19. {  
20.     for(int i=0; i<n; i++) dist[i] = i==st? 0: INF;  
21.     memset(inq, 0, sizeof(inq));  
22.     q.push(st);  
23.     inq[st] = 1;                    //反正马上就出队，这个inq可以不要  
24.     while(!q.empty())  
25.     {  
26.         int u = q.front(); q.pop();  
27.         inq[u] = 0;  
28.         for(int e=first[u]; e!=-1; e=next[e])  
29.         {  
30.             int v = a[e].v;  
31.             if(dist[v] > dist[u]+a[e].w)  
32.             {  
33.                 dist[v] = dist[u]+a[e].w;  
34.                 if(!inq[v]) { q.push(v); inq[v] = 1; }      //inq=1 !!!!  
35.             }  
36.         }  
37.     }  
38. }  
39.   
40. void read_graph()  
41. {  
42.     cin>>n>>m;  
43.     memset(first, -1, sizeof(first));       //别忘了初始化 表头  
44.     for(int e=0; e<m; e++)  
45.     {  
46.         cin>>a[e].u>>a[e].v>>a[e].w;  
47.         next[e] = first[a[e].u];  
48.         first[a[e].u] = e;  
49.     }  
50. }  
51.   
52. int main()  
53. {  
54.     read_graph();  
55.     int st;  
56.     cin>>st;  
57.     spfa(st);  
58.     for(int i=0; i<n; i++)  
59.     {  
60.         printf("[%d,%d]=%d\n", st, i, dist[i]);  
61.     }  
62. }