邻接矩阵 和 领接表 和 链式前向星对比

邻接矩阵、邻接表和链式前向星的空间复杂度差异源于其底层数据结构的根本性不同。邻接矩阵采用二维数组，其空间消耗与顶点数的平方成正比，而与实际的边数无关；邻接表与链式前向星则采用基于边的存储策略，其空间消耗与顶点数和边数之和呈线性关系。以下将分别以不使用类的C++代码形式，直观展示三者的实现，并深入剖析其空间占用特性。

1. 邻接矩阵（Adjacency Matrix）

空间复杂度：O(V²)

其核心是一个 V × V 的二维数组（V 为顶点数），无论图中实际有多少条边，都需要分配 V * V 个存储单元。对于无向图，矩阵呈对称性，理论上可压缩存储，但标准实现仍为完整矩阵。

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

const int MAX_V = 100; // 预设最大顶点数
int adjMatrix[MAX_V][MAX_V]; // 全局二维数组作为邻接矩阵
int V; // 实际顶点数

// 初始化图
void initGraphMatrix(int vertices) {
    V = vertices;
    for (int i = 0; i < V; ++i) {
        for (int j = 0; j < V; ++j) {
            adjMatrix[i][j] = 0; // 0 表示无边（对于无权图）
        }
    }
}

// 添加无向边
void addEdgeMatrix(int u, int v) {
    adjMatrix[u][v] = 1;
    adjMatrix[v][u] = 1; // 无向图需对称设置 
}

// 打印邻接矩阵
void printMatrix() {
    for (int i = 0; i < V; ++i) {
        for (int j = 0; j < V; ++j) {
            cout << adjMatrix[i][j] << " ";
        }
        cout << endl;
    }
}

空间分析 ：数组 adjMatrix 的大小固定为 MAX_V * MAX_V。即使实际边数 E 远小于 V²（稀疏图），该矩阵的绝大部分空间（值为0）也被浪费。例如，对于 V=1000 的图，矩阵需 10⁶ 个 int 单元（约4MB），即使边数仅有 2000。

2. 邻接表（Adjacency List）

空间复杂度：O(V + E)

为每个顶点维护一个动态数组（如 vector），仅存储与该顶点直接相连的邻接顶点。总存储空间正比于顶点数 V（每个 vector 的头部开销）加上边数 E（每条边作为一个元素被存储）。对于无向图，每条边会在两个顶点的列表中各存储一次，因此空间约为 O(V + 2E)。

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

const int MAX_V = 100;
vector<int> adjList[MAX_V]; // 全局数组，每个元素是一个vector 
int V;

void initGraphList(int vertices) {
    V = vertices;
    // vector 已默认初始化，无需额外操作
}

// 添加无向边
void addEdgeList(int u, int v) {
    adjList[u].push_back(v); // 将v加入u的邻接表
    adjList[v].push_back(u); // 将u加入v的邻接表 
}

// 打印邻接表
void printList() {
    for (int i = 0; i < V; ++i) {
        cout << i << ": ";
        for (int neighbor : adjList[i]) {
            cout << neighbor << " ";
        }
        cout << endl;
    }
}

空间分析 ：存储开销由两部分构成：一是 vector<int> adjList[MAX_V] 本身，即 V 个 vector 对象的固定开销；二是所有 push_back 进去的边信息。在稀疏图（E << V²）中，此结构空间效率远高于邻接矩阵。承上例，V=1000, E=2000，邻接表存储约 1000 + 2*2000 = 5000 个 int，空间占用仅为邻接矩阵的0.5%。

3. 链式前向星（Forward Star）

空间复杂度：O(V + E)

通过多个一维数组模拟静态链表来存储图。其空间消耗同样与 V + E 成正比，但它是静态数组分配，无需 vector 的动态扩容开销，内存布局更紧凑，缓存命中率更高。

#include <iostream>
#include <cstring>
using namespace std;

const int MAX_V = 100;
const int MAX_E = 500; // 必须预先估计最大边数

// 核心数组
int head[MAX_V]; // head[u]：顶点u的第一条边在edges数组中的索引
int to[MAX_E];   // to[i]：第i条边的终点
int nextEdge[MAX_E]; // nextEdge[i]：与第i条边同起点的下一条边的索引
int edgeCount = 0; // 当前已添加的边数

void initGraphStar() {
    memset(head, -1, sizeof(head)); // 初始化所有链表头为-1，表示空链表
    edgeCount = 0;
}

// 添加一条有向边 u -> v
void addEdgeStar(int u, int v) {
    to[edgeCount] = v;                // 记录边的终点
    nextEdge[edgeCount] = head[u];    // 新边插入链表头部：其next指向原头边
    head[u] = edgeCount;              // 更新顶点u的头边为当前边
    edgeCount++;
}

// 添加无向边（调用两次addEdgeStar）
void addUndirectedEdgeStar(int u, int v) {
    addEdgeStar(u, v);
    addEdgeStar(v, u);
}

// 遍历顶点u的所有邻接点
void traverseStar(int u) {
    cout << u << ": ";
    for (int i = head[u]; i != -1; i = nextEdge[i]) {
        cout << to[i] << " ";
    }
    cout << endl;
}

空间分析 ：需要三个长度为 MAX_E 的数组 (to, nextEdge) 和一个长度为 MAX_V 的数组 (head)。总空间为 O(MAX_V + 3 * MAX_E)，常数因子虽大于邻接表，但因使用基础数组且内存连续，实际内存占用和访问效率在竞赛场景中往往更优。其缺点是需要预先设定 MAX_E，灵活性不及 vector。

总结对比与选择建议

下表从空间复杂度、内存特性及适用场景进行综合对比：

特性	邻接矩阵	邻接表	链式前向星
空间复杂度	O(V²)，固定且庞大。	O(V + E)，只存有效边。	O(V + E)，数组实现，无动态开销。
内存占用	与边数无关，稀疏图浪费严重。	与边数线性相关，有动态容器开销。	与边数线性相关，内存连续紧凑。
适用图类型	稠密图 (E ≈ V²)。	通用，尤其适合稀疏图。	稀疏图，且边数可预估。
边查询效率	O(1)，直接矩阵访问。	O(deg(u))，需遍历链表。	O(deg(u))，需遍历链表。
动态增删	简单（修改矩阵值）。	容易（vector操作）。	困难（通常不支持删边）。
实现复杂度	最简单。	中等，直观易用。	较高，需理解数组模拟链表。

选择指南：

• 邻接矩阵：仅当处理近乎完全的稠密图，或需要极高频的任意两点间邻接关系查询时使用。
• 邻接表 ：是最通用、最推荐 的默认选择，尤其在使用C++ STL的 vector 实现时，它在开发效率、可读性和动态性之间取得了最佳平衡。
• 链式前向星 ：适用于对性能有极致要求 、内存需要精细控制、且图结构静态（建图后不再修改）的场景，如算法竞赛。

---

参考来源

• 邻接矩阵，邻接表，链式前向星