链式前向星 存储图的信息

书上介绍了两种存储图的方式

---------->>

1、邻接矩阵 　　　　

2、邻接表

邻接矩阵的优势在于 可以快速读取两个节点的连通情况 和权值O(1) 

但是内存消耗太大 特别是图比较稀疏的时候浪费非常多

那么久有了邻接表的方式

struct Edge

{ int to , cost} 

vector<Edge> G[MAXV]

这样节省了内存 O(E） 但是因为vector是封装了很多功能的容器 在普通题目当中时间消耗不容忽视

因此有了向前星 的写法 代替vector的方式

#include <iostream>
#include <cstring>
#include <cstdio>
#include <set>
#include <fstream>
using namespace std;
const int maxn=1100000;
const int maxm=110000;

using namespace std;

struct Edge//边的的数组
{
    int next, n, to;//分别代表下一个 相同起点的位置 这条边的权值 这条边的终点
}edge[maxm];//所有的边都将储存在这个数组当中

int head[maxn];// head[i] 表示从i点出发的 边的第一个节点 在edge数组中的位置

int num = 0; //当前已有边的个数

int Add(int from, int to, int n)//分别代表的信息 :从哪个点出发 终点 权值
{
    edge[num].n = n;
    edge[num].to = to;
    edge[num].next = head[from];//从头插入
    head[from] = num++;//更新头节点
}

void use(int v)//遍历以v为起点的链表---->> 输出所有以v为起点的边
{
    int t = head[v];
    while (t != -1)//head 和 edge初始化为-1
    {
        cout << v << " ----> " << edge[t].to << " : " << edge[t].n << endl;
        t = edge[t].next;
    }
}


int main()
{
    ifstream cin ("in.txt");
    int from[128], to[128], n[128];
    int i = 0;
    memset(edge, -1, sizeof(edge));
    memset(head, -1, sizeof(head));
    while (cin >> from[i] >> to[i] >> n[i])
    {
        Add(from[i], to[i], n[i]);
        i++;
    }
    //下面测试就是在乱搞了
    set<int> s;
    set<int> :: iterator it;
    for (int j = 0; j < i; j++)
    {
        s.insert(from[j]);//去重
    }
    for(it = s.begin(); it != s.end(); it++)
    {
        use((*it));
    }
}

测试输入
1 3 2
1 2 5
2 3 4
2 4 2
4 3 6
4 6 1
3 5 10
5 6 3
5 7 5
6 9 7

输出
1 ----> 2 : 5
1 ----> 3 : 2
2 ----> 4 : 2
2 ----> 3 : 4
3 ----> 5 : 10
4 ----> 6 : 1
4 ----> 3 : 6
5 ----> 7 : 5
5 ----> 6 : 3
6 ----> 9 : 7