试编写算法将带头结点的单链表就地逆置

算法步骤如下：

1. 定义三个指针：p、q、r，分别指向头结点、第一个结点和第二个结点。

2. 将第一个结点的 next 指针指向 NULL。

3. 将 q 指针指向第二个结点。

4. 将 r 指针指向第三个结点。

5. 依次将每个结点的 next 指针指向前一个结点，即将 q 的 next 指针指向 p，将 r 的 next 指针指向 q，以此类推。

6. 将头结点的 next 指针指向原链表的最后一个结点，即将 p 的 next 指针指向 NULL。

7. 返回头结点。

具体实现可以参考以下代码：

Node* reverseList(Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    Node *p = head, *q = head->next, *r = q->next;
    p->next = NULL;
    while (r != NULL) {
        q->next = p;
        p = q;
        q = r;
        r = r->next;
    }
    q->next = p;
    head->next = q;
    return head;
}

相关问题

试编写算法将带头结点的单链表就地逆置，所谓“就地”是指辅助空间复杂度为o(1)。

这题需要写一个算法，将带头结点的单链表就地逆置，所谓“就地”是指空间复杂度为O(1)。

解释一下“就地”是指空间复杂度为O(1)，意思是将单链表逆置后，不需要额外的空间来存储，只是修改链表上结点的指针指向。

设计算法将带头结点的单链表就地逆置

在计算机科学中，将带头结点的单链表就地逆置（In-place Reverse Linked List）是指不额外分配空间，直接通过修改原链表节点指针来达到链表逆序的效果。这里是一个常见的递归算法解决方案：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(head):
    if not head or not head.next:  # 如果链表为空或者只有一个节点，无需反转，直接返回
        return head
    
    # 将当前节点的next指向前一个节点
    prev = None
    curr = head
    while curr:
        next_temp = curr.next  # 先保存下一个节点
        curr.next = prev      # 当前节点指向prev
        prev = curr           # 预备移动到下一个位置
        curr = next_temp       # 移动到下一个节点
    return prev  # 返回新的头节点

在这个算法中，我们遍历链表的同时，每次都将当前节点的`next`指向前一个节点，直到遍历完整个链表。最后，返回`prev`作为新的头节点，因为链表的最后一个节点在反转过程中变成了新的头。