编写一个函数，以一个单链表头指针为参数，函数返回值为链表节点个数

假设链表节点结构体定义如下：

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

那么可以编写如下的函数来计算链表节点个数：

int countNodes(struct ListNode* head) {
    int count = 0;
    while (head) {
        count++;
        head = head->next;
    }
    return count;
}

这个函数的实现非常简单，就是从链表的头节点开始依次遍历每个节点，并计数。当遍历到链表尾部时，计数器值就是链表节点个数。

相关问题

编写一个函数，以一个单链表头指针为参数，函数返回值为链表节点个数，并输出节点个数

下面是一个用C++语言实现的单链表节点数计算函数：

#include<iostream>
using namespace std;

struct ListNode{
    int val;
    ListNode* next;
    ListNode(int x):val(x),next(NULL){}
};

int getCount(ListNode* head){
    int count = 0;
    ListNode* p = head;
    while(p != NULL){
        count++;
        p = p->next;
    }
    return count;
}

int main(){
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);

    int count = getCount(head);
    cout<<"链表节点个数为："<<count<<endl;

    return 0;
}

在上面的代码中，我们首先定义了一个链表节点结构体 `ListNode`，包括节点的值和指向下一个节点的指针。然后编写了一个函数 `getCount`，用于计算链表节点个数。在函数中，我们定义了一个计数器 `count`，并将头指针 `head` 赋值给临时指针变量 `p`。然后我们使用 `while` 循环遍历整个链表，每遍历一个节点，计数器 `count` 就加1，最终返回计数器的值。在 `main` 函数中，我们创建了一个简单的链表，并调用 `getCount` 函数进行节点数计算。

用C语言编写(2）已知f为单链表的表头指针，链表中存储的都 是整型数据，试写出实现下列运算的递归算法：①求链表中的最大整数； ②求链表的结点个数； ③求所有整数的平均值。

在C语言中，我们可以利用递归来遍历链表并执行相应的计算。这里提供三种递归函数的示例实现：

1. 求链表中的最大整数：

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

int findMax(ListNode* f) {
    // 基本情况：如果链表为空，则返回INT_MIN作为最大值
    if (f == NULL || f->next == NULL) {
        return f->val;  
    }
    
    // 递归情况：比较当前节点值和其后节点的最大值
    return MAX(f->val, findMax(f->next));
}

其中，`MAX`是一个宏定义，用于获取两个整数中的较大者。

2. 求链表的结点个数：

int countNodes(ListNode* f) {
    // 基本情况：如果链表为空，则返回0
    if (f == NULL) {
        return 0;
    }
    
    // 递归情况：当前节点加上剩余节点数量
    return 1 + countNodes(f->next);
}

3. 求所有整数的平均值（假设链表非空且所有元素都是正整数）：

double average(ListNode* f, double sum, int count) {
    // 基本情况：当遍历到链表末尾时，返回总和除以计数
    if (f->next == NULL) {
        return sum / count;
    }

    // 递归情况：累加当前节点值，增加计数，并继续递归
    return average(f->next, sum + f->val, count + 1);
}

// 初始化平均值
double calcAverage(ListNode* f) {
    return average(f, 0.0, 0); // 从0开始累加和和计数
}

每个函数都会处理链表的基本情况（空链表）以及递归调用自身以处理更深入的部分。在实际应用时，记得检查函数返回值的有效性和边界条件。