Java 如何颠倒链表实现的顺序？

我有一个叫做LinkStrand的类，它的功能非常类似于链表。它有

toString（）

，

size（）

，

append（）

，

next（）

，和

value（）

，但不是

previous（）

方法。我试图编写代码，反转节点的顺序，以及每个节点内的字符串。为了使我自己在其他一些我必须编写的方法中变得更容易，我在构造节点时去掉了下一个节点的要求。下面是Node类的外观：

private class Node {
    public Node myNext;
    public String myData;

    Node(String value) {
        myData = value;
        //myNext = next;
    }   
}

My.reverse（）方法当前分别反转节点中的所有字符串，但不反转节点本身的顺序。副本如下：

public IDnaStrand reverse() {
    if (this == null)
        return this;
    Node prevStrand = null;
    Node thisStrand = myHead;
    String revString;
    LinkStrand val = new LinkStrand();
    while (thisStrand != null){
        Node hold = thisStrand.myNext;
        if (revSave.containsKey(thisStrand.myData)){
            revString = revSave.get(thisStrand.myData);
            val.append(revString);
            //System.out.println("Val is: " + val);
        }
        else{
            revString = reverseStr(thisStrand.myData);
            val.append(revString);
            //System.out.println("Val is: " + val);
            revSave.put(thisStrand.myData, revString);
        }
        thisStrand.myData = revString;
        thisStrand.myNext = prevStrand;
        prevStrand = thisStrand;
        thisStrand = hold;
    }
    return val;
}

我一直在试图想出某种方法来反转节点顺序，但我还是一无所获。有人知道我该怎么做吗

谢谢

创建一个新实例 循环遍历原始实例，并在位置0处插入新实例，然后返回它

另一种方法是对它进行排序，但在您的问题中看不到任何表明它当前已排序的内容。

创建一个新实例 循环遍历原始实例，并在位置0处插入新实例，然后返回它

---

另一种方法是对它进行排序，但在您的问题中看不到任何表明它当前已排序的内容。

如果允许您修改

IDnaStrand

和

LinkStrand

，请添加一个方法

前置（节点n）

。然后，在遍历列表时，只需在每个节点前面加上前缀

如果无法修改类，请将

节点以反向顺序保存到数组中（
noderray[size-1]
，
noderray[size-2]
，…），然后按顺序创建一个新的
LinkStrand
）。或者，您可以按顺序加载数组，然后按反向顺序创建
LinkStrand

例如：

thisStrand = myHead;
int size = 0;
while(thisStrand != null){
    thisStrand = thisStrand.myNext;
    size++;
}
Node[] nodeArray = new Node[size];
thisStrand = myHead;
for(int i = size-1, i < 0; i--) {
    nodeArray[i] = thisStrand;
}

如果允许修改
IDnaStrand
和
LinkStrand
，请添加一个方法
prepend（Node n）
。然后，在遍历列表时，只需在每个节点前面加上前缀

如果无法修改类，请将
节点以反向顺序保存到数组中（
noderray[size-1]
，
noderray[size-2]
，…），然后按顺序创建一个新的
LinkStrand
）。或者，您可以按顺序加载数组，然后按反向顺序创建
LinkStrand

例如：

thisStrand = myHead;
int size = 0;
while(thisStrand != null){
    thisStrand = thisStrand.myNext;
    size++;
}
Node[] nodeArray = new Node[size];
thisStrand = myHead;
for(int i = size-1, i < 0; i--) {
    nodeArray[i] = thisStrand;
}

假设您的列表如下所示：

A -> B -> C -> D -> E

我会缩短符号，因为我会写很多：

A B C D E

让我们看3个变量。我会展示他们的全部清单，这样你就可以看到发生了什么。第一项始终是存储在其中一个变量中的节点

list: null
curr: A B C D E
next: B C D E

将A的下一个指针设置为
列表
（null）的值。现在是列表的末尾

list: null
curr: A
next: B C D E

现在，转到下一步：

list: A
curr: B C D E
next: C D E

你可以看到将会发生什么。开始时继续：将
curr
的下一个指针设置为
list
：

list: B A
curr: B A
next: C D E

预付款：

list: B A
curr: C D E
next: D E

再次：

list: C B A
curr: C B A
next: D E

等等

伪代码相当简单：

list = null
curr = original_list

while next != null
    next = curr->next
    curr->next = list
    list = curr
    curr = next
end

所有这些真正要做的就是从列表的头部获取每个节点，并使其成为另一个列表的头部。这具有颠倒顺序的效果。我的回答可能有点冗长，但这就是你要做的。
假设你的列表如下所示：

A -> B -> C -> D -> E

我会缩短符号，因为我会写很多：

A B C D E

让我们看3个变量。我会展示他们的全部清单，这样你就可以看到发生了什么。第一项始终是存储在其中一个变量中的节点

list: null
curr: A B C D E
next: B C D E

将A的下一个指针设置为
列表
（null）的值。现在是列表的末尾

list: null
curr: A
next: B C D E

现在，转到下一步：

list: A
curr: B C D E
next: C D E

你可以看到将会发生什么。开始时继续：将
curr
的下一个指针设置为
list
：

list: B A
curr: B A
next: C D E

预付款：

list: B A
curr: C D E
next: D E

再次：

list: C B A
curr: C B A
next: D E

等等

伪代码相当简单：

list = null
curr = original_list

while next != null
    next = curr->next
    curr->next = list
    list = curr
    curr = next
end

所有这些真正要做的就是从列表的头部获取每个节点，并使其成为另一个列表的头部。这具有颠倒顺序的效果。我的答案可能有点冗长，但这就是你所要做的。
你的答案假设他的LinkStrand类有一个prepend（），他没有说它有。我也不知道如何编写。prepend（），因为在我的构造函数中不需要指向下一个节点的指针。@weskpga，naff解决方案是将它们放在一个临时列表中，重新排序，然后将它们转移到一个新实例或您的类，我想。您的答案是假设他的LinkStrand类有一个prepend（），他没有说它有。我也不知道如何编写。prepend（），因为在我的构造函数中不需要指向下一个节点的指针。@weskpga，naff解决方案是将它们放在临时列表中，我想，重新排序，然后将它们转移到新实例或您的类。反向实现是错误的，因为结果的最后一个元素！=最初的元素或必须在节点中实现可克隆的接口。或者调用方法“reverseAndClone（）”。反向实现是错误的，因为结果的最后一个元素！=最初的元素或必须在节点中实现可克隆的接口。或者调用方法“reverseAndClone（）”。