Java 迭代地反转单链表

必须为O（n）且在适当位置（空间复杂度为1）。下面的代码确实有效，但有更简单或更好的方法吗

public void invert() {
    if (this.getHead() == null)
        return;
    if (this.getHead().getNext() == null)
        return;
    //this method should reverse the order of this linked list in O(n) time
    Node<E> prevNode = this.getHead().getNext();
    Node<E> nextNode = this.getHead().getNext().getNext();
    prevNode.setNext(this.getHead());
    this.getHead().setNext(nextNode);
    nextNode = nextNode.getNext();

    while (this.getHead().getNext() != null)
    {
        this.getHead().getNext().setNext(prevNode);
        prevNode = this.getHead().getNext();
        this.getHead().setNext(nextNode);
        if (nextNode != null)
            nextNode = nextNode.getNext();
    }
    this.head = prevNode;
}

public void invert（）{
if（this.getHead（）==null）
返回；
if（this.getHead（）.getNext（）==null）
返回；
//此方法应在O（n）时间内反转此链表的顺序
节点prevNode=this.getHead（）.getNext（）；
Node nextNode=this.getHead（）.getNext（）.getNext（）；
setNext（this.getHead（））；
this.getHead（）.setNext（nextNode）；
nextNode=nextNode.getNext（）；
while（this.getHead（）.getNext（）！=null）
{
this.getHead（）.getNext（）.setNext（prevNode）；
prevNode=this.getHead（）.getNext（）；
this.getHead（）.setNext（nextNode）；
if（nextNode！=null）
nextNode=nextNode.getNext（）；
}
this.head=prevNode；
}

这个怎么样：

public void invert() {
    if (head != null) {
        for (Node<E> tail = head.getNext(); tail != null; ) {
            Node<E> nextTail = tail.getNext();
            tail.setNext(head);
            head = tail;
            tail = nextTail;
        }
    }
}

public void invert（）{
if（head！=null）{
对于（节点tail=head.getNext（）；tail！=null；）{
Node nextail=tail.getNext（）；
尾。下一个（头）；
头=尾；
尾巴=下一个尾巴；
}
}
}

这个怎么样：

public void invert() {
    if (head != null) {
        for (Node<E> tail = head.getNext(); tail != null; ) {
            Node<E> nextTail = tail.getNext();
            tail.setNext(head);
            head = tail;
            tail = nextTail;
        }
    }
}

public void invert（）{
if（head！=null）{
对于（节点tail=head.getNext（）；tail！=null；）{
Node nextail=tail.getNext（）；
尾。下一个（头）；
头=尾；
尾巴=下一个尾巴；
}
}
}

适用于LinkedList的此实现：

---

使用LinkedList的此实现：

---

使用自包含的实现，即列表由head节点表示：

public class Node<E>
{
    Node<E> next;
    E value;

    public Node(E value, Node<E> next)
    {
        this.value = value;
        this.next = next;
    }

    public Node<E> reverse()
    {
        Node<E> head = null;
        Node<E> current = this;
        while (current != null) {
            Node<E> save = current;
            current = current.next;
            save.next = head;
            head = save;
        }
        return head;
    }
}

公共类节点
{
节点下一步；
E值；
公共节点（E值，节点下一个）
{
这个值=值；
this.next=next；
}
公共节点反向（）
{
节点头=空；
节点电流=此；
while（当前！=null）{
节点保存=当前；
当前=当前。下一步；
save.next=头部；
头=保存；
}
回流头；
}
}

使用自包含的实现，即列表由头部节点表示：

public class Node<E>
{
    Node<E> next;
    E value;

    public Node(E value, Node<E> next)
    {
        this.value = value;
        this.next = next;
    }

    public Node<E> reverse()
    {
        Node<E> head = null;
        Node<E> current = this;
        while (current != null) {
            Node<E> save = current;
            current = current.next;
            save.next = head;
            head = save;
        }
        return head;
    }
}

公共类节点
{
节点下一步；
E值；
公共节点（E值，节点下一个）
{
这个值=值；
this.next=next；
}
公共节点反向（）
{
节点头=空；
节点电流=此；
while（当前！=null）{
节点保存=当前；
当前=当前。下一步；
save.next=头部；
头=保存；
}
回流头；
}
}

编辑以删除每次迭代的额外比较：

    public void invert() {
        Node<E> prev = null, next = null;;
        if (head == null) return;
        while (true) {
            next = head.getNext();
            head.setNext(prev);
            prev = head;
            if (next == null) return;
            head = next;
        }
    }

public void invert（）{
节点prev=null，next=null；；
if（head==null）返回；
while（true）{
next=head.getNext（）；
标题：设置下一个（上一个）；
prev=头部；
if（next==null）返回；
头=下一个；
}
}

编辑以删除每次迭代的额外比较：

    public void invert() {
        Node<E> prev = null, next = null;;
        if (head == null) return;
        while (true) {
            next = head.getNext();
            head.setNext(prev);
            prev = head;
            if (next == null) return;
            head = next;
        }
    }

public void invert（）{
节点prev=null，next=null；；
if（head==null）返回；
while（true）{
next=head.getNext（）；
标题：设置下一个（上一个）；
prev=头部；
if（next==null）返回；
头=下一个；
}
}

公共无效反转（）{
if（first==null）返回；
Node prev=null；
for（Node next=first.next；next！=null；next=first.next）{
first.next=prev；
prev=第一；
第一个=下一个；
}  
first.next=prev；
}

公共无效反转（）{
if（first==null）返回；
Node prev=null；
for（Node next=first.next；next！=null；next=first.next）{
first.next=prev；
prev=第一；
第一个=下一个；
}  
first.next=prev；
}

修改节点类

可以重写节点类中的toString方法来输入任何数据

公共类节点{
公共节点；
私有int数据；
节点（int数据）{
这个数据=数据；
}
@凌驾
公共字符串toString（）{
返回此。数据+“”；
}

修改节点类

可以重写节点类中的toString方法来输入任何数据

公共类节点{
公共节点；
私有int数据；
节点（int数据）{
这个数据=数据；
}
@凌驾
公共字符串toString（）{
返回此。数据+“”；
}

处理头节点为空，并泛化所有其他情况。LN2上的第二个

；

是否具有任何意义？处理头节点为空，并泛化所有其他情况。LN2上的第二个

；

是否具有任何意义？如果目的是返回指向反向列表头的指针，您只需在最末尾返回

previous

。您实际上不需要在每次迭代时首先维护

first

，对吗？如果目的是返回指向反向列表头的指针，您只需在最末尾返回

previous

。