图的存储方式

Solution1：邻接矩阵 
方法十分简单，定义一个二维数组edge [i] [j]（edge是边&边缘的意思）,如果边上有权值就定义int类型数组，没有的话用bool类型（省内存，int类型为4B,bool为1B），edge [i] [j] 表示i,j之间的边权值，无向图在输入的时候要edge [i] [j] = edge [j] [i] ,有向图则不用

#include<iostream>
#include<cstdio>
int edge[1010][1010],n,m;
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y,v;
        scanf("%d %d %d",&x,&y,&v);
        edge[x][y]=edge[y][x]=v;//向x,y间添加一个权值为v的边(无向)
        //有向图为edge[x][y]=v;
    }
    return 0;
}

 

邻接矩阵十分占内存，如果n*m超过3×10e7，内存就超过128MB了，所以当看到类似的 
n,m=<10e4时 就不要用邻接矩阵了~~~

---

Solution 2: 邻接表 
邻接表是链状的（别被这个名字吓到），它实际上是一个离散化的邻接矩阵，定义一个结构体

 

struct node
{
    int to[1010];
    int v[1010];
    int len;
}edge[1010];

 edge[i]表示第i号节点，.to[ ]表示到与别的节点联通的路径，.v[ ] 就很简单辣，是i到edge[i].to[j]号节点的权值，.len 用来标记一共有几个联通i节点的边（或者是i的出度）

#include<iostream>
#include<cstdio>
struct node
{
    int to[1010];
    int v[1010];
    int len;
}edge[1010];
int n,m;
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y,v1;
        scanf("%d %d %d",&x,&y,&v1);
        edge[x].len++;edge[y].len++;
        edge[x].to[edge[x].len]=y;edge[y].to[edge[x].len]=x;
        edge[x].v[edge[x].len]=edge[y].to[edge[x].len]=v1;//向x,y间添加一个权值为v的边(无向)
        /*有向图为
        edge[x].len++;
        edge[x].to[edge[x].len]=y;
        edge[x].v[edge[x].len]=v1;
        */
    }
    return 0;
}

 

 

邻接表的好处是当n很大（10e5），但是m很小（200）时，可以用邻接表存储整个图，但是它也有缺点：时间。邻接矩阵的查找时间为O(1),可是邻接表需要O(edge[x].len),当出题人诚心要卡数据的时候，他会让一个节点连上剩下所有的n-1个节点，这样查找时间会大大降低,退化成O(n)，而且内存也存在隐患。

---

Solution 3:前向星 
前向星这个名字听起来不咋的，但是在内存上，它可是稳稳的O(nlogn),因为它的初始化需要排序，直接sort一下,就需要O(nlogn)的时间复杂度辣 
又是一个结构体

 

struct node
{
    int to;
    int x;
    int v;
}edge[1010];

用edge[i]表示第i条边，.x,.to,.v表示从.x到.to的一条权值为v的边，输入后按照.x从小到大的顺序sort，用一个head[i]数组标记第i号节点第一次在edge中出现的位置（排序后） 
比如说这样的数据： 
1 3 
2 3 
1 4 
3 5 
1 5 
2 5 
因为是无向图，所以要双向添加edge,所以数据变成了 
1 3 
3 1 
2 3 
3 2 
1 4 
4 1 
3 5 
5 3 
1 5 
5 1 
2 5 
5 2 
排序之后： 
1 3 
1 4 
1 5 
2 3 
2 5 
3 2 
3 5 
4 1 
5 1 
5 3 
5 2 
这时开始标记head数组： 
head 1 4 6 8 9 (标记num节点在edge中第一次出现的位置 
num 1 2 3 4 5 
好啦，接下来奉上代码：

#include<iostream>
#include<cstdio>
#include<algorithm>//sort()
using namespace std;
struct node
{
    int to;
    int x;
    int v;
}edge[2010]; //因为是无向图，所以要2*n的空间
int head[1010];
bool cmp(node a,node b)//compare（比较）的简称
{
    return a.x>b.x;
}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d".&edge[i*2-1].x,&edge[i*2-1].to,&edge[i*2-1].v);//双向添加边，数组下标2*n-1和2*n;有向图就是i;
        edge[i*2].x=edge[i*2-1].to;edge[i*2].to=edge[i*2-1].x;edge[i*2].v=edge[i*2-1].v;//同上
    }
    sort(edge+1,edge+2*m+1,cmp)//排序
    head[1]=1;
    for(int i=1;i<=m;i++)
        if(edge[i-1].x!=edge[i].x)  head[edge[i+1].x]=i;
}

