图的邻接表

邻接矩阵和邻接表区别：

对于n个顶点，m条边，对于n阶有向完全图最大的m=2*（ n-1+(n-2)+(n-3)+...+2+1 ）= O(n^2) ,当边数远小于n^2的稀疏图来说用邻接表储存图的空间时间复杂度是O(M)，而邻接矩阵储存是O(N^2).

邻接表的两种实现方式：

 1.用数组实现：

int u[ ],v[ ],w[ ];    //分别储存u点，v点，和边权值。

int first[ n+1 ];   //下标表示1，2,....,n点，储存着各个点目前时间最后读入的一条边。所以一开始没有读入任何边要初始化成-1.

int next[ m+1];  //每一个特定的下标表示出自某一点i的某个边a，这个特定的下标的单元里储存着与i点相连的另一个边b，依次类推，相当于一条链表记录下了i顶点所有相连的边。

代码实现：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int n,m;
int a,b,c;
int u[100],v[100],w[100];
int first[100],next[100];
void ini()
{
    cin>>n>>m;
    memset(first,-1,sizeof(first));
    for(int i=1;i<=m;i++){
        cin>>a>>b>>c;
        u[i]=a,v[i]=b,w[i]=c;
        next[i]=first[u[i]];
        first[u[i]]=i;
    }
}
void print()//遍历
{
    for(int i=1;i<=n;i++)
    {
        int k=first[i];
        while(k!=-1){
            printf("u[%d]=%d,v[%d]=%d,w[%d]=%d\n",k,u[k],k,v[k],k,w[k]);
            k=next[k];
        }

    }
}
int main()
{
    ini();
    print();
}

输入和输出：

4 5
1 4 9
2 4 6
1 2 5
4 3 8
1 3 7
u[5]=1,v[5]=3,w[5]=7
u[3]=1,v[3]=2,w[3]=5
u[1]=1,v[1]=4,w[1]=9
u[2]=2,v[2]=4,w[2]=6
u[4]=4,v[4]=3,w[4]=8

可以发现此时遍历某个顶点的边的时候遍历的顺序正好和读入顺序相反，因为每个顶点插入边的时候都是直接插入到“链表”的首部而不是尾部。不过并不产生任何问题，这正是这种方法的奇妙之处。

2.用vector实现

vector实现的特点是思路清晰遍历某个顶点的边的时候顺序和读入顺序相同。保存边权值就用pair保存.

vector的下标表示1...n各个顶点。

代码实现：

#include<iostream>
#include<cstdio>
#include<vector>
#define N 101
using namespace std;
int n,m;
int a,b,c;
typedef pair<int,int> pii;
vector<pii> G[N];
void ini()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        cin>>a>>b>>c;
        G[a].push_back( make_pair(b,c) ); // 有向边，而且要学会make_pair的使用很方便。
    }
}
void print()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<G[i].size();j++){
            printf("%d %d %d\n",i,G[i][j].first,G[i][j].second);
        }
    }
}
int main()
{
    ini();
    print();
    return 0;
}

输入：

4 5
1 4 9
2 4 6
1 2 5
4 3 8
1 3 7

输出：

1 4 9
1 2 5
1 3 7
2 4 6
4 3 8