从零构建图结构，手把手教你用C语言实现邻接表遍历算法

第一章：从零认识图结构与邻接表

图是计算机科学中用于表示对象之间关系的重要数据结构。它由一组顶点（节点）和一组连接这些顶点的边组成，广泛应用于社交网络、路径规划、推荐系统等领域。

什么是图结构

图可以分为有向图和无向图。在有向图中，边具有方向性；而在无向图中，边没有方向。此外，图还可以带有权重，称为加权图，常用于表示距离或成本。

邻接表的实现方式

邻接表是一种高效存储稀疏图的方法，它为每个顶点维护一个链表，记录与其相邻的所有顶点。相比邻接矩阵，邻接表在空间使用上更加节省，尤其适用于边数远小于顶点数平方的场景。 以下是使用Go语言实现邻接表的基本结构：

// 定义图的邻接表表示
type Graph struct {
    vertices int
    adjList  map[int][]int
}

// 初始化一个包含v个顶点的图
func NewGraph(v int) *Graph {
    return &Graph{
        vertices: v,
        adjList:  make(map[int][]int),
    }
}

// 添加一条从u到v的边
func (g *Graph) AddEdge(u, v int) {
    g.adjList[u] = append(g.adjList[u], v) // 有向图
    // 若为无向图，还需添加反向边：g.adjList[v] = append(g.adjList[v], u)
}

• 初始化图结构，分配顶点数量和邻接列表映射
• 通过AddEdge方法动态添加边
• 遍历时可对每个顶点的邻接列表进行迭代访问

表示方法	空间复杂度	适用场景
邻接表	O(V + E)	稀疏图
邻接矩阵	O(V²)	稠密图

graph TD A --> B A --> C B --> D C --> D

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

2.1 图的基本概念与邻接表存储原理

图是由顶点集合和边集合构成的非线性数据结构，用于表示对象之间的多对多关系。每个顶点（或称节点）通过边与其他顶点相连，边可具有方向性（有向图）或权重（加权图）。

邻接表的结构设计

邻接表使用数组与链表结合的方式存储图。数组的每个元素对应一个顶点，其链表存储所有与该顶点相邻的节点。

• 节省空间：适用于稀疏图，避免邻接矩阵的空间浪费
• 动态扩展：易于插入和删除边

邻接表的代码实现

type Graph struct {
    vertices int
    adjList  []([]int)
}

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

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

上述 Go 语言实现中，adjList 是一个切片的切片，每个子切片保存从对应顶点出发的所有邻接点。添加边的操作时间复杂度为 O(1)，整体结构灵活高效。

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

在图的实现中，首先需要明确定义顶点和边的数据结构。顶点通常用于表示实体，而边则描述实体之间的连接关系。

顶点的基本结构

顶点可使用结构体封装其属性，如编号、数据等。例如：

typedef struct Vertex {
    int id;                 // 顶点唯一标识
    char* data;             // 存储附加信息
} Vertex;

该结构便于扩展，id用于快速索引，data可存储名称或其他元数据。

边的表示方式

边可定义为连接两个顶点的结构：

typedef struct Edge {
    Vertex* src;            // 源顶点
    Vertex* dest;           // 目标顶点
    int weight;             // 权重，无权图可设为1
} Edge;

src与dest指针实现灵活连接，weight支持带权图应用。

结构对比

结构	用途	适用场景
Vertex	表示节点	所有图结构
Edge	表示连接	邻接表或边列表

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

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

链表节点的动态创建

每个链表节点通常包含数据域和指向下一个节点的指针域。通过 malloc 分配空间，确保节点独立存在堆区。

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

struct Node* create_node(int value) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    if (!node) {
        perror("Memory allocation failed");
        exit(EXIT_FAILURE);
    }
    node->data = value;
    node->next = NULL;
    return node;
}

上述代码中，malloc 为新节点分配内存，若失败则终止程序；返回指向合法节点的指针，用于链表插入操作。

内存管理注意事项

• 每次 malloc 都应检查返回值是否为 NULL
• 节点删除后必须调用 free() 防止内存泄漏
• 避免悬空指针：释放后应将指针置为 NULL

2.4 构建图：添加顶点与边的完整实现

在图数据结构中，构建图的核心在于动态添加顶点和边。首先需要初始化一个邻接表，通常使用哈希表存储每个顶点及其相邻顶点集合。

添加顶点

每个新顶点需唯一标识，避免重复插入：

func (g *Graph) AddVertex(v string) {
    if _, exists := g.vertices[v]; !exists {
        g.vertices[v] = make(map[string]bool)
    }
}

