请用C语言设计一个简单的算法，实现单链表反转

好的，以下是用 C 语言实现单链表反转的算法：

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *pre = NULL, *cur = head, *next = head ? head->next : NULL;
    while (cur) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next ? next->next : NULL;
    }
    return pre;
}

其中，结构体 ListNode 表示单链表的节点，包含一个整型变量 val 和一个指向下一个节点的指针 next。

算法的实现与上面的 C++ 代码类似，使用三个指针 pre、cur、next 遍历链表，并将 cur 的 next 指针指向 pre，然后依次向后移动 pre、cur、next 指针，直到 cur 指向 NULL。最后返回 pre，即为反转后的链表头节点。

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

相关问题

请用C语言设计一个非常简单的算法，实现单链表反转

以下是一个更简单的C语言实现单链表反转的算法：

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

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* reverseList(ListNode* head) {
    ListNode *prev = NULL, *curr = head;
    while (curr != NULL) {
        ListNode *next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

int main() {
    ListNode *head = (ListNode*)malloc(sizeof(ListNode));
    head->val = 1;
    head->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->val = 2;
    head->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->val = 3;
    head->next->next->next = NULL;
    
    printf("Original list: ");
    ListNode *curr = head;
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");

    head = reverseList(head);
    
    printf("Reversed list: ");
    curr = head;
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");
    
    return 0;
}

该算法与之前的算法类似，但是省去了一个指针变量，直接在while循环内部定义了一个指向下一个节点的指针变量next。这样可以使代码更加简洁。

请用C语言设计一个简单的算法，实现单链表反转（一定要简单！！！）

以下是一个简单的C语言实现单链表反转的算法：

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

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* reverseList(ListNode* head) {
    ListNode *prev = NULL, *curr = head, *next = NULL;
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

int main() {
    ListNode *head = (ListNode*)malloc(sizeof(ListNode));
    head->val = 1;
    head->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->val = 2;
    head->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->val = 3;
    head->next->next->next = NULL;
    
    printf("Original list: ");
    ListNode *curr = head;
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");

    head = reverseList(head);
    
    printf("Reversed list: ");
    curr = head;
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");
    
    return 0;
}

该算法使用三个指针prev、curr和next，分别指向反转后的链表头部、当前节点和下一个节点。在遍历链表的过程中，将当前节点的next指针指向prev，然后将prev指针移动到当前节点，将curr指针移动到下一个节点。最后返回prev指针，即为反转后的链表头部。