C语言实现图存储（从零开始掌握邻接矩阵核心技术）

第一章：C语言实现图存储（从零开始掌握邻接矩阵核心技术）

在数据结构中，图是一种重要的非线性结构，广泛应用于社交网络、路径规划和任务调度等场景。使用C语言实现图的存储，邻接矩阵是一种直观且高效的方式，尤其适用于顶点数量较少但边较密集的图。

邻接矩阵的基本原理

邻接矩阵使用二维数组表示图中顶点之间的连接关系。若图包含 n 个顶点，则创建一个 n×n 的整型数组 adjMatrix，其中 adjMatrix[i][j] 表示从顶点 i 到顶点 j 是否存在边。对于无向图，矩阵是对称的；对于有向图，则不一定对称。

定义图的结构体

在C语言中，可通过结构体封装图的基本信息：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 100

typedef struct {
    int vertices; // 顶点数量
    int adjMatrix[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵
} Graph;

// 初始化图
void initGraph(Graph* g, int n) {
    g->vertices = n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            g->adjMatrix[i][j] = 0; // 0 表示无边
        }
    }
}

上述代码定义了一个图结构，并通过 initGraph 函数将所有边初始化为0。

添加边的操作

通过函数向图中添加边，支持无向图和有向图：

• 调用 addEdge(graph, u, v) 添加一条从 u 到 v 的边
• 对于无向图，需同时设置 adjMatrix[u][v] 和 adjMatrix[v][u]
• 对于有向图，仅设置 adjMatrix[u][v]

邻接矩阵的优缺点对比

优点	缺点
实现简单，易于理解	空间复杂度为 O(n²)，浪费空间
判断两点是否有边效率高（O(1)）	不适合稀疏图

graph TD A[开始] --> B[初始化邻接矩阵] B --> C[输入顶点数和边数] C --> D[添加边] D --> E[输出邻接矩阵] E --> F[结束]

第二章：邻接矩阵的基本原理与结构设计

2.1 图的基本概念与邻接矩阵定义

图是表示对象之间关系的数学结构，由顶点（Vertex）和边（Edge）组成。根据边是否有方向，图可分为有向图和无向图。在计算机科学中，图的存储方式多样，其中邻接矩阵是一种基于二维数组的表示方法。

邻接矩阵的结构特点

邻接矩阵使用 $ n \times n $ 的二维数组 `matrix` 表示图，其中 `matrix[i][j]` 的值表示从顶点 $ i $ 到顶点 $ j $ 是否存在边。对于无权图，通常用 1 表示存在边，0 表示无边；对于带权图，则存储对应的权重。

# 无向图的邻接矩阵表示（5个顶点）
n = 5
adj_matrix = [[0] * n for _ in range(n)]

# 添加边 (0,1), (1,2), (2,3)
edges = [(0,1), (1,2), (2,3)]
for u, v in edges:
    adj_matrix[u][v] = 1
    adj_matrix[v][u] = 1  # 无向图对称

上述代码构建了一个简单的无向图邻接矩阵。由于是无向图，每条边在矩阵中对称设置。该表示法便于快速判断两顶点间是否存在连接，但空间复杂度为 $ O(n^2) $，适合稠密图。

邻接矩阵的优缺点对比

• 优点：边的查询操作时间复杂度为 $ O(1) $
• 缺点：空间消耗大，稀疏图下效率低
• 适用场景：节点数量较少且边较密集的图结构

2.2 邻接矩阵的数学表示与存储优势

邻接矩阵是图的一种基础表示方法，使用二维数组 $ A $ 来描述图中顶点之间的连接关系。若图中有 $ n $ 个顶点，则邻接矩阵为 $ n \times n $ 的方阵，其中元素 $ A[i][j] $ 表示从顶点 $ i $ 到顶点 $ j $ 是否存在边。

数学定义与结构特征

对于无向图，邻接矩阵是对称的；对于有向图，则不一定对称。权重图中，$ A[i][j] $ 可存储边的权重，而非仅用 0/1 表示连通性。

