设计一个算法，将带头节点的单链表逆置

可以使用三个指针依次遍历链表，将每个节点的 next 指针指向它的前驱节点，即可实现链表的逆置。

具体的实现方式如下：

def reverse_linked_list(head):
    if head is None or head.next is None:
        return head

    prev = None
    curr = head.next
    while curr is not None:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node

    head.next = prev
    return head

其中，head 表示链表的头节点，prev 表示当前节点的前驱节点，curr 表示当前节点，next_node 表示当前节点的后继节点。

该算法的时间复杂度为 O(n)，其中 n 表示链表的长度。

相关问题

设计一个算法，将带头结点的单链表逆置

算法步骤如下：

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

2. 将p的next指针指向NULL，表示逆置后的链表的尾结点。

3. 循环遍历链表，每次将q的next指针指向p，表示将当前结点逆置。

4. 将p、q、r指针向后移动一个结点，继续遍历链表。

5. 当r指针指向NULL时，表示遍历完整个链表，逆置完成。

6. 将头结点的next指针指向q，表示逆置后的链表的头结点。

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

void reverseList(Node* 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;
}

设计一个算法，将带头结点的单链表逆置。

算法如下：

1. 定义三个指针：pre指向当前节点的前一个节点，cur指向当前节点，next指向当前节点的下一个节点。

2. 将头结点的next指针置为NULL，表示逆置后的链表的尾节点。

3. 从头结点的下一个节点开始，依次遍历链表。

4. 对于每个节点，将其next指针指向pre节点，实现逆置。

5. 更新pre、cur、next指针，继续遍历链表。

6. 遍历结束后，将头结点的next指针指向pre节点，表示逆置后的链表的头节点。

7. 返回逆置后的链表头节点。

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

ListNode* reverseList(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    ListNode* pre = NULL;
    ListNode* cur = head->next;
    ListNode* next = cur->next;
    head->next = NULL;
    while (next != NULL) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next->next;
    }
    cur->next = pre;
    head->next = cur;
    return head;
}