图的存储

图的四种存储方式邻接矩阵，前向星，邻接表，链式前向星。

输入文件内容：

8 12
1    2    4
1    6    9
3    1    22
3    2    19
4    3    17
5    8    29
6    1    12
6    5    9
6    7    4
7    4    25
8    3    11
8    7    7

邻接矩阵：图的数据结构中最简单，最常用的一种。完成初始化后，对有向图，加边的操作就是graph[u][v]=c。对无向图，必须再加上graph[v][u]=c。它的缺点：遍历效率低，不能存储重边，大图的空间开销太大。//例如当n>10e7时建立一个int 一维数组 too large.

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=101;
int graph[maxn][maxn];
int main()
{
    //freopen("cin.txt","r",stdin);
    int n,m,i,j,a,b,val;
    cin>>n>>m;  //规模以及实际的边数。例子中数据是8,12.
    for(i=0;i<m;i++){
        scanf("%d%d%d",&a,&b,&val);
        graph[a][b]=val;
    }
    //遍历：
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
            if(graph[i][j])printf("%d %d %d\n",i,j,graph[i][j]);
    return 0;
}

前向星：将边存放在数组中，把数组中的边按照起点的顺序排序，为查询方便，经常有一个数组存储起点为Vi的第一条边的位置。

memset(head,-1,sizeof(head)); //全部成-1

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=100,maxm=140;
int head[maxn];  //存储起点为Vi的第一条边的位置。
struct node{
    int from,to,w;
}edge[maxm];
bool cmp(node a,node b){
   if(a.from==b.from&&a.to==b.to)return a.w<b.w;
   if(a.from==b.from)return a.to<b.to;
   return a.from<b.from;
}
int main()
{
    freopen("cin.txt","r",stdin);
    int n,m;
    cin>>n>>m;  //规模以及实际的边数。例子中数据是8,12.
    int i,j;
    for(i=1;i<=m;i++)scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].w);
    sort(edge+1,edge+m+1,cmp);
    head[edge[1].from]=1;  //head下标代表顶点的编号1--8。head本身代表边的序号0--11
    for(i=2;i<=m;i++)if(edge[i].from!=edge[i-1].from)head[edge[i].from]=i; //起点为Vi的第一条边的位置
    //遍历：
    for(i=1;i<=n;i++)
        for(j=head[i];edge[j].from==i&&j<=m;j++)printf("%d %d %d\n",edge[j].from,edge[j].to,edge[j].w);
    return 0;
}

邻接表：把所有邻接于Vi的顶点Vj链接成一个单链表，此单链表称为顶点Vi的邻接表。

邻接表的实现：动态建表，C++ STL vector模拟链表，链式前向星（静态建表）

动态建表的时间复杂度：O(m)，空间复杂度：O(m)，但是内存的释放和申请，判断任意两点的相连都是它的缺点。

vector模拟链表的方法和动态建表相比不用考虑内存申请释放问题，代码写的少且简单，但思想类似，所以注重研究这种方法：

#include <iostream>
#include<cstdio>
#include<vector>
using namespace std;
const int maxn=101;
struct node{
    int to,w;
};
int main()
{
    freopen("cin.txt","r",stdin);
    vector<node> qn[maxn];  //考虑重边，所以"[]"
    int n,m,i,j,a,b,val;
    cin>>n>>m;  //规模以及实际的边数。例子中数据是8,12.
    for(i=0;i<m;i++){
        scanf("%d%d%d",&a,&b,&val);
        node t;
        t.to=b;  t.w=val;
        qn[a].push_back(t);
    }
    //遍历：
    for(i=1;i<=n;i++)
        for(vector<node>::iterator k=qn[i].begin();k!=qn[i].end();k++){
            node t1=*k;  //一定要新建一个node变量才能顺利输出to,w，不能直接"*k.to,*k.w"
            printf("%d %d %d\n",i,t1.to,t1.w);
        }
 //清除操作：
    for(i=0;i<m;i++)qn[i].clear();//qn.erase(qn.begin(),b.end())
    return 0;
} 

输出结果：

1 2 4
1 6 9
3 1 22
3 2 19
4 3 17
5 8 29
6 1 12
6 5 9
6 7 4
7 4 25
8 3 11
8 7 7

链式前向星，遍历效率高，额外空间少，时间复杂度O(m)，这是一种很优秀的图的数据存储结构。

存储图：

输出结果：

1 6 9
1 2 4
3 2 19
3 1 22
4 3 17
5 8 29
6 7 4
6 5 9
6 1 12
7 4 25
8 7 7
8 3 11

#include <iostream>
#include<cstdio>
using namespace std;
const int maxn=101,maxm=141;
int head[maxn];
struct node{
 int to,w,next;
}edge[maxm];
int main(){
    freopen("cin.txt","r",stdin);
    freopen("cout1.txt","w",stdout);
    int n,m,k,i; cin>>n>>m; //规模以及实际的边数。例子中数据是8,12.
    for(i=0;i<m;i++){
        k=i+1;
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        edge[k].to=b;
        edge[k].w=c;
        edge[k].next=head[a];
        head[a]=k;
    }
    //遍历：
    for(i=1;i<=n;i++)
       for(k=head[i];k!=0;k=edge[k].next){ printf("%d %d %d\n",i,edge[k].to,edge[k].w); }
    return 0;
}