Java 这个链表反向实现是如何工作的？

我正在试图理解下面的反向

LinkedList

代码是如何工作的

public void reverse(Node<T> h) {
  Node<T> d = new Node<T>();
  Node<T> t;
  while (h.next != null) {
     t = h.next; //temp nodes points to h.next (1st item in list)
     h.next = t.next; //h.next bypasses first node in list.
     t.next = d.next; //t.next points to d.next.. where is d.next pointing to?
     d.next = t; //d.next now points to t.
  }
   h.next = d.next;
  }

public void reverse（节点h）{
节点d=新节点（）；
节点t；
while（h.next！=null）{
t=h.next；//临时节点指向h.next（列表中的第一项）
h、 next=t.next；//h.next绕过列表中的第一个节点。
t、 next=d.next；//t.next指向d.next..d.next指向哪里？
d、 next=t；//d.next现在指向t。
}
h、 next=d.next；
}

这个过程是如何工作的

---

一张图表将是惊人的。似乎一个列表中的节点被弹出并推入一个新列表？在这种情况下，

h

是否指向正在反转的列表？

更新我自己，以及挑战的编校：

该算法确实有效，它只是以一种令人困惑的方式编写，不包括第一个节点（它仅用于副作用），这是一个。。。有问题的设计本身

重写它以避免无用的

d.next

并更好地定义

t

的范围，使我更容易（也可能）遵循：

public void reverse(Node<T> h) { // draw H under first node
  Node<T> d = null
  while (h.next != null) {
     Node<T> t = h.next;  // draw T under box at end of H arrow (remove any previous T)
     h.next = t.next;     // change arrow from H to end where arrow from box above T ends (no arrow for last element)
     t.next = d;          // draw arrow from box above T to box D is under (no arrow for first element)
     d = t;               // draw D under box (remove any previous D)
   }
   h.next = d;            // draw arrow from H to box D is under
}

public void reverse（节点h）{//在第一个节点下绘制h
节点d=null
while（h.next！=null）{
节点t=h.next；//在h箭头末尾的框下绘制t（删除之前的任何t）
h、 next=t.next；//将箭头从h改为t端上方框中的箭头（最后一个元素没有箭头）
t、 next=d；//从t上方的框中绘制箭头，到t下方的框中绘制箭头（第一个元素没有箭头）
d=t；//在方框下画d（删除之前的任何d）
}
h、 next=d；//从h向下方方框d绘制箭头
}

到箱子上去

（我建议您查看上的代码，这是相同的概念，但更容易理解，并且没有此实现的假头节点。）

---

我知道我说过“画盒子就行了”。所以，在你多说了几句之后，我画了这些盒子。（我假装回到了大学；-）

但是，我也无法让它工作。我甚至试过圆圈

我怀疑发布的代码不是一个有效的实现（这现在是一个公开的挑战，其他人现在可以证明我错了；至少它可以让这个问题保持开放；-）

在多次尝试后，我无法使用它来反转2、3或4个元素的长度列表（尽管我已经成功地使用了中提供的[更直观的]代码）

---

我认为使用

h.next

而不是

h

作为“根”节点存在缺陷。也许作者是在解释带有虚拟节点和副作用的

void

返回？但是在这种情况下，行

h.next=t.next

似乎仍然破坏了算法。

更新我自己，以及修改挑战：

该算法确实有效，它只是以一种令人困惑的方式编写，不包括第一个节点（它仅用于副作用），这是一个。。。有问题的设计本身

重写它以避免无用的

d.next

并更好地定义

t

的范围，使我更容易（也可能）遵循：

public void reverse(Node<T> h) { // draw H under first node
  Node<T> d = null
  while (h.next != null) {
     Node<T> t = h.next;  // draw T under box at end of H arrow (remove any previous T)
     h.next = t.next;     // change arrow from H to end where arrow from box above T ends (no arrow for last element)
     t.next = d;          // draw arrow from box above T to box D is under (no arrow for first element)
     d = t;               // draw D under box (remove any previous D)
   }
   h.next = d;            // draw arrow from H to box D is under
}

public void reverse（节点h）{//在第一个节点下绘制h
节点d=null
while（h.next！=null）{
节点t=h.next；//在h箭头末尾的框下绘制t（删除之前的任何t）
h、 next=t.next；//将箭头从h改为t端上方框中的箭头（最后一个元素没有箭头）
t、 next=d；//从t上方的框中绘制箭头，到t下方的框中绘制箭头（第一个元素没有箭头）
d=t；//在方框下画d（删除之前的任何d）
}
h、 next=d；//从h向下方方框d绘制箭头
}

到箱子上去

（我建议您查看上的代码，这是相同的概念，但更容易理解，并且没有此实现的假头节点。）

---

我知道我说过“画盒子就行了”。所以，在你多说了几句之后，我画了这些盒子。（我假装回到了大学；-）

但是，我也无法让它工作。我甚至试过圆圈

我怀疑发布的代码不是一个有效的实现（这现在是一个公开的挑战，其他人现在可以证明我错了；至少它可以让这个问题保持开放；-）

在多次尝试后，我无法使用它来反转2、3或4个元素的长度列表（尽管我已经成功地使用了中提供的[更直观的]代码）

---

我认为使用

h.next

而不是

h

作为“根”节点存在缺陷。也许作者是在解释带有虚拟节点和副作用的

void

返回？但是在这种情况下，行

h.next=t.next

似乎仍然破坏了算法。

使用铅笔和纸。制作你自己的图表。画小盒子（或圆圈或小马）并用箭头将它们连接在一起。这些箭头表示“下一个”字段。然后在每一步用手移动箭头来运行上面的代码。我正在尝试，但我感到困惑。。。d和t是新节点？？主列表是h。列表正确吗？d和t最初指向哪里？请看我的评论，但d被分配了，但它似乎没有指向任何地方！对吧？嗯。你确定这是有效的代码吗？我的箱子似乎不合适。我无法让它为2、3或4的列表工作。它似乎有根本性的缺陷，应该更像是：使用铅笔和纸。制作你自己的图表。画小盒子（或圆圈或小马）并用箭头将它们连接在一起。这些箭头表示“下一个”字段。然后在每一步用手移动箭头来运行上面的代码。我正在尝试，但我感到困惑。。。d和t是新节点？？主列表是h。列表正确吗？d和t最初指向哪里？请看我的评论，但d被分配了，但它似乎没有指向任何地方！对吧？嗯。你确定我不会吗