该方法确保顶点不存在时才初始化其邻接集合，时间复杂度为 O(1)。

添加边

添加有向边从 u 到 v，若为无向图则反向也需添加：

func (g *Graph) AddEdge(u, v string) {
    g.AddVertex(u)
    g.AddVertex(v)
    g.vertices[u][v] = true
}

此操作自动补全缺失顶点，并建立连接关系。

操作复杂度对比

操作	时间复杂度	说明
AddVertex	O(1)	哈希表插入
AddEdge	O(1)	两次查找加一次映射设置

2.5 邻接表的初始化与销毁操作封装

在图的邻接表实现中，合理的初始化与销毁操作是内存安全和性能保障的基础。通过封装这两个过程，可以有效避免资源泄漏并提升代码可维护性。

邻接表结构定义

typedef struct ArcNode {
    int adjvex;
    struct ArcNode* next;
} ArcNode;

typedef struct {
    ArcNode** heads;
    int vertexNum;
} AdjListGraph;

该结构中，heads 是指向指针数组的指针，每个元素指向一个边链表；vertexNum 记录顶点数量。

初始化操作

void initGraph(AdjListGraph* graph, int n) {
    graph->vertexNum = n;
    graph->heads = (ArcNode**)calloc(n, sizeof(ArcNode*));
}

使用 calloc 分配并清零内存，确保所有头指针初始为 NULL，防止野指针。

销毁操作

• 遍历每个顶点的邻接链表
• 逐个释放边节点内存
• 最后释放头指针数组

保证了动态内存的完全回收，符合资源管理规范。

第三章：深度优先遍历（DFS）算法实现

3.1 DFS遍历逻辑与递归策略解析

深度优先搜索（DFS）通过递归方式探索图或树的每个分支，直至最深层节点。其核心在于“回溯”机制，即当前路径无法继续时返回上一节点尝试其他路径。

递归实现框架

def dfs(graph, node, visited):
    if node not in visited:
        print(node)
        visited.add(node)
        for neighbor in graph[node]:
            dfs(graph, neighbor, visited)

该代码中，visited 集合防止重复访问，graph[node] 遍历当前节点所有邻接点。每次递归调用传入未访问的邻居节点，确保完整遍历连通分量。

调用栈与执行顺序

• 首次访问根节点并标记已访问
• 递归进入第一个未访问子节点
• 持续深入直到无后继节点
• 回溯至存在未访问子节点的祖先

3.2 使用栈模拟递归过程的非递归实现

在处理递归算法时，函数调用本身依赖于系统调用栈。通过显式使用栈数据结构，可以将递归过程转化为非递归实现，避免栈溢出并提升控制灵活性。

核心思路

将递归函数的参数和状态压入自定义栈中，通过循环模拟函数调用过程。每次从栈中取出一个状态进行处理，必要时将子问题重新入栈。

代码示例：非递归后序遍历二叉树

stack st;
TreeNode* lastVisited = nullptr;
while (root || !st.empty()) {
    if (root) {
        st.push(root);
        root = root->left;
    } else {
        TreeNode* peek = st.top();
        if (peek->right && lastVisited != peek->right) {
            root = peek->right;
        } else {
            cout << peek->val << " ";
            lastVisited = st.top(); st.pop();
        }
    }
}

上述代码通过栈模拟系统调用栈，利用 lastVisited 标记判断右子树是否已访问，确保左-右-根的顺序执行。与递归相比，该方式更可控且适用于深度较大的树结构。

3.3 遍历路径记录与访问状态控制

在图或树的深度优先搜索（DFS）过程中，准确记录遍历路径并管理节点的访问状态至关重要。为避免重复访问导致无限循环，通常引入布尔数组或集合来标记已访问节点。

访问状态管理策略

• 使用 visited 布尔切片标记节点是否已被访问
• 递归前标记当前节点为已访问，回溯时可选择性取消标记以支持多路径探索
• 路径使用栈结构动态维护，进入节点时压入，退出时弹出

func dfs(node int, graph [][]int, visited []bool, path *[]int) {
    visited[node] = true
    *path = append(*path, node) // 记录当前路径

    for _, neighbor := range graph[node] {
        if !visited[neighbor] {
            dfs(neighbor, graph, visited, path)
        }
    }

    *path = (*path)[:len(*path)-1] // 回溯：移除当前节点
}

上述代码中，visited 控制访问状态，防止重复进入；path 实时记录搜索路径。回溯阶段通过切片截断实现路径撤销，确保后续搜索不受影响。

第四章：广度优先遍历（BFS）算法实现

4.1 BFS核心思想与队列的应用

