链式向前星（领接表）

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

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

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

那么对于下图

我们输入边的顺序为:

1 2

2 3

3 4

1 3

4 1

1 5

4 5

edge结构体里面存放的是：
to：该条边指向的下一个顶点
value：即该条边的权值
next：表示与此条边的from顶点连接的其他边
用head[from]来记录每一个顶点连接的其他边的最大编号

这样我们就可以根据每一次回去遍历以from为顶点的边，找到该条边，该条边所连接的下一条边就是edge[i].next=head[from] (此时head[from]即为前一条from顶点相连的另一条边) 续往下找，所以我们就找到了以from为顶点的所有边了

编号[i]	0	1	2	3	4	5	6
from	1	2	3	1	4	1	4
to	2	3	4	3	1	5	5
next	-1	-1	-1	0	-1	3	4
head[from]	0	1	2	3	4	5	6

最终得出的head

i	1	2	3	4	5
——	5	1	2	6	5

解释一下from等于1的时候，因为我们是从后面往前找，head[1]=6，此时我们就找
next —— 3 —————— 0 —————— -1
edge5———> edge3————>edge0————>结束

#include 
#include 
#include 
 
using namespace std;
const int maxn=1100000;
const int maxm=110000;
 
struct node
{
	int next,to,value;
};
 
node edge[maxm];
int head[maxn];
int n,m,cnt;
 
void add_edge(int from,int to,int cost)
{
	edge[cnt].to=to;
	edge[cnt].value=cost;
	edge[cnt].next=head[from];
	head[from]=cnt++;
	/*head[i]保存的是以i为起点的所有边中编号最大的那个*/
}
 
void show()
{
	int i,t;
	for(i=1;i<=n;i++)
	{
		t=head[i];
		while(t!=-1)
		{
			cout<<i<<"-->"<<edge[t].to<<" need "<<edge[t].value<<endl;
			t=edge[t].next;
		}
	}
}
 
int main()
{
	//freopen("input.txt","r",stdin);
	int from,to,cost;
	while(cin>>n>>m)
	{
		memset(edge,0,sizeof(edge));
		memset(head,-1,sizeof(head));
		cnt=0;
		while(m--)
		{
			cin>>from>>to>>cost;
			add_edge(from,to,cost);
			add_edge(to,from,cost);
		}
		show();
	}
	return 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/hz18790581821/article/details/70233495