图的表示

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

 

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

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

 

View Code

/********前向星**********/

//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();

View Code

/********邻接表之动态建表**********/

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();

View Code

View Code

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



//该点的第一条边 

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();