Go 输出反向链表时获得无限循环

我正在学习Go，并编写了以下代码来反转链接列表。但是，代码没有按预期工作

下面是一个节点结构，以及打印和反转列表的功能

type Node struct {
    number   int
    previous *Node
    next     *Node
}

func PrintList(node *Node) {
    for n := node; n != nil; n = n.next {
        fmt.Println(n)
    }
}

func ReverseList(node *Node) {
    var nextNodeRef *Node

    for n := node; n != nil; n = n.previous {
        if n.next == nil {
            n.next = n.previous
            n.previous = nil

            *node = *n

            break
        } else {
            nextNodeRef = n.next

            n.next = n.previous
            n.previous = nextNodeRef

            if n.next == nil {
                node = n
            }
        }
    }

}

问题是，当我反转列表并调用

PrintList

时，除了最后一个元素（它曾经是第一个元素）之外，列表中所有元素的输出似乎都是无限的

这是我的

主要功能：

func main() {
    myList := Node{1, nil, nil}
    myListAddress := &myList

    AddNumber(2, myListAddress)
    AddNumber(3, myListAddress)

    fmt.Println("My list:")
    PrintList(myListAddress)

    ReverseList(myListAddress)
    fmt.Println("My list reversed:")
    // here I always get list elements that contain 3, 2, 3, 2...
    PrintList(myListAddress)
}

func ReverseList(node *Node) *Node {

    for n := node; n != nil; n = n.previous {
        if n.next == nil {
            n.next = n.previous
            n.previous = nil

            return n
        } else {
            n.next, n.previous = n.previous, n.next
        }
    }

    return node
}

下面是我使用的
AddNumber
函数：

func AddNumber(number int, node *Node) *Node {
    if node == nil {
        log.Fatal("No Node provided")
    }

    var newNode Node

    for n := node; n != nil; n = n.next {
        if n.next == nil {
            newNode = Node{number, n, nil}
            n.next = &newNode

            break
        }
    }

    return &newNode
}

这条线并不像你想象的那样。您可能希望它将外部的
*节点更改为指向新的头部（旧的尾部），是吗？不，它只是替换那个位置的节点。这解释了前一个第一个值丢失的原因

所以在这最后一步之前，你有这样的东西

nil <- 3 <=> 2 <=> 1 -> nil
       ↑           ↑
       n           node, myListAddress

顺便说一句，这个列表太小了，这个图表可能会有误导性。以下是使用更多元素时的外观：

      prev
 ┌────────────────────────────┐
 │                            │ node, myListAddress    
 ˅                            │╱
nil <- 5 <=> 4 <=> 3 <=> 2 -> 5 ──┐
             ^                    │next
             └────────────────────┘

然后

我花在这些箭头上的时间比我应该花的时间多得多：/
      prev
 ┌────────────────────────────┐
 │                            │ node, myListAddress    
 ˅                            │╱
nil <- 5 <=> 4 <=> 3 <=> 2 -> 5 ──┐
             ^                    │next
             └────────────────────┘

func ReverseList(node *Node) *Node {

    for n := node; n != nil; n = n.previous {
        if n.next == nil {
            n.next = n.previous
            n.previous = nil

            return n
        } else {
            n.next, n.previous = n.previous, n.next
        }
    }

    return node
}

myListAddress = ReverseList(myListAddress)