图的存储——链式前向星

这里有神犇——该名称创始人的博客，大家可以去考古，一波肥😉

前向星

前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了

以下图为例构造前向星：

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

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

利用前向星，我们可以O(len[i])的时间找到以i为起点的所有边

前向星适合于优化稀疏图的BFS，DFS，单源最短路径(SPFA)

链式前向星

如果按前向星那样，第一步是给起点排序，时间复杂度至少为O(eloge)。如果使用链式前向星，就可以避免排序。所谓链式前向星，即将链表引入前向星，可以不排序也能达到前向星的效果，这里的链表是指的是数组模拟链表

首先我们创建一个结构体：

struct node{
	int to,next,w; //to表示第i条边的终点，next表示与第i条边同起点的下一条边的存储位置，w表示权值
}edge[N];

然后设置一个head数组，该数组存的是以i为起点的第一条边的位置（即输入时的编号又是edge数组的下标）

显然这个下标我们需要设置为全局变量tot

int head[N];  
int tot;	//edge数组的下标

接下来就是我们的主角：add函数，它表示的是图的初始化过程。下面我们先让tot++是因为刚开始tot等于0，我们设置的链表结束条件是edge[i].next==0，因此这里不能给edge[0].next赋值

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

我们举一个简单的例子，假如1号顶点对应三条边，其余三个顶点分别为2,5,6，那么我们这样输入：

1 2
1 5
1 6

第i行	^	1	2	3
edge[i].next	^	0	1	2
head[1]	0	1	2	3

edge[i].next刚好和head构成数组模拟的链表，由于我们head数组只用起点u来访问，因此只需要一个head数组就足够使所有的起点都能在数组上维护链表关系

那么就得出了如何访问某一特定节点的邻接边：

int start; //输入要访问的起点
for(int i=head[start];i;i=edge[i].next)
	   cout<<start<<"->"<<edge[i].to<<" "<<edge[i].w<<endl;

总结链式前向星，我们可以发现下面结论：

• 链式前向星并不改变边表原来的存储顺序，只是建立了元素之间的关系
• 可以发现，这是变式的邻接表，或者说链式前向星是邻接表的数组实现形式
• 相对于邻接表，无向图的链式前向星实现更为简单，可以省大约一半的空间，而且时间也会节省不少

下面是测试代码：

#include <iostream>

using namespace std;

const int N=1e5+10;
struct node{
	int next,to,w;
}edge[N];

int tot;
int head[N];

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

int main(){
	int n;
	cin>>n;
	int a,b,c;
	while(n--){
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int start;
	while(cin>>start){
        for(int i=head[start];i;i=edge[i].next)
            cout<<start<<"的一条边是"<<edge[i].to<<" "<<edge[i].w<<endl;
	}
	return 0;
}