在图论算法中，邻接链表（邻接表）是最常用的存储结构——它简洁高效，能快速表示节点间的连接关系。但正是这种“简洁性”，让很多开发者（包括我）陷入“机械套用”的陷阱：看似掌握了邻接表的语法，却没理解其“节点→后继节点”的核心映射逻辑，最终写出逻辑错乱、甚至超时的代码。

本文结合我在 allPathsSourceTarget 问题中踩的坑，聊聊邻接链表在算法中的实际使用误区、核心原则，以及如何避免“看似正确却无效”的代码。

一、故事的起点：一段“看似没问题”的超时代码

LeetCode 的 allPathsSourceTarget 问题很直接：给定有向无环图（DAG）的邻接表 graph，返回所有从起点 0 到终点 n-1 的路径。我信心满满地写出了这样的 DFS 代码：

def allPathsSourceTarget(self, graph):
    answer = []
    def dfs(start, path, n):
        if start == n-1:
            answer.append(path[:])
            return
        l = len(graph[start])
        for i in range(l):
            path.append(i)  # 错误：把索引当节点
            dfs(i, path, n)  # 错误：递归传递索引
            path.pop()
    n = len(graph)
    dfs(0, [], n)
    return answer

结果毫不意外：超时。更尴尬的是，用简单测试用例 graph = [[1], [2], []] 调试时，发现代码陷入了无限递归——dfs(0, ...) 调用 dfs(0, ...)，循环往复。

这段代码的语法完全正确，但逻辑却从根上错了。而错误的核心，正是对“邻接链表的结构和映射关系”理解不清。

二、先搞懂：邻接链表的本质不是“列表的列表”

很多人把邻接表简单理解为“列表套列表”，但这只是它的语法形式，核心是“节点到后继节点的映射关系”。我们用具体例子拆解：

假设 graph = [[1,3], [2], [3], []]，这是一个 4 节点（0~3）的有向图：

  • 外层列表的索引：graph[u] 中的 u 是“起点节点”（比如 graph[0] 表示所有从节点 0 出发的边）；
  • 内层列表的元素：graph[u] 中的每个元素 v 是“终点节点”（比如 graph[0] = [1,3] 表示 0→1、0→3 两条边）；
  • 内层列表的索引：比如 graph[0] 的索引 0 对应元素 1，索引 1 对应元素 3——这个索引只是访问元素的工具，没有任何实际语义。

简单说：邻接表的核心是“u → [v1, v2, ...]”，而不是“u → [索引0, 索引1, ...]”。我的代码之所以错，就是把“内层索引”当成了“终点节点”，完全违背了邻接表的映射本质。

三、邻接链表使用的三大核心误区（我全踩了）

误区1：混淆“内层索引”和“实际节点”（最致命）

这是导致无限递归的直接原因。在我的代码中：

  • 遍历 for i in range(l) 拿到的是 graph[start] 的内层索引（比如 0、1）；
  • 错误地将 i 当成了“下一个要访问的节点”，执行 path.append(i) 和 dfs(i, ...)；
  • 当 graph[0] = [1,3] 时，i=0 被当成节点 0，递归调用 dfs(0, ...)，形成无限循环（0→0→0→...）。

正确的做法是：遍历内层列表的元素（实际节点），而非索引。比如 for v in graph[start]，直接拿到 start 能到达的节点 v，再递归 dfs(v, ...)。

误区2：忽略邻接表的“方向性”

邻接表是“有向”的映射（u → v 不代表 v → u），但很多人会下意识地忽略这一点。比如在路径搜索中，误将 graph[v] 当成 v 能到达 u 的证据，导致路径推进逻辑错乱。

我的代码虽然没直接犯这个错，但本质上是“无方向遍历”——不管 start 能到达哪个节点，只按索引推进，完全脱离了邻接表的方向约束。

四、邻接链表的正确使用原则

原则1：先明确“映射关系”，再写代码

拿到邻接表 graph 后，先问自己三个问题：

  1. 外层索引 u 代表什么？（起点节点）
  2. 内层元素 v 代表什么？（终点节点）
  3. 我需要的“路径/关系”是什么？（比如从 u 到 v 的边）

