请编程实现带头结点的单链表逆序问题（要求空间复杂度为O(1)）

要实现带头结点的单链表逆序，并且要求空间复杂度为O(1)，可以采用三指针法，也就是对链表进行原地逆序。具体操作步骤如下：

1. 初始化三个指针：`prev`（前指针），`curr`（当前指针，初始指向头结点的下一个节点，即链表的第一个实际存储数据的节点），`next`（后指针，用于临时保存`curr`的下一个节点）。
2. 遍历链表，对每个节点进行逆序操作：
- 在当前节点的逆序操作中，首先保存`curr`的下一个节点到`next`。
- 将`curr`的`next`指针指向前一个节点`prev`。
- 将`prev`指针移动到`curr`位置，即`prev` = `curr`。
- 将`curr`指针移动到`next`位置，即`curr` = `next`。
3. 当`curr`指针移动到链表尾部（即`curr`为空指针时），表示整个链表已经逆序完成，此时`prev`指针指向新的头结点（即原链表的尾节点）。

以下是使用C语言实现该算法的示例代码：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建一个新的节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode) {
        newNode->data = data;
        newNode->next = NULL;
    }
    return newNode;
}

// 向链表尾部添加节点
void appendNode(Node* head, int data) {
    Node* newNode = createNode(data);
    Node* curr = head;
    while (curr->next) {
        curr = curr->next;
    }
    curr->next = newNode;
}

// 打印链表
void printList(Node* head) {
    Node* curr = head->next; // 跳过头结点
    while (curr) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

// 单链表逆序函数
void reverseList(Node* head) {
    Node* prev = NULL;
    Node* curr = head->next; // 当前节点指向头结点的下一个节点
    Node* next = NULL;
    while (curr) {
        next = curr->next; // 保存下一个节点
        curr->next = prev; // 反转当前节点的指针
        prev = curr;       // 前指针移动到当前节点
        curr = next;       // 当前节点移动到下一个节点
    }
    head->next = prev; // 将头结点的next指向前一个节点，完成逆序
}

int main() {
    Node* head = createNode(0); // 创建带头结点的链表
    appendNode(head, 1);
    appendNode(head, 2);
    appendNode(head, 3);
    appendNode(head, 4);

    printf("原始链表: ");
    printList(head);

    reverseList(head);

    printf("逆序后的链表: ");
    printList(head);

    // 释放链表内存
    Node* temp;
    while (head) {
        temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}