如何仅使用两个指针来反转单链表？

Question

我想知道是否存在一些逻辑来反转仅使用两个指针的单链表。

下面是使用p、q、r三个指针来反转单链表：

struct node {
    int data;
    struct node *link;
};

void reverse() {
    struct node *p = first,
                *q = NULL,
                *r;

    while (p != NULL) {
        r = q;
        q = p;
        p = p->link;
        q->link = r;
    }
    first = q;
}

还有其他替代方案可以反转链表吗？就时间复杂度而言，反转单链表的最佳逻辑是什么？

Answer 1

您可以仅使用一个 Extra 指针简单地反转链接列表。 而做到这一点的关键是使用递归。

这是Java程序。

public class Node {
   public int data;
   public Node next;
}

public Node reverseLinkedListRecursion(Node p) {
    if (p.next == null) {
        head = p;
        q = p;
        return q;
    } else {
        reverseLinkedListRecursion(p.next);
        p.next = null;
        q.next = p;
        q = p;
        return head;
    }
}

// call this function from your main method.
 reverseLinkedListRecursion(head);

如您所见，这是一个头递归的简单示例。 我们主要有两种不同的递归。

1. 头递归：- 当递归是函数执行的第一件事时。
2. 尾递归：- 当递归是函数执行的最后一件事时。

这里程序会一直递归调用自己，直到我们的指针“p”到达最后一个节点，然后在返回堆栈帧之前，我们将头指向最后一个节点和额外的指针“q”来构建链表向后的方向。

这里堆栈帧会一直返回，直到堆栈为空。

Answer 2

这里有一个更简单的 python 版本。它确实只使用了两个指针slow & fast

def reverseList(head: ListNode) -> ListNode:

    slow = None
    fast = head
    while fast:  
        node_next = fast.next
        
        fast.next = slow
        slow = fast
            
        fast = node_next
    return slow

Answer 3

只需使用XOR linked list，它在恒定时间内“自然可逆”，只需交换第一个和最后一个（头和尾）指针。

void reverse() noexcept { std::swap(first_, last_); }

我已经上传了a working example as a project on my GitHub。

Answer 4

使用 1 个变量的解决方案（仅 p）：

typedef unsigned long AddressType;

#define A (*( AddressType* )&p )
#define B (*( AddressType* )&first->link->link )
#define C (*( AddressType* )&first->link )

/* Reversing linked list */
p = first;

while( first->link )
{
    A = A + B + C;
    B = A - B - C;
    A = A - B;
    C = A - C;
    A = A - C;
}

first = p;

Answer 5

你可以使用递归方法：

这是伪代码：

Node* reverse(Node* root)
{
    if(!root) return NULL;

    if(!(root->next)) temp = root;
    else
    {
        reverse(root->next);
        root->next->next = root;
        root->next = NULL;
    }

    return temp;
}

函数调用后，返回链表的新根[temp]。 很明显，它只使用了两个指针。

Answer 6

//with this no extra space and no extra scans but this code is reversing code but read
// in reverse direction no changes made in the linked list 
PrintInReverse(Node node)
{
   // given list is null
   if(node ==null)
       return null;
   // if list contains only one node
   if(node->next ==null)
   {
       print(node.value)
   }
   // call recursively 
   else
   {
       //while(node->next != null)// due to while loop it goes into infinite loop.use //if
       if(node->next!=NULL)
       {
           PrintInReverse(node->next)
           print(node.value)
       }
   }
}

Add comments...