图的存储

图的存储

邻接矩阵

略

邻接表

略

链式前向星

数据结构:

const int MAX_EDGE_SCALE = 1000;    // 边的规模
const int MAX_VERTEX_SCALE = 1000;  // 顶点的规模

struct Edge{
    int v;  // 边(u, v)
    int w;  // 权重
    int next;  // 下一条边的编号
}; 

vector<Edge> edge(MAX_EDGE_SCALE); // 存储边
int cnt = 0;    // 边的个数
vector<int> head(MAX_VERTEX_SCALE, -1); 

• 结构体Edge: edge[i]表示第 $i$ 条边。
• head[u]表示以节点 $u$ 为起点的第一条边的编号(edge数组的下标)。

添加边：

void addEdge(int u, int v, int w){
    edge[++cnt].next = head[u]; 
    edge[cnt].v = v;
    edge[cnt].w = w;
    head[u] = cnt;
}

• 当加入一条新的边 $(u,v,w)$ 时，首先，应该给这条边分配一个编号(++cnt)，然后，让这条边的下一条边是现在以 $u$ 为起点的第一条边（edge[++cnt].next = head[u];）.然后更新这条边的权重(edge[cnt].w = w;)和终点(edge[cnt].v = v;)。最后，让这条新边成为以 $u$ 为起点的的第一条边。

遍历边：

// 遍历以 u 为起点的所有边。
for (int i = head[u]; ~i; i = edge[i].next){
    cout << u << " " << i.v << " " << i.w << endl;
}

• ~-1 = 0

链式前向星2

上述使用了MAX_EDGE_SCALE和MAX_VERTEX_SCALE两个常量，因此edge数组和head的大小是固定的，如果输入的边数edge_size和顶点数vertex_size并不大，会有很多空间被浪费掉。

因此，可以做如下修改：

#include<iostream>
#include<vector>

using namespace std;

vector<int> vertex_to, weight, nxt;
vector<int> head;

void addEdge(int u, int v, int w){
    nxt.push_back(head[u]);
    vertex_to.push_back(v);
    weight.push_back(w);
    head[u] = nxt.size()-1;
}

int main(){
    /*  input
        5 8
        0 1 2
        0 3 4
        1 2 3
        1 3 4
        2 3 4
        2 4 5
        4 0 1
        4 3 4
    */
    int edge_size, vertex_size;
    cin >> vertex_size >> edge_size;

    head.resize(vertex_size + 1, -1);

    for (int i = 0; i < edge_size; i ++){
        int u, v, w;
        cin >> u >> v >> w;
        addEdge(u, v, w);
    }

    for (int i = 0; i < vertex_size; i ++){
        for (int j = head[i]; ~j; j = nxt[j]){
            cout << i << " " << vertex_to[j] << " " << weight[j] << endl;
        }
    }
    return 0;
}

• 空间复杂度变成了：$O(max(edge\_size,vertex\_size))$

STL vector

这类似与邻接表，但是没有使用链表实现。

#include<iostream>
#include<vector>
#include<set>
using namespace std;

const int MAX_EDGE_SCALE = 1000;    // 边的规模
const int MAX_VERTEX_SCALE = 1000;  // 顶点的规模

vector<pair<int, int>> T[MAX_VERTEX_SCALE];

int main(){
    int edge_size, vertex_size;
    cin >> vertex_size >> edge_size;

    for (int i = 0; i < edge_size; i ++){
        int u, v, w;
        cin >> u >> v >> w;
        T[u].emplace_back(pair<int, int>(v, w));
    }

    cout << "------" << endl;
    for (int i = 0; i < vertex_size; i ++){
        for (auto elem : T[i]){
            cout << i << " " << elem.first << " " << elem.second << endl;
        }
    }
    return 0;
}

• vector<pair<int, int>> T[MAX_VERTEX_SCALE]这其实就是一个二维数组，可以写成：vector<vector<pair<int, int>>> T;。
• pair<int, int>中的第一个int的含义是边 $(u,v)$ 中的 $v$ ,第二个int的含义是权重。
  • 如果想存储更多信息，请使用结构体或者tuple(不推荐)。