在 allPathsSourceTarget 中，我需要的是“从当前节点 current 到其所有后继节点 v 的路径”，所以核心逻辑必须是“遍历 graph[current] 的元素 v”，而非索引。

原则2：区分“工具”和“核心”——索引不是节点

邻接表的内层索引只是“访问元素的工具”，就像钥匙不是房间本身。使用时要记住：

  • 工具（内层索引 i）：仅用于获取核心数据（v = graph[u][i]）；
  • 核心（节点 v）：用于路径构建、递归推进、条件判断。

两种遍历方式的正确实现（对比参考）

方式 1：坚持用索引遍历（需手动转换）

如果因特殊场景（比如需要记录边的索引）坚持要用索引，必须先通过索引拿到节点，再进行后续操作：

for i in range(len(graph[current])):
    v = graph[current][i]  # 索引→节点的关键转换
    path.append(v)
    dfs(v, path)
    path.pop()

方式 2：直接映射（推荐，无需索引）

这是最贴合邻接表 “节点→后继节点” 映射本质的方式 —— 跳过索引，直接遍历内层列表的 “核心数据（节点 v）”，代码更简洁、不易出错：

for v in graph[current]:  # 直接遍历核心数据（节点v），无需索引中转
    path.append(v)
    dfs(v, path)
    path.pop()

原则3：结合题目规则，验证逻辑闭环

邻接表的使用必须和题目规则绑定：

  • 节点编号规则：比如本题节点是 0~n-1，终点是 n-1；
  • 图的类型：比如本题是 DAG，无环，无需 visited 数组；如果是有环图，必须加访问标记避免循环；
  • 路径要求：比如本题需要“完整路径”，初始路径必须包含起点（[start]），终止时要收集完整路径。

五、邻接链表的其他实战场景（核心逻辑一致）

邻接表的使用原则不仅适用于路径搜索，在其他图论算法中也完全通用：

场景1：拓扑排序（Kahn 算法）

核心是“基于邻接表找节点的入度和后继”：

  • 邻接表 graph[u] 存储 u 的后继节点 v；
  • 入度数组 in_degree[v] 记录 v 的入度；
  • 遍历 graph[u] 的元素 v，而非索引，更新入度和队列。

场景2：最短路径（BFS）

核心是“从当前节点 u 出发，遍历所有后继 v，更新距离”：

  • 队列存储当前节点 u；
  • 遍历 for v in graph[u]，计算 dist[v] = min(dist[v], dist[u] + 1)；
  • 若遍历索引，会导致更新错误的节点距离。

场景3：无环图的最长路径

核心是“DFS 遍历所有后继节点，记录最大路径长度”：

  • 从起点出发，遍历 graph[current] 的所有 v；
  • 递归 dfs(v)，回溯时更新最大长度；
  • 若混淆节点和索引，会导致递归方向错误，无法找到有效路径。

六、最终反思：算法不是“模板堆砌”，而是“数据结构的逻辑映射”

我的代码超时，表面上是“细节错误”，本质上是“对数据结构的理解停留在语法层面”。邻接表看似简单，但如果没有搞懂“u → [v]”的映射本质，再熟练的 DFS 模板也只是“空中楼阁”。

总结下来，使用邻接表的关键不是“记住语法”，而是：

  1. 先拆解邻接表的映射关系（谁是起点，谁是终点）；
  2. 区分“工具数据”（如索引）和“核心数据”（如节点）；
  3. 结合题目规则，让每一步遍历、递归都有逻辑支撑。

就像盖房子，邻接表是“建材”，映射关系是“图纸”——如果看不懂图纸，再好用的建材也只能堆出一堆废墟。下次再用邻接表时，不妨先停下来问自己：“这个列表的索引和元素，到底代表什么？” 想通这一点，很多错误自然就避免了。

最后用一句话收尾：数据结构的价值不在于“怎么存”，而在于“怎么映射”——理解了映射逻辑，算法才能真正跑通。