输出反向链表时出现无限循环

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《输出反向链表时出现无限循环》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

我正在学习 go，并编写了以下代码来反转链表。但是，该代码无法按预期工作。

这是一个 node 结构以及用于打印和反转列表的函数。

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 时，我得到了列表中所有元素的看似无限的输出，除了最后一个元素（曾经是第一个元素）

这是我的 main 函数：

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)
}

这是我使用的 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
}

解决方案

*node = *n

这行代码的作用与您想象的不同。您可能希望它将外部 *node 更改为指向新的头部（旧的尾部），是吗？嗯，不，它只是替换该位置的节点。这解释了为什么前面的第一个值丢失了。

所以在最后一步之前你会有这样的事情

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

然后将 node 替换为 n 的值（即 nil <- 3 -> 2）。这使得结构看起来像这样：

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

顺便说一下，这个列表太小了，所以这个图表可能会产生误导。以下是更多元素的外观：

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

您可以在那里使用 **node 。或者简单地从函数返回新的头：

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)

以上就是《输出反向链表时出现无限循环》的详细内容，更多关于的资料请关注golang学习网公众号！