顶点	A	B	C
A	0	1	0
B	1	0	1
C	0	1	0

代码实现示例

// 初始化邻接矩阵
func NewGraph(n int) [][]int {
    graph := make([][]int, n)
    for i := range graph {
        graph[i] = make([]int, n)
    }
    return graph
}

// 添加边（无向图）
func AddEdge(graph [][]int, u, v int) {
    graph[u][v] = 1
    graph[v][u] = 1
}

上述 Go 代码构建了一个基于二维切片的邻接矩阵，AddEdge 函数在无向图中双向置位，体现对称性。该结构适合稠密图，支持 $ O(1) $ 时间内判断边的存在性。

2.3 C语言中二维数组的合理应用

在C语言中，二维数组常用于表示矩阵、图像像素或表格数据。其本质是“数组的数组”，通过行和列的索引访问元素，结构清晰且内存连续。

二维数组的基本声明与初始化

int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

上述代码定义了一个3×3的整型数组。内存中按行优先顺序存储，即第一行元素连续存放，随后是第二行，依此类推。初始化时可省略第一维大小，编译器自动推导。

典型应用场景：矩阵转置

• 将原矩阵的行变为列，常用于线性代数运算；
• 利用嵌套循环遍历并交换行列索引实现；
• 注意避免越界访问，确保目标数组维度匹配。

2.4 无向图与有向图的矩阵建模差异

在图论中，邻接矩阵是描述图结构的核心工具。无向图和有向图在矩阵建模上的根本差异体现在矩阵的对称性上。

邻接矩阵的对称性特征

无向图的边没有方向，若顶点 $i$ 与 $j$ 相连，则 $A_{ij} = A_{ji} = 1$，因此其邻接矩阵是对称的。而有向图中，边 $i \rightarrow j$ 并不保证 $j \rightarrow i$ 存在，故矩阵无需对称。

代码示例：构建邻接矩阵

import numpy as np

# 有向图邻接矩阵（非对称）
directed_adj = np.array([
    [0, 1, 0],
    [0, 0, 1],
    [1, 0, 0]
])

# 无向图邻接矩阵（对称）
undirected_adj = np.array([
    [0, 1, 1],
    [1, 0, 0],
    [1, 0, 0]
])

上述代码中，directed_adj 表示一个三节点有向环，其非对称性体现了方向约束；undirected_adj 中节点0与1、2互连，矩阵对称反映边的双向性。

结构对比总结

图类型	矩阵对称性	边含义
无向图	是	双向连接
有向图	否	单向关系

2.5 初始化邻接矩阵的核心代码实现

在图的表示方法中，邻接矩阵是一种直观且高效的存储结构，尤其适用于稠密图的场景。通过二维数组记录顶点之间的连接关系，能够快速判断任意两点是否存在边。

核心初始化逻辑

邻接矩阵的初始化需设定顶点数量，并将所有边权置为默认值（如0或无穷大）。以下为使用C++实现的示例：

// 初始化n个顶点的邻接矩阵
int n = 5;
vector<vector<int>> adjMatrix(n, vector<int>(n, 0)); // 默认无边

// 添加边：u到v，权重为w
void addEdge(int u, int v, int w) {
    adjMatrix[u][v] = w;
}

上述代码创建了一个5×5的二维向量，初始值为0，表示无连接。addEdge函数用于设置有向边的权重，便于后续图算法调用。

时间与空间特性

• 空间复杂度为 O(V²)，V为顶点数
• 适合频繁查询边存在的场景
• 稀疏图中存在空间浪费问题

第三章：图的操作接口设计与实现

3.1 添加顶点与边的逻辑处理

在图数据结构中，添加顶点与边是构建拓扑关系的基础操作。首先需确保顶点唯一性，避免重复插入。

顶点添加逻辑

使用哈希表存储顶点，以实现 O(1) 时间复杂度的查找与去重：

