图论--链式前向星

我们存图的方式通常有邻接矩阵和前向星，邻接矩阵易造成空间浪费，前向星需要sort排序,复杂度是O（nlogn），所以效率不高，链式前向星是前向星的优化，它可以避免排序。

以下是边的存储结构

struct Node{
    int to;
    int w;
    int next;
}edge[maxn];

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

除此之外我们还需要一个head数组，它表示的是以i为起点的第一条边的存储位置，首先将head数组全部赋初值-1

下面是边的读入

void addEdge(int u,int v,int w)//每条边的起点,终点,权值
 {
    edge[cnt].to = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];//获取与它同起点的边的下一条位置
    head[u] = cnt++;//cnt的初值赋0
 }

head数组是以i为起点的第一条边的存储位置，这个以i为起点的第一条边随着cnt的增加而增加，其实这个第一条边是以该起点为边的最后一条边出现的位置，所以遍历每条边的时候其实是反向遍历的，假设我们要遍历以u为起点的所有边，当遍历到以u为起点的最后一条边的时候，因为head赋予的初值为-1，那么下一次i就等于-1了，循环就不再执行了

 

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

我们来模拟一遍，假设现在加入的边的顺序是(1,3)  (2,4) (3,4) (1,2) (3,1) (1,5)

edge[0].to = 3；edge[0].next = head[1] = -1；head[1] = 0；

edge[1].to = 4；edge[1].next = head[2] = -1；head[2] = 1；

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

edge[3].to = 2；edge[3].next = head[1] = 0；head[1] = 3；

edge[4].to = 1；edge[4].next = head[3] = 2；head[3] = 4；

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

假设我们遍历的是以1为起点的所有边 i = head[1] = 5 ，就是(1,5)这条边，然后i = edge[i].next = 3,就是(1,2)这条边，最后i = edge[i].next = 0，即(1,3)这条边，i = edge[0].next=-1，然后循环结束。至此，以1为起点的所有边就被遍历完了