从零实现图的邻接表表示，手把手教你掌握C语言图遍历核心算法-优快云博客

第一章：从零认识图的邻接表表示

在图论与数据结构中，邻接表是一种高效且直观的图表示方法，特别适用于稀疏图的存储。它通过为每个顶点维护一个链表，记录与其相邻的所有顶点，从而节省空间并提高遍历效率。

邻接表的基本结构

邻接表通常由一个数组或切片组成，数组的每个元素对应图中的一个顶点，其值是一个链表或动态数组，保存从该顶点出发可达的所有邻居节点。对于无向图，每条边会在两个顶点的链表中各出现一次；对于有向图，则仅在起点的链表中添加终点。例如，一个包含4个顶点的有向图，若存在边 0→1、0→2、1→3，则其邻接表可表示为：

顶点 0: [1, 2]
顶点 1: [3]
顶点 2: []
顶点 3: []

Go语言实现示例


// 使用切片模拟邻接表
type Graph struct {
    vertices int
    adjList  [][]int
}

// 添加一条有向边
func (g *Graph) AddEdge(src, dest int) {
    g.adjList[src] = append(g.adjList[src], dest) // 将dest加入src的邻接列表
}

// 初始化图
func NewGraph(n int) *Graph {
    return &Graph{
        vertices: n,
        adjList:  make([][]int, n), // 创建n个空切片
    }
}

邻接表与邻接矩阵对比

特性	邻接表	邻接矩阵
空间复杂度	O(V + E)	O(V²)
适合图类型	稀疏图	稠密图
查询边是否存在	O(degree)	O(1)

graph TD A[顶点0] --> B[顶点1] A --> C[顶点2] B --> D[顶点3]

第二章：邻接表的数据结构设计与实现

2.1 图的基本概念与邻接表原理剖析

图是一种由顶点集合和边集合构成的非线性数据结构，用于表示对象之间的多对多关系。每个顶点称为节点，边则代表节点间的连接关系。根据边是否有方向，图可分为有向图和无向图。

邻接表存储结构

邻接表通过为每个顶点维护一个链表来存储其相邻顶点，适合稀疏图存储，节省空间。

每个顶点对应一个链表，记录与其相连的所有顶点
空间复杂度为 O(V + E)，其中 V 为顶点数，E 为边数
插入边操作高效，便于遍历某个顶点的所有邻接点

type Graph struct {
    vertices int
    adjList  map[int][]int
}

func (g *Graph) AddEdge(u, v int) {
    g.adjList[u] = append(g.adjList[u], v)
}

上述 Go 代码定义了一个基于哈希表实现的邻接表图结构。`adjList` 将每个顶点映射到其邻接顶点切片，`AddEdge` 方法在指定顶点间添加有向边。该设计灵活高效，适用于动态图结构的构建与操作。

2.2 定义顶点与边的C语言数据结构

在图的实现中，合理设计顶点与边的数据结构是构建高效算法的基础。C语言通过结构体（struct）提供了对复合数据类型的强大支持，适合用于表示图的基本元素。

顶点的基本结构

通常，顶点可包含标识符、数据负载及邻接信息。一个简洁的顶点定义如下：

typedef struct Vertex {
    int id;                 // 顶点唯一标识
    int data;               // 存储数据（可选）
    struct Edge* adjList;   // 指向第一条邻接边
} Vertex;

该结构中，adjList 实现邻接表的关键链表头指针，便于遍历所有从该顶点出发的边。

边的连接方式

边结构需记录目标顶点和权重，并形成链表以挂载到源顶点：

typedef struct Edge {
    int weight;             // 边的权重
    Vertex* to;             // 指向目标顶点
    struct Edge* next;      // 下一条邻接边
} Edge;

next 字段实现同一起点的多条边串联，构成邻接表的核心链式结构。这种设计兼顾内存效率与访问速度，适用于稀疏图的广泛场景。

2.3 动态内存分配与链表节点管理

在C语言中，动态内存分配是实现灵活数据结构的基础。通过 malloc、calloc 和 free 等函数，程序可在运行时按需申请和释放堆内存，尤其适用于链表这类动态增长的数据结构。

链表节点的动态创建

每个链表节点通常包含数据域和指向下一个节点的指针域。使用 malloc 分配内存可确保节点在程序生命周期内有效。


typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* create_node(int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    if (!new_node) {
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

上述代码中，malloc 为新节点分配足够内存；若分配失败则终止程序。返回的指针指向已初始化的节点，可安全接入链表。

内存管理注意事项

每次 malloc 都应检查返回指针是否为 NULL
链表销毁时必须遍历并调用 free 释放每个节点，防止内存泄漏
避免悬空指针：释放后应将指针置为 NULL

2.4 构建无向图的邻接表存储模型

在图的存储结构中，邻接表是一种高效且节省空间的方式，尤其适用于稀疏图。它通过为每个顶点维护一个链表，记录与其相邻的所有顶点。

数据结构设计

使用哈希表作为主存储结构，键为顶点，值为相邻顶点的列表。对于无向图，每条边 (u, v) 需在 u 和 v 的列表中分别添加对方。


type Graph struct {
    adjList map[string][]string
}

func NewGraph() *Graph {
    return &Graph{adjList: make(map[string][]string)}
}

func (g *Graph) AddEdge(u, v string) {
    g.adjList[u] = append(g.adjList[u], v)
    g.adjList[v] = append(g.adjList[v], u) // 无向图双向添加
}

上述代码定义了一个基于字符串顶点的无向图结构。AddEdge 方法确保边的两个顶点互为邻居，体现了无向图的对称性。初始化使用 map 动态扩展，适合未知规模的图数据。

2.5 构建有向图的邻接表及边界条件处理

在表示有向图时，邻接表是一种高效且灵活的数据结构。它使用哈希表或数组存储每个顶点的出边集合，适用于稀疏图并节省空间。

邻接表的基本结构

通常使用一个 map 或切片的切片来实现，键为顶点，值为相邻顶点列表。


type Graph struct {
    vertices map[int][]int
}

func NewGraph() *Graph {
    return &Graph{vertices: make(map[int][]int)}
}

该结构中，vertices 存储从源节点到目标节点的单向连接关系，初始化避免 nil 引用。

边界条件处理

插入边时需检查源与目标顶点是否已存在；
避免重复添加相同边以防止冗余；
删除顶点时同步清理所有相关入边和出边。

正确处理这些边界情况可确保图操作的健壮性与一致性。

第三章：图的遍历算法理论基础

3.1 深度优先搜索（DFS）的核心思想与递归实现

深度优先搜索（DFS）是一种用于遍历或搜索图和树的算法，其核心思想是沿着路径一直深入，直到无法继续为止，然后回溯并尝试其他分支。

递归实现原理

DFS天然适合用递归实现。每次访问一个节点后，递归地访问其未被访问的邻接节点。


def dfs(graph, start, visited):
    visited.add(start)
    print(start)  # 访问当前节点
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

上述代码中，graph 表示邻接表，start 为当前节点，visited 集合记录已访问节点，防止重复访问。递归调用确保优先深入探索每条路径。

算法特点

使用系统栈保存状态，简洁易实现
适用于连通性判断、路径查找等问题
时间复杂度为 O(V + E)，V 为顶点数，E 为边数

3.2 广度优先搜索（BFS）的队列机制与层次遍历

队列在BFS中的核心作用

广度优先搜索利用队列的“先进先出”特性，确保从根节点开始逐层访问所有相邻节点。每次将当前节点出队，并将其未访问的邻接节点入队，从而实现层次扩展。

二叉树的层次遍历实现

func levelOrder(root *TreeNode) [][]int {
    if root == nil {
        return nil
    }
    var result [][]int
    queue := []*TreeNode{root}
    
    for len(queue) > 0 {
        levelSize := len(queue)
        var currentLevel []int
        
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            currentLevel = append(currentLevel, node.Val)
            
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        result = append(result, currentLevel)
    }
    return result
}

该代码通过维护一个队列实现逐层遍历。外层循环控制整体遍历，内层循环依据当前队列长度处理每一层节点，保证层次结构清晰分离。

时间与空间复杂度分析

时间复杂度：O(n)，每个节点恰好入队一次
空间复杂度：O(w)，w为树的最大宽度，即队列中最多存储一层节点

3.3 DFS与BFS的性能对比与适用场景分析

时间与空间复杂度对比

在相同规模的图中，DFS和BFS的时间复杂度均为 O(V + E)，其中 V 为顶点数，E 为边数。但空间复杂度表现不同：BFS需存储每层节点，最坏情况下空间为 O(V)；而DFS依赖递归栈，平均空间更小，但在深度较大时可能引发栈溢出。

算法	时间复杂度	空间复杂度	最优场景
DFS	O(V + E)	O(V)	路径存在性、拓扑排序
BFS	O(V + E)	O(V)	最短路径（无权图）

代码实现与逻辑分析


# BFS 实现最短路径搜索
from collections import deque
def bfs_shortest_path(graph, start, target):
    queue = deque([(start, [start])])
    visited = set([start])
    
    while queue:
        node, path = queue.popleft()
        if node == target:
            return path  # 首次到达即为最短路径
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, path + [neighbor]))

该代码使用队列确保按层遍历，path 记录路径，一旦到达目标节点即返回结果，保证了路径最短性。

