存图-深度理解链式前向星

前向星

在接触链式前向星之前，先了解一下什么是前向星。

前向星就是一种边集数组。我们先把每条边的起点按照从小到大的顺序排序如果起点一样，那么就按照终点从小到达来排

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

head[i]表示以i为起点的边在数组中储存的第一个位置，

len[i]表示以i为起点的边的条数。

我们输入边的顺序为：

1 2

2 3

3 4

4 5

4 1

1 3

1 5

经过排序后得到： 

编号	起点u	终点v
1	1	2
2	1	3
3	1	5
4	2	3
5	3	4
6	4	1
7	4	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(1)的时间内找到以i为起点的第一条边以O(len[i])的时间找到以i为起点的所有边。

前向星特别适合用来优化SPFA(一种最短路算法),DFS以及BFS（深度优先搜索和宽度优先搜索）。

但是前向星还是需要加上排序的时间的，如果是快排大概是O(n*log(n));

而链式前向星则不需要排序也能够得到。

链式前向星

采用链式前向星可以避免排序。

建立结构体为：

struct Edge
{
    int to;
    int val;
    int next;
};

edge[i].to表示第i条边的终点

edge[i].next表示与第i条边同起点的下一条边的存储位置。

edge[i].w表示边权值

另外还有一个数组head[]，它是用来表示以i为起点的第一条边的存储的位置，实际上你会发现这里的第一条边存储的位置其实是在以i为起点的所有边的最后输入的那个编号。

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

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

 初始化cnt = 0,下面模拟一下链式前向星的存图过程：

输入顺序依然为：

1 2

2 3

3 4

1 3

4 1

1 5

4 5

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的边,可以看出是逆序的.