BFS（广度优先搜索）的核心思想是逐层扩展，从起始节点出发，优先访问所有相邻节点，再依次访问这些相邻节点的未访问邻居，确保最短路径的探索顺序。

队列在BFS中的关键作用

BFS使用队列（FIFO）结构维护待访问节点。先进入队列的节点先被处理，保证了层级遍历的正确性。

• 初始化时将起点入队
• 每次取出队首节点并访问其邻接点
• 未访问的邻接点标记后入队

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    
    while queue:
        node = queue.popleft()          # 取出队首节点
        for neighbor in graph[node]:    # 遍历邻接节点
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)  # 新节点入队

代码中 deque 实现高效出入队操作，visited 集合避免重复访问，确保算法在线性时间内完成图的遍历。

4.2 C语言中循环队列的实现与集成

循环队列通过复用已出队的空间，有效避免普通队列的“假溢出”问题，是嵌入式系统和实时通信中的常用数据结构。

基本结构定义

typedef struct {
    int *data;
    int front;
    int rear;
    int capacity;
} CircularQueue;

该结构体包含动态数组指针 data、队头索引 front、队尾索引 rear 和最大容量 capacity。其中，rear 指向下一个插入位置，front 指向当前队首元素。

核心操作逻辑

判断空：`front == rear`；判断满：`(rear + 1) % capacity == front`。入队时更新 rear，出队时更新 front，均采用模运算实现循环特性。

• 初始化需动态分配内存并设置初始状态
• 入队前必须检查队列是否已满
• 出队后应返回值并移动队头指针

4.3 层次遍历输出与最短路径初步探索

层次遍历的基本实现

层次遍历（Level-order Traversal）依赖队列结构实现，按树的层级从左到右访问节点。以下为二叉树的层次遍历代码示例：

from collections import deque

def level_order(root):
    if not root:
        return []
    result, queue = [], deque([root])
    while queue:
        node = queue.popleft()
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result

该算法时间复杂度为 O(n)，每个节点入队出队一次。使用双端队列保证了高效的头部弹出操作。

最短路径的图论视角

在无权图中，层次遍历可自然扩展为最短路径搜索。BFS首次到达目标节点时，其路径即为最短路径。

• 适用场景：社交网络中的好友推荐、迷宫寻路
• 核心优势：避免深度优先搜索的路径冗余
• 数据结构：仍采用队列，但需记录路径或距离信息

4.4 BFS在连通性检测中的实际应用

在分布式系统中，判断节点间是否连通是保障服务可用性的关键。BFS因其逐层遍历的特性，非常适合用于检测图中任意两节点之间是否存在路径。

网络拓扑连通性验证

通过将网络设备抽象为图的顶点，连接关系作为边，可构建无向图模型。从任一节点启动BFS，标记所有可达节点，未被访问者即为不连通设备。

from collections import deque

def is_connected(graph, start, target):
    visited = set()
    queue = deque([start])
    visited.add(start)
    
    while queue:
        node = queue.popleft()
        if node == target:
            return True
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    return False

该函数以起始节点出发，利用队列实现层级扩展，visited集合避免重复访问。当目标节点被命中时，立即返回True，时间复杂度为O(V + E)，适用于大规模稀疏图场景。

第五章：算法性能分析与扩展思考

时间复杂度的实际影响

在真实场景中，算法的时间复杂度直接影响系统响应速度。例如，在处理百万级用户推荐列表时，若使用 O(n²) 的冒泡排序，耗时可能超过数分钟；而改用 O(n log n) 的快速排序后，执行时间可压缩至毫秒级。

• 选择合适的数据结构能显著降低复杂度
• 递归算法需警惕栈溢出和重复计算问题
• 预处理和缓存机制可将在线查询优化为离线计算

空间换时间的工程实践

// 使用哈希表缓存已计算的斐波那契数
var cache = make(map[int]int)

func fib(n int) int {
    if n <= 1 {
        return n
    }
    if val, exists := cache[n]; exists {
        return val // 避免重复递归
    }
    cache[n] = fib(n-1) + fib(n-2)
    return cache[n]
}

分布式环境下的算法扩展

面对超大规模数据集，单机算法往往无法胜任。通过将 MapReduce 模型应用于词频统计任务，可将原本需要数小时的任务分布到集群并行处理。

算法类型	单机处理上限	集群扩展能力
DFS 遍历	10^5 节点	有限
BSP 并行图计算	无硬性限制	强

动态适应性设计

当请求延迟 > 阈值 → 启动异步降级策略 → 切换至近似算法（如 HyperLogLog）→ 监控误差率 → 动态恢复