如何用c语言实现，通过递归算法找到一个带头节点的单链表中的最大值？

在C语言中，我们可以使用递归算法来找出单链表中的最大值。假设链表结构如下：

typedef struct ListNode {
    int val; // 节点值
    struct ListNode *next; // 指向下一个节点的指针
} ListNode;

下面是一个递归函数`findMax`，它会遍历链表并返回当前访问的最大值：

int findMax(ListNode* head) {
    // 基本情况：如果链表为空，返回INT_MIN作为初始最大值
    if (head == NULL) {
        return INT_MIN;
    }
    
    // 如果只有一个节点，返回该节点的值就是最大值
    else if (head->next == NULL) {
        return head->val;
    }

    // 递归情况：比较当前节点值与剩余部分的最大值
    else {
        int maxRest = findMax(head->next); // 递归寻找剩余部分的最大值
        return max(head->val, maxRest); // 返回当前值和剩余部分最大值中的较大者
    }
}

// 辅助函数用于比较两个整数取较大值
int max(int a, int b) {
    return a > b ? a : b;
}

相关问题

用C语言写出对于一个不带头节点的非空单链表L，设计一个递归算法返回最大值节点的地址

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* maxNode(Node* head) {
    if (head->next == NULL) { // 只有一个节点，直接返回该节点
        return head;
    }
    Node* max = maxNode(head->next); // 递归找到后面的最大节点
    return head->data > max->data ? head : max; // 返回当前节点和后面最大节点中较大的一个
}

int main() {
    Node* head = (Node*)malloc(sizeof(Node)); // 创建头节点
    head->next = NULL;
    Node* p1 = (Node*)malloc(sizeof(Node)); // 创建第一个节点
    p1->data = 1;
    head->next = p1;
    Node* p2 = (Node*)malloc(sizeof(Node)); // 创建第二个节点
    p2->data = 3;
    p1->next = p2;
    Node* p3 = (Node*)malloc(sizeof(Node)); // 创建第三个节点
    p3->data = 2;
    p2->next = p3;
    p3->next = NULL;

    Node* max = maxNode(head->next); // 获取最大节点
    printf("Max node: %d\n", max->data);

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

    return 0;
}

数据结构（C语言）算法设计：已知f为单链表的表头指针，链表中存储的都是整型数据，试写出实现下列运算的递归算法： ①求链表中的最大整数； ②求链表的结点个数；

在C语言中，你可以使用递归来实现单链表的一些基本操作。以下是针对题目中给出的两个运算的递归算法：

1. **求链表中的最大整数**（递归算法）

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

// 函数声明，递归寻找最大值
int findMax(ListNode* head) {
    // 基线条件：如果链表为空，则返回INT_MIN作为初始最大值
    if (head == NULL)
        return INT_MIN;
    
    // 递归条件：如果链表不空，比较当前节点值与剩余部分的最大值
    else {
        int maxSoFar = head->val; // 当前节点的最大值
        int remainingMax = findMax(head->next); // 递归获取剩余部分的最大值
        
        // 返回较大者
        return (maxSoFar > remainingMax) ? maxSoFar : remainingMax;
    }
}