图的表示

最近效率好差好差，大学读多了，人不爱思考了，迟钝了，注意力也很难集中了。总是不能很专心很坚持的去完成一件事情。比如课本，比如作业，比如刷题，即使是电影小说也很难静下心来看完。。。

图的表示方法：1.邻接矩阵（太简单不讨论） 2.前向星 3.邻接表（动态建表，vector） 4.链式前向星（静态建邻接表表）

其中链式前向星最好。空间少，可存储重边，可以处理点边数量多的情况，没有动态建表的内存管理所以更安全。除了不能直接用起点终点来确定是否有边外，链式前向星几乎完美。

/********前向星**********/
//n 点最大值
//m 边最大值 
int head[n];

struct Node
{
    int from;
    int to;
    int w;
};

Node edge[m];

//对所有边按照起点排序，若起点相同按照终点排序，若终点相同按照权值排序 
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;
}

//输入存储 
cin >> n >> m;

for (int i = 0; i < m; ++i)
    cin >> edge[i].from >> edge[i].to >> edge[i].w;

sort(edge, edge+m, cmp);

//确定起点为vi的第一条边出现的位置 
head[edge[0].from] = 0;

for (int i = 0; i < m; ++i)
    if (edge[i].from != edge[i-1].from)
        head[edge[i].from] = i;

//遍历
for (int i = 1; i <= n; ++i)    //因为点是v1、v2、v3……所以从1开始 
    for (int k = head[i]; k < m && i == edge[k].from; k++)
        print();

/********邻接表之动态建表**********/
struct Node//边节点 
{
    int to;
    int w;
    Node *next;
};

struct startNode//起点！ 
{
    int from;
    Node *first;
};

startNode graph[n];

//输入存储
cin >> i >> j >> w;
Node *p = new Node();
p->to = j;
p->w = w;
p->next = graph[i].first;
graph[i].first = p;

//遍历
for (int i = 1; i <= n; ++i) 
    for (Node *k = graph[i].first; k != NULL; k = k->next)
        print();

/*********邻接表之静态建表（链式向前星）************/

//该点的第一条边 
int head[n];

struct Edge
{
    int to;//该边的终点
    int w;//该边的权值 
    int next;//该点对应的下一条边 
};
//边的集合 
Edge edges[m];

memset(head, -1, sizeof(head));
//输入存储
//k 为当前输入的第k条边 
cin >> i >> j >> w;
edges[k].to = j;
edges[k].w = w;
edges[k].next = head[i];
head[i] = k; 
 
//遍历
for (int i = 1; i <= n; ++i)
    for (int k = head[i]; k != -1; k = edges[k].next) 
        print();