写算法，借助于栈将一个单链表逆置。请使用C语言写出。

以下是使用栈将单链表逆置的C语言代码：

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

// 定义单链表结构体
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

// 定义栈结构体
typedef struct Stack {
    ListNode* top;
} Stack;

// 初始化栈
Stack* initStack() {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stack->top = NULL;
    return stack;
}

// 判断栈是否为空
int isEmpty(Stack* stack) {
    return stack->top == NULL;
}

// 入栈
void push(Stack* stack, ListNode* node) {
    node->next = stack->top;
    stack->top = node;
}

// 出栈
ListNode* pop(Stack* stack) {
    if (isEmpty(stack)) {
        return NULL;
    }
    ListNode* node = stack->top;
    stack->top = stack->top->next;
    return node;
}

// 将单链表逆置
ListNode* reverseList(ListNode* head) {
    Stack* stack = initStack();
    ListNode* p = head;
    while (p) {
        push(stack, p);
        p = p->next;
    }
    ListNode* newHead = pop(stack);
    p = newHead;
    while (!isEmpty(stack)) {
        p->next = pop(stack);
        p = p->next;
    }
    p->next = NULL;
    return newHead;
}

// 打印单链表
void printList(ListNode* head) {
    ListNode* p = head;
    while (p) {
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n");
}

int main() {
    // 构造一个单链表
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->val = 1;
    ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
    p1->val = 2;
    ListNode* p2 = (ListNode*)malloc(sizeof(ListNode));
    p2->val = 3;
    ListNode* p3 = (ListNode*)malloc(sizeof(ListNode));
    p3->val = 4;
    head->next = p1;
    p1->next = p2;
    p2->next = p3;
    p3->next = NULL;

    printf("原始单链表：\n");
    printList(head);

    ListNode* newHead = reverseList(head);

    printf("逆置后的单链表：\n");
    printList(newHead);

    return 0;
}

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