PS.有的同学会问，不是还有个链式前向星吗？为森马不讲？我对此给出合理解释：

1. 因为链式前向星比前向星复杂，在各种比赛中会浪费更多时间
2. 链式前向星只是少了个nlogn的排序过程，一般来说只要有与图相关的算法，都要n²的时间，比起来nlogn几乎只是常数级而已~~

原创：https://blog.csdn.net/tyk_13_dsfz/article/details/81434833 

 

深度理解链式前向星

我们首先来看一下什么是前向星.

 

前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,

并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了.

 

用len[i]来记录所有以i为起点的边在数组中的存储长度.

用head[i]记录以i为边集在数组中的第一个存储位置.

 

那么对于下图:

 

 

 

我们输入边的顺序为:

 

1 2

2 3

3 4

1 3

4 1

1 5

4 5

 

那么排完序后就得到:

 

编号:     1      2      3      4      5      6      7

起点u:    1      1      1      2      3      4      4

终点v:    2      3      5      3      4      1      5

 

得到:

 

head[1] = 1    len[1] = 3

head[2] = 4    len[2] = 1

head[3] = 5    len[3] = 1

head[4] = 6    len[4] = 2

 

但是利用前向星会有排序操作,如果用快排时间至少为O(nlog(n))

 

 

如果用链式前向星,就可以避免排序.

 

我们建立边结构体为:

 

struct Edge

{

     int next;

     int to;

     int w;

};

其中edge[i].to表示第i条边的终点,edge[i].next表示与第i条边同起点的下一条边的存储位置,edge[i].w为边权值.

 

另外还有一个数组head[],它是用来表示以i为起点的第一条边存储的位置,实际上你会发现这里的第一条边存储的位置其实

在以i为起点的所有边的最后输入的那个编号.

 

head[]数组一般初始化为-1,对于加边的add函数是这样的:

void add(int u,int v,int w)
{
    edge[cnt].w = w;
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

 

初始化cnt = 0,这样,现在我们还是按照上面的图和输入来模拟一下:

 

 

edge[0].to = 2;     edge[0].next = -1;      head[1] = 0;

edge[1].to = 3;     edge[1].next = -1;      head[2] = 1;

edge[2].to = 4;     edge[2],next = -1;      head[3] = 2;

edge[3].to = 3;     edge[3].next = 0;       head[1] = 3;

edge[4].to = 1;     edge[4].next = -1;      head[4] = 4;

edge[5].to = 5;     edge[5].next = 3;       head[1] = 5;

edge[6].to = 5;     edge[6].next = 4;       head[4] = 6;

 

很明显,head[i]保存的是以i为起点的所有边中编号最大的那个,而把这个当作顶点i的第一条起始边的位置.

 

这样在遍历时是倒着遍历的,也就是说与输入顺序是相反的,不过这样不影响结果的正确性.

比如以上图为例,以节点1为起点的边有3条,它们的编号分别是0,3,5   而head[1] = 5

 

我们在遍历以u节点为起始位置的所有边的时候是这样的:

 

for(int i=head[u];~i;i=edge[i].next)

 

那么就是说先遍历编号为5的边,也就是head[1],然后就是edge[5].next,也就是编号3的边,然后继续edge[3].next,也

就是编号0的边,可以看出是逆序的.

原创：https://blog.csdn.net/ACdreamers/article/details/16902023