func (g *Graph) AddVertex(id string) {
    if g.vertices == nil {
        g.vertices = make(map[string]*Vertex)
    }
    if _, exists := g.vertices[id]; !exists {
        g.vertices[id] = &Vertex{ID: id, Edges: make([]*Edge, 0)}
    }
}

上述代码中，g.vertices 是图的顶点映射表，仅当顶点 ID 不存在时才创建新顶点。

边的建立流程

添加边需验证源顶点与目标顶点的存在性，并维护双向引用：

• 检查源顶点和目标顶点是否均已添加
• 将边加入源顶点的边列表
• 若为无向图，同步添加反向边

3.2 删除边与权重更新的编程实现

在图结构操作中，删除边和动态更新权重是核心功能。为保证数据一致性，需同步维护邻接表与权重映射。

边删除的实现逻辑

使用邻接表存储图结构时，删除边需从源节点的邻接集中移除目标节点。

func (g *Graph) RemoveEdge(u, v int) {
    if neighbors, exists := g.AdjList[u]; exists {
        newNeighbors := []int{}
        for _, node := range neighbors {
            if node != v {
                newNeighbors = append(newNeighbors, node)
            }
        }
        g.AdjList[u] = newNeighbors
    }
}

该函数遍历源节点 u 的邻居列表，仅保留非目标节点 v 的条目，实现边的逻辑删除。

权重更新机制

若图带有权重，需额外维护 map 记录边权值：

• 删除边时，同时从权重 map 中删除 (u,v) 键
• 更新权重时，直接修改 map 中对应键的值

3.3 图的遍历接口与矩阵访问规范

在图结构的数据处理中，统一的遍历接口和矩阵访问规范是实现高效算法的基础。为确保不同存储格式（如邻接表与邻接矩阵）间的兼容性，需定义标准化的访问协议。

核心接口设计

遍历操作应支持深度优先（DFS）和广度优先（BFS）两种模式，并通过统一接口调用：

type Graph interface {
    // 获取顶点数量
    Vertices() int
    // 判断两顶点是否存在边
    HasEdge(u, v int) bool
    // 遍历邻居节点
    Neighbors(v int) []int
}

该接口屏蔽底层实现差异，使上层算法无需关心数据存储形式。

矩阵访问规则

对于基于二维数组的邻接矩阵，必须遵循行主序访问原则以提升缓存命中率。同时规定对角线元素表示自环，无向图矩阵必须对称。

操作	时间复杂度	说明
HasEdge(u,v)	O(1)	直接索引访问
Neighbors(v)	O(V)	扫描整行

第四章：典型应用场景与算法集成

4.1 基于邻接矩阵的深度优先搜索（DFS）

在图的遍历算法中，深度优先搜索（DFS）通过回溯机制系统地探索每个顶点。当使用邻接矩阵表示图时，矩阵的行列分别对应顶点，元素值表示边的存在与否。

算法核心逻辑

DFS从起始顶点出发，标记已访问，递归访问所有未访问的邻接顶点。邻接矩阵便于快速判断两顶点间是否有边。

void DFS(int graph[][V], int v, bool visited[]) {
    visited[v] = true;
    cout << v << " ";

    for (int i = 0; i < V; ++i) {
        if (graph[v][i] == 1 && !visited[i]) {
            DFS(graph, i, visited);
        }
    }
}

上述代码中，graph为邻接矩阵，visited记录访问状态，V为顶点数。循环检查第v行的所有列，寻找邻接且未访问的顶点。

时间与空间复杂度

• 时间复杂度：O(V²)，需遍历整个矩阵
• 空间复杂度：O(V)，用于存储访问标记和递归栈

4.2 基于邻接矩阵的广度优先搜索（BFS）

算法基本思想

广度优先搜索通过逐层遍历图的节点实现连通性探索。使用邻接矩阵存储图结构，便于快速判断两节点间是否存在边。

核心实现代码

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

