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

算法如下：

1. 定义三个指针：pre、cur、next，分别指向当前结点的前一个结点、当前结点和当前结点的后一个结点。

2. 将 cur 指向头结点的下一个结点，pre 指向头结点，next 指向 cur 的下一个结点。

3. 循环遍历链表，每次将 cur 的 next 指向 pre，然后将 pre、cur、next 分别向后移动一个结点。

4. 当 cur 指向 null 时，说明链表已经遍历完毕，此时将头结点的 next 指向 pre，完成链表的逆置。

代码实现如下：

void reverseList(ListNode* head) {
    ListNode* pre = head;
    ListNode* cur = head->next;
    ListNode* next = cur->next;
    pre->next = nullptr;
    while (cur != nullptr) {
        cur->next = pre;
        pre = cur;
        cur = next;
        if (next != nullptr) {
            next = next->next;
        }
    }
    head->next = pre;
}

相关问题

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

算法步骤如下：

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. 将 cur 指向头结点的下一个节点，pre 指向头结点，next 指向 cur 的下一个节点。

3. 依次遍历链表，将 cur 的 next 指向 pre，然后将 pre、cur、next 分别向后移动一个节点。

4. 当 next 为空时，说明已经遍历完整个链表，此时将头结点的 next 指向 pre，即完成了链表的逆置。

下面是具体的代码实现：

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

注意，这里假设链表带有头结点，如果不带头结点，需要对代码进行相应的修改。