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

关注

原创最新推荐文章于 2026-09-14 14:58:37 发布 334 阅读 AI 写同款· GEO 优化 ›

【自己动手写数据结构】 -- 有向带权图的邻接矩阵存储的简单实现 /* * 带权图的邻接矩阵存储实现 * * 当G = 是一个带权图时，G的邻接矩阵中若顶点Vi到顶点Vj * 之间存在边，则将[i,j]赋值为此边的权值；若不存在边，则将[i,j] * 赋值为无穷大；而[i,i]的值为0 */ #include //定义10000为无穷大 #define MAXSIZE 10000 //定义最大的顶点数为30 #define vertexNum 30 阅读详情

第一章：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 社区贡献	理解中间件链与限流算法实现