试写一算法，对单链表实现就地逆置c++

在C++中，对单链表进行就地逆置可以通过迭代的方式实现，以下是一个简单的算法描述：

1. 初始化三个指针，分别为`prev`（指向已逆置部分的最后一个节点），`curr`（当前节点）和`next`（下一个节点）。最初，`prev`为空，`curr`指向链表的头节点。
2. 遍历链表，对每个节点进行操作：
- 在处理当前节点`curr`之前，保存它的下一个节点`next`（使用`next = curr->next`）。
- 将当前节点的指针域反向指向前一个节点`prev`（执行`curr->next = prev`）。
- 移动指针到下一节点`curr`（`curr = next`）。
- 将`prev`移动到下一个节点，以便于下次迭代时使用（`prev = next`）。
3. 当`curr`为空时，表示已经遍历完链表，此时`prev`指向新链表的头节点。
4. 更新原链表的头指针，使其指向新的头节点`prev`。

下面是对应的C++代码示例：

#include <iostream>

// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 函数实现单链表就地逆置
void reverseLinkedList(ListNode*& head) {
    ListNode* prev = nullptr;
    ListNode* curr = head;
    ListNode* next = nullptr;

    while (curr != nullptr) {
        next = curr->next;  // 保存下一个节点
        curr->next = prev;  // 反转当前节点的指针域
        prev = curr;        // 移动prev到当前节点
        curr = next;        // 移动curr到下一个节点
    }
    head = prev;  // 更新头指针为新的头节点
}

// 用于打印链表的辅助函数
void printList(ListNode* head) {
    while (head != nullptr) {
        std::cout << head->val << " ";
        head = head->next;
    }
    std::cout << std::endl;
}

// 主函数，用于测试链表逆置功能
int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);

    std::cout << "Original list: ";
    printList(head);

    reverseLinkedList(head);

    std::cout << "Reversed list: ";
    printList(head);

    // 清理链表内存
    while (head != nullptr) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }

    return 0;
}