Algorithm 有人能给我解释一下，给定一个头部节点，双向链表的反转吗？

我看过其他的解决方案，但我很难想象效果。 我知道我们必须切换.next和.prev，但我不明白为什么我们要迭代到.prev

例如： 给定Null-->A-->Null

如果头是一个

我们将一个变量“transverse”设置为head

当穿越时！=空

1） temp=traverse.prev

2） traverse.prev=traverse.next

3） traverse.next=temp

4） （混淆部分）**TRANSERVE=TRANSERVE.prev

因此，在我们给定的设置中，在第一次迭代之后，它将是

B-->零，C-->D-->零

---

考虑到这一点，我无法想象第二次迭代和以后的迭代。如果B是遍历，我们最终交换C和A？

您已经交换了A的上一个/下一个，但还没有接触到B，所以B必须仍然是遍历

A<--B-->C

这样，您仍然持有指向新头部（您可以返回给调用方）的遍历指针，否则您所拥有的只是一个指向尾部（原始头部）的指针，这现在不是很有趣

---

哇，我在这个答案上花了比我应该花的更多的精力——但我喜欢数据结构。

在步骤

1

、

2

和

3

之后，原始列表进程的下一个节点现在由

遍历指向。prev

因为

next

和

prev

被交换

在第一次迭代之后，

A.next

为

null

，

A.prev

指向

B

，但是

B.prev

仍然指向

A

，

B.next

指向

C

第二次操作后，

B.prev

指向

C

，而

B.next

指向

A

---

因此，在每次交互中，您修复单个节点的引用，并移动到原始列表的下一个（现在由

prev

作为目标）。

给定双链接列表

NULL<-A<=>B<=>C<=>D->NULL

行

[1]

、

[2]

和

[3]

交换遍历的上一个和下一个节点。假设这是您的第一次迭代，就在您的链的第四行之前：

        +----------+
        |          | A.prev
        |          V
(traverse = A) <-- B <=> C <=> D -> NULL
        |
        | A.next
        v
      NULL

+----------+
|| A.prev
|五
（遍历=A）空
|
|A.下一个
v
无效的

---

因此，当执行第四行时，

travel

变为

A.prev

，这意味着

B

，然后继续执行。

Ok现在更有意义了。指针是以“循环方式”运行的。在第一次迭代之后，a.prev是B，B.prev是a，这对我来说没有多大意义是的，这在过程中是固定的。在每次迭代中，只处理一个节点

While (traverse.prev != null)

NULL<-A<=>B<=>C<=>D->NULL

traverse = A

while traverse != Null...
  temp          = traverse.prev    // [1]
  traverse.prev = traverse.next    // [2]
  traverse.next = temp             // [3]
  traverse      = traverse.prev    // [4]

        +----------+
        |          | A.prev
        |          V
(traverse = A) <-- B <=> C <=> D -> NULL
        |
        | A.next
        v
      NULL