第四章：C语言实现图遍历核心算法

4.1 实现DFS遍历并输出访问路径

深度优先搜索（DFS）是一种用于遍历图或树结构的重要算法，其核心思想是沿着一条路径尽可能深入地访问节点，直到无法继续为止，再回溯尝试其他路径。

递归实现DFS

使用递归方式实现DFS最为直观，以下为Python示例代码：


def dfs(graph, start, visited=None, path=None):
    if visited is None:
        visited = set()
    if path is None:
        path = []
    visited.add(start)
    path.append(start)
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited, path)
    return path

该函数接收邻接表表示的图、起始节点、已访问集合和路径列表。每次访问节点时将其加入路径，并递归访问其未被访问的邻接点。

访问路径输出示例

假设图结构如下：

A: [B, C]
B: [D]
C: [E]
D: []
E: []

从A出发的DFS访问路径为：A → B → D → C → E。

4.2 基于队列的BFS非递归实现

核心思想与数据结构选择

广度优先搜索（BFS）通过逐层遍历的方式访问图中节点。使用队列（Queue）作为核心数据结构，确保先进入的节点先被处理，从而实现层级扩展。

算法步骤与代码实现


from collections import deque

def bfs(graph, start):
    visited = set()                    # 记录已访问节点
    queue = deque([start])             # 初始化队列并加入起始节点
    visited.add(start)
    
    while queue:
        node = queue.popleft()         # 取出队首节点
        print(node)                    # 处理当前节点
        for neighbor in graph[node]:   # 遍历相邻节点
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor) # 未访问则入队

上述代码中，deque 提供高效的两端操作，visited 集合避免重复访问，保证算法正确性与效率。

时间与空间复杂度分析

时间复杂度：O(V + E)，每个节点和边各被访问一次
空间复杂度：O(V)，主要消耗在 visited 集合与队列存储

4.3 遍历过程中状态标记与防重复访问策略

在图或树结构的深度优先搜索（DFS）和广度优先搜索（BFS）中，防止节点被重复访问是确保算法正确性和效率的关键。为此，常引入状态标记机制，将节点标记为“未访问”、“访问中”和“已访问”三种状态。

状态标记的实现方式

使用一个哈希表或布尔数组记录每个节点的访问状态。例如，在图的遍历中：


visited := make(map[int]bool)
for node := range graph {
    if !visited[node] {
        dfs(graph, node, visited)
    }
}

上述代码中，visited 映射用于记录已访问的节点，避免重复进入相同分支，防止无限递归。

防重复访问的策略对比

布尔标记法：适用于无环结构，简单高效；
三色标记法：白（未访问）、灰（访问中）、黑（已完成），可检测环路；
时间戳标记：为每次遍历分配唯一ID，支持多轮并发遍历。

4.4 测试用例设计与遍历结果验证

在自动化测试中，合理的测试用例设计是确保系统稳定性的关键。应基于边界值、等价类划分和路径覆盖原则构建用例集，以提升代码覆盖率。

测试用例设计策略

正向用例：验证正常输入下的预期行为
反向用例：测试异常或非法输入的容错能力
边界用例：针对参数上下限进行验证

遍历结果验证示例


// 验证树结构遍历结果
func TestTreeTraversal(t *testing.T) {
    expected := []int{1, 2, 3, 4, 5}
    result := InOrderTraversal(root)
    if !reflect.DeepEqual(expected, result) {
        t.Errorf("期望 %v，但得到 %v", expected, result)
    }
}

该代码通过反射对比实际输出与预期序列是否一致，适用于深度优先遍历的正确性校验。使用 reflect.DeepEqual 可安全比较切片内容，确保遍历顺序符合中序逻辑。

验证结果对比表

测试场景	预期输出	实际输出	状态
中序遍历	[1,2,3,4,5]	[1,2,3,4,5]	✅
空树遍历	[]	[]	✅

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

构建持续学习的技术路径

技术演进迅速，掌握核心原理的同时，需建立可持续的学习机制。建议定期阅读官方文档、参与开源项目，并通过撰写技术笔记巩固理解。例如，Go语言开发者可订阅 Golang Blog 并跟踪 proposal 变更：


// 示例：使用 context 控制 goroutine 生命周期
func fetchData(ctx context.Context) error {
    req, _ := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/data", nil)
    _, err := http.DefaultClient.Do(req)
    return err
}

实战驱动的技能提升策略

通过真实项目打磨能力是关键。以下为推荐学习资源分类：

学习方向	推荐资源	实践建议
系统设计	Designing Data-Intensive Applications	实现一个简易版分布式缓存
云原生	Kubernetes 官方教程	部署有状态服务并配置 Horizontal Pod Autoscaler