void BFS(int start, const vector<vector<int>>& adjMatrix) {
    int n = adjMatrix.size();
    vector<bool> visited(n, false);
    queue<int> q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int u = q.front(); q.pop();
        cout << u << " ";
        for (int v = 0; v < n; ++v) {
            if (adjMatrix[u][v] == 1 && !visited[v]) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
}

上述代码中，adjMatrix[u][v] 表示节点 u 到 v 是否存在边；visited 数组避免重复访问；队列确保按层次顺序扩展。

时间复杂度分析

• 邻接矩阵大小为 O(n²)
• 每个节点和每条边最多被检查一次
• 总体时间复杂度为 O(n²)

4.3 Dijkstra最短路径算法的矩阵实现

Dijkstra算法用于求解单源最短路径问题，适用于带权有向图或无向图。当使用邻接矩阵存储图结构时，可直接基于二维数组进行距离更新与顶点选择。

算法核心步骤

• 初始化源点到各顶点的距离，不可达设为无穷大（如9999）
• 维护一个已确定最短路径的顶点集合
• 每次从未处理顶点中选取距离最小者进行扩展

邻接矩阵表示示例

	A	B	C	D
A	0	5	2	999
B	999	0	1	3
C	999	999	0	1
D	999	999	999	0

int dist[V]; // 存储最短距离
bool visited[V]; // 标记是否已处理
for (int i = 0; i < V; i++) {
    dist[i] = graph[src][i];
}
dist[src] = 0;

for (int i = 0; i < V - 1; i++) {
    int u = minDistance(dist, visited);
    visited[u] = true;
    for (int v = 0; v < V; v++) {
        if (!visited[v] && graph[u][v] && 
            dist[u] + graph[u][v] < dist[v]) {
            dist[v] = dist[u] + graph[u][v];
        }
    }
}

上述代码中，`minDistance`函数返回未访问顶点中距离最小的索引，外层循环执行V-1次以确保所有顶点被处理。`graph[u][v]`表示边权值，松弛操作更新当前最短路径估计。

4.4 Floyd-Warshall算法在稠密图中的应用

算法核心思想

Floyd-Warshall算法通过动态规划求解所有顶点对之间的最短路径，特别适用于边数接近顶点数平方的稠密图。其时间复杂度为 $O(V^3)$，在稠密图中表现优于多次运行Dijkstra算法。

算法实现

def floyd_warshall(graph):
    n = len(graph)
    dist = [row[:] for row in graph]  # 拷贝邻接矩阵
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if dist[i][k] + dist[k][j] < dist[i][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]
    return dist

该代码实现三重循环松弛操作：外层循环遍历中间节点k，内层更新每对节点(i, j)的最短距离。初始graph为邻接矩阵，不可达边设为无穷大。

适用场景对比

• 稠密图：边数接近 $V^2$，Floyd-Warshall更高效
• 需要所有节点对最短路径时优势明显
• 支持负权边（不含负权环）

第五章：总结与进阶学习建议

构建持续学习的技术路径

技术演进迅速，保持竞争力的关键在于建立系统化的学习机制。建议定期阅读官方文档、参与开源项目，并在本地复现核心功能。例如，深入理解 Go 语言的并发模型时，可通过实现一个轻量级任务调度器来巩固知识：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        time.Sleep(time.Second)
    }
}

func main() {
    jobs := make(chan int, 100)
    var wg sync.WaitGroup

    // 启动3个工作协程
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, &wg)
    }

    // 发送5个任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()
}

选择高价值的进阶方向

根据当前市场需求，以下领域值得重点关注：

• 云原生架构：掌握 Kubernetes 控制器开发与服务网格配置
• 可观测性工程：实践 OpenTelemetry 在微服务中的集成方案
• 安全编码：学习如何防范常见漏洞，如 SQL 注入与 XSS 攻击
• 性能调优：使用 pprof 分析 Go 程序内存与 CPU 使用情况

参与真实项目提升实战能力

项目类型	推荐平台	技能收益
分布式缓存设计	GitHub 开源项目	掌握一致性哈希与故障转移机制
API 网关开发	GitLab 社区贡献	理解中间件链与限流算法实现