图的几种存储方法比较：二维矩阵、邻接表与链式前向星

图是一种非常重要的非线性数据结构，广泛应用于社交网络、路径规划、网络拓扑等领域。在计算机中表示和存储图结构有多种方法，本文将详细分析三种常见的存储方式：二维矩阵（邻接矩阵）、邻接表和链式前向星，比较它们的优缺点及适用场景。

1. 邻接矩阵（二维矩阵）

存储原理

邻接矩阵使用一个大小为V×V的二维数组（矩阵）来表示图，其中V是图中顶点的数量。对于无权图：

• matrix[i][j] = 1 表示顶点i和j之间有边
• matrix[i][j] = 0 表示无边

对于带权图：

• matrix[i][j] = w 表示顶点i和j之间有边且权重为w
• matrix[i][j] = ∞ 或特殊值(如-1)表示无边

代码实现

// 无权图
const int MAX_V = 100;
int matrix[MAX_V][MAX_V];

// 初始化
memset(matrix, 0, sizeof(matrix));

// 添加边
void addEdge(int u, int v) {
    matrix[u][v] = 1;
    // 如果是无向图
    matrix[v][u] = 1;
}

// 带权图
void addEdge(int u, int v, int w) {
    matrix[u][v] = w;
    // 如果是无向图
    matrix[v][u] = w;
}

优点

1. 直观简单：实现和理解都非常直观
2. 快速查询：可以在O(1)时间内判断任意两个顶点之间是否有边
3. 方便计算：某些图算法（如Floyd-Warshall）使用邻接矩阵实现更自然
4. 易于处理带权图：权重可以直接存储在矩阵中

缺点

1. 空间复杂度高：需要O(V²)的空间，对于稀疏图浪费大量空间
2. 添加/删除顶点困难：需要重新调整矩阵大小
3. 遍历邻接点效率低：即使一个顶点只有很少的邻接点，也需要遍历整行

适用场景

• 稠密图（边数接近顶点数的平方）
• 需要频繁查询任意两点间是否有边
• 顶点数量较少的情况

2. 邻接表

存储原理

邻接表为每个顶点维护一个链表（或动态数组），存储该顶点的所有邻接顶点。通常使用数组或哈希表来映射顶点到其邻接链表。

代码实现

#include <vector>
using namespace std;

const int MAX_V = 100;
vector<int> adj[MAX_V]; // 无权图
vector<pair<int, int>> adj_weight[MAX_V]; // 带权图，存储(邻接顶点，权重)

// 添加无权边
void addEdge(int u, int v) {
    adj[u].push_back(v);
    // 如果是无向图
    adj[v].push_back(u);
}

// 添加带权边
void addWeightedEdge(int u, int v, int w) {
    adj_weight[u].push_back({v, w});
    // 如果是无向图
    adj_weight[v].push_back({u, w});
}

优点

1. 空间效率高：只存储实际存在的边，空间复杂度为O(V+E)，特别适合稀疏图
2. 遍历邻接点高效：可以直接访问某个顶点的所有邻接点
3. 易于扩展：添加新顶点和边很方便

缺点

1. 查询边存在性较慢：需要遍历链表来检查特定边是否存在，最坏O(V)
2. 实现稍复杂：比邻接矩阵实现略复杂
3. 缓存不友好：链表节点可能分散在内存各处

适用场景

• 稀疏图
• 需要频繁遍历邻接点的算法（如BFS、DFS）
• 顶点数量大但边相对少的图

3. 链式前向星

存储原理

链式前向星是一种静态链表实现的邻接表，使用三个数组：

• head[MAX_V]：记录每个顶点第一条边的位置
• edge[]：存储所有边
• next[]：存储下一条边的索引

每条边存储目标顶点和权重（可选）等信息。

代码实现

const int MAX_V = 100;
const int MAX_E = 1000;

struct Edge {
    int to;         // 边的终点
    int next;       // 下一条边的索引
    int w;          // 权重（可选）
} edges[MAX_E];

int head[MAX_V];    // 初始化为-1
int edge_count = 0;  // 边计数器

// 初始化
memset(head, -1, sizeof(head));

// 添加边
void addEdge(int u, int v, int w = 0) {
    edges[edge_count].to = v;
    edges[edge_count].w = w;
    edges[edge_count].next = head[u];
    head[u] = edge_count++;
}

// 遍历u的邻接点
for (int i = head[u]; i != -1; i = edges[i].next) {
    int v = edges[i].to;
    int w = edges[i].w;
    // 处理u->v的边，权重为w
}

优点

1. 空间效率高：与邻接表相当，O(V+E)
2. 静态存储：使用数组而非指针，更适合某些编程环境
3. 缓存友好：数据连续存储，访问效率可能更高
4. 适合竞赛编程：在ACM等竞赛中广泛使用

缺点

1. 实现复杂：理解和实现难度较高
2. 静态大小：需要预先估计最大边数或动态调整数组
3. 不易修改：删除边操作较困难

适用场景

• 内存受限环境
• 需要高性能图遍历的场合
• 竞赛编程中处理大规模图
• 需要静态存储结构的场景

三种存储方式的对比

特性	邻接矩阵	邻接表	链式前向星
空间复杂度	O(V²)	O(V+E)	O(V+E)
查询边存在性	O(1)	O(deg(v))	O(deg(v))
遍历邻接点	O(V)	O(deg(v))	O(deg(v))
添加边	O(1)	O(1)	O(1)
删除边	O(1)	O(deg(v))	困难
添加顶点	困难	容易	困难
适合图类型	稠密图	稀疏/稠密图	稀疏/稠密图
实现难度	简单	中等	较难
缓存友好性	好	一般	好

实际应用建议

1. 小规模图或稠密图：优先考虑邻接矩阵，实现简单且查询高效
2. 大规模稀疏图：使用邻接表或链式前向星，节省内存
3. 需要频繁遍历图的算法（如DFS/BFS）：邻接表或链式前向星更优
4. 竞赛编程：链式前向星因其高效和紧凑常被选用
5. 需要频繁修改图结构：邻接表更灵活

总结

图的存储方式选择取决于具体应用场景和性能需求。理解这三种存储方法的特点和适用条件，可以帮助我们在不同情况下做出最合适的选择。在实际开发中，邻接表因其良好的平衡性而被广泛使用；在性能敏感或内存受限的场景，链式前向星可能更优；而对于小规模图或需要频繁查询边存在性的场景，邻接矩阵仍是不错的选择。