用c语言给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

在C语言中，你可以使用迭代或递归的方式来反转单链表。这里是一个典型的迭代方法：

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL, *current = head, *next = NULL;
    
    // 当链表非空时，循环遍历
    while (current != NULL) {
        next = current->next;  // 保存当前节点的下一个节点
        current->next = prev;   // 将当前节点指向 prev，完成反转
        prev = current;         // 更新 prev 为当前节点
        current = next;         // 移动到下个节点
    }
    
    return prev;  // 返回新的头节点，即原链表的尾节点
}

这个函数接受链表的头节点作为输入，然后逐步改变节点的指针，使得它们从原来的顺序变成逆序。最后返回`prev`，它就是新链表的头节点。

相关问题

使用代码实现斐波那契数列 （2）使用递归解决二叉树的深度问题。设计一个函数，计算二叉树的最大深度。最大深度是从根节点到最远叶子节点的最长路径上的节点数量。 （3）给定一个单链表的头节点 head，请使用递归的方式反转这个链表，并返回新的头节点 用c语言

（1）使用C语言实现斐波那契数列，我们可以采用递归的方式：

#include <stdio.h>

// 递归函数计算斐波那契数列
int fibonacci(int n) {
    if (n <= 1) // 基线条件：F(0) = 0 和 F(1) = 1
        return n;
    else
        return fibonacci(n - 1) + fibonacci(n - 2); // 递归调用
}

int main() {
    int n, i;
    printf("请输入一个非负整数: ");
    scanf("%d", &n);
    printf("斐波那契数列的第 %d 项是: %d\n", n, fibonacci(n));
    return 0;
}

当你运行此程序并输入一个数字时，会得到相应位置的斐波那契数值。

（2）计算二叉树的最大深度，同样采用递归：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int maxDepth(struct TreeNode* root) {
    if (root == NULL) // 基线条件：空树的深度为0
        return 0;
    else
        return 1 + MAX(maxDepth(root->left), maxDepth(root->right)); // 递归，取左右子树深度较大者加1
}

// 注意这里MAX是一个全局的或者局部的函数，用于返回两个整数中的较大值

（3）反转单链表（头插法）的递归版本：

struct ListNode* reverseList(struct ListNode* head) {
    if (head == NULL || head->next == NULL) // 基线条件：空链表或只有一个元素的链表
        return head;
    
    // 递归部分，先将当前节点的next指向下一段链表，然后更新头节点指向当前节点
    struct ListNode* newHead = reverseList(head->next);
    head->next->next = head; // 将原头节点作为新链表的尾巴
    head->next = NULL; // 更新原头节点的next指针
    
    return newHead; // 返回新头节点
}

当调用`reverseList(head)`时，会返回反转后的链表的新头部。

用c语言给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 数据范围： 要求：空间复杂度 ，时间复杂度 。

以下是用C语言实现反转单链表的代码：

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

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

在该代码中，我们定义了一个结构体 `ListNode` 来表示单链表的每个节点，每个节点有一个整型值 `val` 和一个指向下一个节点的指针 `next`。函数 `reverseList` 用来反转整个链表，它输入链表的头节点 `head`，输出反转后的链表头节点。该函数的实现过程如下：

定义两个指针 `prev` 和 `curr`，分别指向反转后的链表头节点和当前节点。
遍历原链表，每次将当前节点 `curr` 的指针指向前一个节点 `prev`，然后将两个指针都向后移动一位。这样，反转后的链表就被构建出来了。
最后返回 `prev`，即反转后的链表头节点。

时间复杂度为 O(n)，空间复杂度为 O(1)。