相邻节点迭代器（实战总结）

相邻节点迭代器：深入理解树与图中的遍历逻辑

在编程世界里，数据结构是构建高效算法的基石。当你处理树、图这类非线性结构时，常常需要访问某个节点的直接邻居——也就是与它相连的其他节点。这种“访问相邻节点”的需求，催生了一种非常实用的编程模式：相邻节点迭代器。它不仅让代码更清晰，还能帮助你更高效地实现广度优先搜索（BFS）、深度优先搜索（DFS）等经典算法。

想象一下，你正在探索一座迷宫。每到一个岔路口，你都会查看所有可以直接到达的出口。这个过程，就和“相邻节点迭代器”在数据结构中的作用如出一辙。它不是简单地列出所有邻居，而是一个可以逐个访问、控制迭代节奏的工具。

什么是相邻节点迭代器？

相邻节点迭代器是一种设计模式，它允许你以统一的方式遍历某个节点的所有邻接节点。它的核心思想是：将“如何获取邻居”与“如何遍历邻居”解耦。

在传统实现中，你可能会写一段代码直接遍历一个邻接列表，比如：

for neighbor in node.neighbors:
    print(neighbor.value)

但这在复杂场景下会变得难以维护。比如你要支持多种遍历策略（按顺序、随机、带权重），或者需要在遍历过程中动态修改图结构。这时候，引入迭代器就显得尤为重要。

相邻节点迭代器的优势在于：

• 代码更加模块化
• 支持懒加载（只在需要时获取下一个节点）
• 可以与标准库的 for 循环无缝结合
• 便于实现复杂遍历逻辑，如跳过某些节点、限制访问深度等

创建数组与初始化

在开始实现之前，我们先定义一个简单的图节点结构。这里以 Python 为例，用类来表示一个图中的节点。

class GraphNode:
    def __init__(self, value):
        self.value = value           # 节点的值，比如 'A'、'B'
        self.neighbors = []          # 存储相邻节点的列表

接下来，我们为这个节点添加一个方法，用于返回其相邻节点的迭代器。

class GraphNode:
    def __init__(self, value):
        self.value = value
        self.neighbors = []

    def get_neighbors_iterator(self):
        """返回一个迭代器，用于逐个访问相邻节点"""
        # 这里使用生成器函数，实现懒加载
        for neighbor in self.neighbors:
            yield neighbor

这个 get_neighbors_iterator 方法返回的是一个生成器对象。当外部调用 for 循环时，它才会真正开始遍历邻居列表。这种设计非常节省内存，尤其适用于大型图结构。

💡 小贴士：生成器函数（yield）是 Python 实现迭代器的核心机制。它不是一次性把所有邻居都加载到内存，而是在每次 next() 调用时才返回下一个元素。

实现一个完整的迭代器类

虽然生成器函数很方便，但在某些场景下，你可能需要更精细的控制。比如你希望支持 has_next()、next()、reset() 等方法。这时，可以自定义一个迭代器类。

class NeighborIterator:
    def __init__(self, neighbors):
        self.neighbors = neighbors   # 邻居列表
        self.index = 0               # 当前索引位置

    def has_next(self):
        """判断是否还有下一个邻居"""
        return self.index < len(self.neighbors)

    def next(self):
        """返回下一个邻居，并移动索引"""
        if not self.has_next():
            raise StopIteration("没有更多邻居了")
        node = self.neighbors[self.index]
        self.index += 1
        return node

    def reset(self):
        """重置迭代器，回到起始位置"""
        self.index = 0

使用这个迭代器时，你可以这样写：

node_a = GraphNode('A')
node_b = GraphNode('B')
node_c = GraphNode('C')
node_d = GraphNode('D')

node_a.neighbors = [node_b, node_c, node_d]

iterator = NeighborIterator(node_a.neighbors)

while iterator.has_next():
    neighbor = iterator.next()
    print(f"访问邻居: {neighbor.value}")

输出：

访问邻居: B
访问邻居: C
访问邻居: D

这种方式特别适合需要重复遍历、或在遍历过程中做条件判断的场景。

在图遍历算法中的应用

相邻节点迭代器的价值，在图遍历算法中体现得淋漓尽致。我们以广度优先搜索（BFS）为例，展示如何使用它来简化代码。

from collections import deque

def bfs(start_node):
    """使用相邻节点迭代器实现 BFS"""
    visited = set()
    queue = deque()
    queue.append(start_node)
    visited.add(start_node.value)

    print(f"开始 BFS，从节点 {start_node.value} 开始")

    while queue:
        current = queue.popleft()
        print(f"访问节点: {current.value}")

        # 使用相邻节点迭代器获取邻居
        neighbor_iter = current.get_neighbors_iterator()

        # 遍历所有邻居
        for neighbor in neighbor_iter:
            if neighbor.value not in visited:
                visited.add(neighbor.value)
                queue.append(neighbor)
                print(f"  添加邻居 {neighbor.value} 到队列")

在这个例子中，get_neighbors_iterator() 提供了统一的接口，无论图结构如何变化，BFS 的主逻辑保持不变。这正是“相邻节点迭代器”带来的解耦优势。

✅ 你可能会问：为什么不直接用 for neighbor in node.neighbors？
回答是：当你要支持多种遍历策略（如按权重、按颜色过滤）时，迭代器模式让你可以轻松扩展，而无需修改主算法。

性能对比与最佳实践

在实际开发中，推荐优先使用生成器函数方式。它简洁、高效、可读性强，且与 Python 的 for 循环完全兼容。

如果你的项目中需要频繁重置迭代器、或进行复杂的状态管理，再考虑使用自定义类。但记住：不要过早优化，先让代码跑通，再根据需求调整。

总结与延伸思考

相邻节点迭代器不是一个高深莫测的概念，而是一种让代码更清晰、更灵活的实用模式。它帮助我们把“访问邻居”这件事从具体实现中抽离出来，形成一个可复用、可扩展的组件。

无论是实现 BFS、DFS，还是构建复杂的图分析工具，掌握这一模式都能让你的代码质量跃上一个台阶。它背后体现的，正是面向接口编程、关注点分离的设计哲学。

在未来的项目中，不妨尝试将每个节点的邻居访问都封装成一个迭代器。你会发现，代码的可读性、可维护性，甚至调试效率，都会显著提升。

最后提醒一句：不要被“迭代器”这个词吓到。它本质上只是“一个能逐个返回元素的东西”。当你学会用它来组织逻辑，你会突然发现，许多原本复杂的循环，变得异常简单。