前向星与链式前向星

这里借鉴了一些大佬的文章和代码，给出链接，谢谢

https://blog.csdn.net/ACdreamers/article/details/16902023

https://blog.csdn.net/wuhuajunbao/article/details/22589619

引言

一般来讲，图的常用存储结构有邻接矩阵，和邻接表，但我们知道邻接矩阵是好写但效率低，邻接表虽效率高但不好写，今天来讲一下图的另一只常用的存储结构：前向星和链式前向星，介于上述两种存储结构之间的一种比较中庸的存储结构——前向星。前向星固然好些，但效率依旧并不高。而在优化为链式前向星后，效率也得到了较大的提升。虽然说，世界上对链式前向星的使用并不是很广泛，但在不愿意写复杂的邻接表的情况下，链式前向星也是一个很优秀的数据结构。

首先我们来说一下图的前向星表示方法：

 

1.前向星

前向星是一种通过存储边信息的方式来存储图的一种数据结构，他构造简单，读入每条边的信息，将边存放在数组中，把数组中的边按照起点顺序排列，前向星也就构造完成了。方便查询，我们用另外一个数组用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   

head[2] = 4   

head[3] = 5  

head[4] = 6

  

存储结构：

struct node
{
    int from;///起点
    int to;///终点
    int w;///权值
} edge[maxm];
int head[maxn];

比较函数：

bool cmp(node a,node b)
{
    if(a.from == b.from && a.to == b.to) return a.w < b.w;
    if(a.from == b.from) return a.to < b.to;
    return a.from < b.from;
}

读入数据：

void input()
{
    for(int i = 0; i < m; i ++)
    {
        scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].w);
    }
    memset(head ,-1 ,sizeof(head));
    sort(edge , edge + m , cmp);
    head[edge[0].from] = 0;
    for(int i = 1; i < m; i ++)
    {
        if(edge[i].from != edge[i-1].from)
        {
            head[edge[i].from] = i;   //确定起点为vi的第一条边的位置。
        }
    }
}

遍历数据：

void output()
{
    for(int i = 1; i <= n; i ++)
        cout << "head["<<i<<"]: "<<head[i]<<endl;
    cout << "遍历所有的边"<<endl;
    for(int i = 1; i <= n; i ++) //head[i]的下标i等于vi;
    {
        for(int j = head[i]; edge[i].from == i && j < m; j  ++)
        {
            cout << edge[j].from << " " << edge[j].to << " " << edge[j].w <<endl;
        }
    }
}

 完整代码：

 

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <cstdio>
 4 #include <cstring>
 5 using namespace std;
 6 const int maxn = 1000;
 7 const int maxm = 1000000;
 8 struct node
 9 {
10     int from;///起点
11     int to;///终点
12     int w;///权值
13 } edge[maxm];
14 int head[maxn];
15 int n,m ;
16 bool cmp(node a,node b)
17 {
18     if(a.from == b.from && a.to == b.to) return a.w < b.w;
19     if(a.from == b.from) return a.to < b.to;
20     return a.from < b.from;
21 }
22 void input()
23 {
24     for(int i = 0; i < m; i ++)
25     {
26         scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].w);
27     }
28     memset(head ,-1 ,sizeof(head));
29     sort(edge , edge + m , cmp);
30     head[edge[0].from] = 0;
31     for(int i = 1; i < m; i ++)
32     {
33         if(edge[i].from != edge[i-1].from)
34         {
35             head[edge[i].from] = i;   //确定起点为vi的第一条边的位置。
36         }
37     }
38 }
39 
40 void output()
41 {
42     for(int i = 1; i <= n; i ++)
43         cout << "head["<<i<<"]: "<<head[i]<<endl;
44     cout << "遍历所有的边"<<endl;
45     for(int i = 1; i <= n; i ++) //head[i]的下标i等于vi;
46     {
47         for(int j = head[i]; edge[i].from == i && j < m; j  ++)
48         {
49             cout << edge[j].from << " " << edge[j].to << " " << edge[j].w <<endl;
50         }
51     }
52 }
53 int main()
54 {
55     while(scanf("%d%d",&n , &m)!=EOF)
56     {
57         input();
58         output();
59     }
60     return 0;
61 }

View Code

 

可以看出，前向星构造时间的复杂度主要取决于排序函数，一般来说，时间复杂度为O（m logm）；空间上需要两个数组，故空间复杂度为O（m+n）；前向星的有点在于可以对应点非常多的情况，可以存储重复边，但不能直接判断图中任意两点是有边。

 2.链式前向星

 

 建立存储结构：

struct EDGE{
    int next;   //下一条边的存储下标
    int to;     //这条边的终点
    int w;      //权值
}edge[MAXM];

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

 

int head[MAXN];  //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

遍历数据：

for(int i=head[st]; i!=0; i=edge[i].next) 
    {///i开始为第一条边，每次指向下一条(以0为结束标志)若下标从0开始，next应初始化-1
        cout << "Start: " << st << endl;
        cout << "End: " << edge[i].to << endl;
        cout << "W: " << edge[i].w << endl << endl;
    }

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

完整代码：

 

 1 #include<iostream>
 2 #include<cstring>
 3 using namespace std;
 4 #define MAXM 500010
 5 #define MAXN 10010
 6 struct EDGE
 7 {
 8     int next;   //下一条边的存储下标
 9     int to;     //这条边的终点
10     int w;      //权值
11 } edge[MAXM];
12 int n,m;
13 int head[MAXN];  //head[i]表示以i为起点的第一条边
14 int cnt=0;
15 void Add(int u, int v, int w)
16 {
17     edge[cnt].w = w;///初始化与cnt为0
18     edge[cnt].to = v;
19     edge[cnt].next = head[u];
20     head[u] = cnt++;    //第一条边为当前边
21 }
22 void Print()
23 {
24     int st;
25     cout << "Begin with[Please Input]: \n";
26     cin >> st;
27     for(int i=head[st]; i!=-1; i=edge[i].next)
28     {
29         ///i开始为第一条边，每次指向下一条(以0为结束标志)若下标从0开始，next应初始化-1
30         cout << "Start: " << st << endl;
31         cout << "End: " << edge[i].to << endl;
32         cout << "W: " << edge[i].w << endl << endl;
33     }
34 }
35 
36 int main()
37 {
38     int s, t, w;
39     cin >> n >> m;
40     memset(head,-1,sizeof(head));
41     for(int i=1; i<=m; i++)
42     {
43         cin >> s >> t >> w;
44         Add(s, t, w);
45     }
46     Print();
47     return 0;
48 }
49 /*
50 5 7
51 1 2 1
52 2 3 1
53 3 4 1
54 1 3 1
55 4 1 1
56 1 5 1
57 4 5 1
58 */

 

 

 

 

 

转载于:https://www.cnblogs.com/wkfvawl/p/9407282.html