go语言中处理循环引用遍历的两种方法：使用标记跟踪已遍历元素，避免重复遍历。使用栈记录遍历路径，遇到循环引用时返回正确节点。

Go 语言函数遍历数据结构时处理循环引用的方法

在 Go 语言中，遍历数据结构时可能会遇到循环引用问题。循环引用是指数据结构中存在指向其自身的引用，导致无法正常终止遍历。

方法一：使用标记

使用标记来跟踪已经遍历过的元素，避免重复遍历。

// 示例代码
type Node struct {
    Value  int
    Next   *Node
    Marked bool
}

func traverse(node *Node) {
    if node == nil {
        return
    }

    node.Marked = true  // 标记已遍历

    // 遍历剩余结构
    for node != nil {
        fmt.Println(node.Value)
        node = node.Next
    }

    // 取消标记，以便后续遍历
    node.Marked = false
}

方法二：使用栈

使用栈来记录遍历路径，以便遇到循环引用时返回到正确的节点。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

立即学习“go语言免费学习笔记（深入）”；

// 示例代码
type Node struct {
    Value  int
    Next   *Node
}

func traverse(node *Node) {
    var stack []*Node

    for node != nil {
        if node.Next != nil && node.Next == stack[len(stack)-1] {
            // 循环引用，跳过此链条
            node = node.Next
            continue
        }

        stack = append(stack, node)

        // 遍历剩余结构
        node = node.Next
    }

    // 栈中元素为遍历过的元素，处理逻辑...
    for len(stack) > 0 {
        node := stack[len(stack)-1]
        fmt.Println(node.Value)
        stack = stack[:len(stack)-1]
    }
}

实战案例

场景 1：遍历链表

type Node struct {
    Value  int
    Next   *Node
}

func traverse(head *Node) {
    for head != nil {
        if head.Next != nil && head.Next == head {
            // 循环引用，跳过此链条
            head = head.Next
            continue
        }

        fmt.Println(head.Value)
        head = head.Next
    }
}

场景 2：遍历图

type Node struct {
    Value  int
    Edges  []*Node
}

func traverse(root *Node) {
    var stack []*Node
    visited := make(map[*Node]bool)

    for root != nil {
        if ok := visited[root]; ok {
            // 已遍历过，跳过
            root = root.Edges[0]
            continue
        }

        visited[root] = true
        stack = append(stack, root)

        // 遍历剩余结构
        root = root.Edges[0]
    }

    // 栈中元素为遍历过的元素，处理逻辑...
    for len(stack) > 0 {
        node := stack[len(stack)-1]
        fmt.Println(node.Value)
        stack = stack[:len(stack)-1]
    }
}