函数题

汇总

单链表统计大写字母个数
int CharacterCount(LinkList L) {
int count = 0; // 初始化计数器count为0
L = L->next; // 将链表头节点跳过，指向第一个实际节点
while (L != NULL) { // 进入循环，遍历链表直到链表末尾
count += (L->data >= 'A' && L->data <= 'Z') ? 1 : 0; // 如果当前节点的数据是大写字母，则计数器count加1，否则加0
L = L->next; // 将指针L指向下一个节点
}
return count; // 返回大写字母的个数
}

逆置链表
void reverseList(LinkList &La) {
LNode *prev = NULL, *current = La.head->next, *next; // 声明三个指针变量：prev、current、next，分别用于指向前一个节点、当前节点和下一个节点
while (current != NULL) { // 当前节点不为空时执行循环，即遍历链表
next = current->next; // 将next指针指向当前节点的下一个节点，保存下一个节点的地址
current->next = prev; // 将当前节点的next指针指向前一个节点，即将链表反转
prev = current; // 将prev指针指向当前节点，更新prev为当前节点
current = next; // 将current指针指向下一个节点，继续遍历链表
}
La.head->next = prev; // 将头节点的next指针指向反转后的链表的第一个节点，完成链表反转
}

求一组数中的最大值、最小值和平均值
float fun(int a[], int n, int *max, int *min) {
float sum = 0; // 初始化求和变量sum为0
*max = *min = a[0]; // 将max和min指针指向的值都设为数组a的第一个元素
for (int i = 0; i < n; i++) { // 遍历数组a
if (a[i] > *max) // 如果当前元素大于max指针指向的值，则更新max的值为当前元素的值
*max = a[i];
if (a[i] < *min) // 如果当前元素小于min指针指向的值，则更新min的值为当前元素的值
*min = a[i];
sum += a[i]; // 累加求和
}
return sum / n; // 返回数组元素的平均值
}

从尾到头输出单链表
void printListFromTail2Head(LinkNode* head) {
if (head != NULL) { // 如果头节点不为空
printListFromTail2Head(head->next); // 递归调用函数，传入头节点的下一个节点
printf("%d ", head->data); // 打印当前节点的数据
}
}

统计单链表的数据元素结点个数并输出最大最小值
int getListLen(LinkList h, DataType* min, DataType* max)
{
PNode p = h->next; // 声明并初始化指向链表头节点的指针p，指向第一个节点的指针
int len = 0; // 初始化链表长度为0
*min = p->data; // 将min指针指向的值设为链表第一个节点的值
*max = p->data; // 将max指针指向的值设为链表第一个节点的值
while (p != NULL) { // 遍历链表
len++; // 累加链表长度
if (p->data < *min) { // 如果当前节点的值小于min指针指向的值，则更新min的值为当前节点的值
*min = p->data;
}
if (p->data > *max) { // 如果当前节点的值大于max指针指向的值，则更新max的值为当前节点的值
*max = p->data;
}
p = p->next; // 将指针p指向下一个节点，继续遍历链表
}
return len; // 返回链表的长度
}

单链表统计奇数个数
int OddNumber(LinkList L) {
LinkList p = L->next; // 声明并初始化指向链表第一个节点的指针p
int count = 0; // 初始化奇数元素计数器为0
while (p != NULL) { // 遍历链表
if (p->data % 2 != 0) { // 判断当前节点的数据是否为奇数
count++; // 如果是奇数，计数器加1
}
p = p->next; // 指针p指向下一个节点，继续遍历链表
}
return count; // 返回奇数元素的个数
}

有序单链表去重
LNode* DelR(LNode* h) {
LNode* newH = NULL; // 新链表头节点指针
LNode* newTail = NULL; // 新链表尾节点指针
LNode* p = h; // 指向当前节点的指针p
LNode* q; // 指向下一个节点的指针q
LNode* dup; // 保存需要删除的重复节点

while (p != NULL) { // 遍历链表
q = p->next; // 指针q指向下一个节点

if (q == NULL || p->data != q->data) { // 如果p节点和q节点的值不同，或者q节点为NULL，说明p节点没有重复
p = q; // 将指针p指向下一个节点，继续判断
continue;
}

dup = q; // 如果p节点和q节点的值相同，将q节点保存到dup指针中
p->next = q->next; // 将p节点的next指针指向q节点的下一个节点，跳过重复节点

if (newH == NULL) { // 如果新链表为空，将dup节点设置为新链表的头尾节点
newH = dup;
newTail = dup;
} else { // 如果新链表不为空，将dup节点添加到链表末尾
newTail->next = dup;
newTail = dup;
}

q = p->next; // 将指针q指向下一个节点，继续判断
}

return newH; // 返回新链表的头节点指针
}

合并链表
void mergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {
LNode *pa = La.head->next; // 指向链表La的第一个节点
LNode *pb = Lb.head->next; // 指向链表Lb的第一个节点
LNode *pc = Lc.head = La.head; // 指向链表Lc的头节点，同时将Lc的头节点指向La的头节点
while (pa && pb) { // 当pa和pb都不为空时执行循环
if (pa->data < pb->data) { // 如果节点pa的值小于节点pb的值
pc->next = pa; // 将pc的next指针指向pa
pc = pa; // 将pc指向pa
pa = pa->next; // 将pa指向下一个节点
} else if (pa->data > pb->data) { // 如果节点pa的值大于节点pb的值
pc->next = pb; // 将pc的next指针指向pb
pc = pb; // 将pc指向pb
pb = pb->next; // 将pb指向下一个节点
} else { // 如果节点pa的值等于节点pb的值
pc->next = pa; // 将pc的next指针指向pa
pc = pa; // 将pc指向pa
pa = pa->next; // 将pa指向下一个节点
LNode *temp = pb; // 保存pb节点的地址到temp
pb = pb->next; // 将pb指向下一个节点
delete temp; // 删除temp指向的节点，即删除重复节点
}
}
pc->next = pa ? pa : pb; // 将剩余的节点连接到pc的next指针上
delete Lb.head; // 删除Lb的头节点
}

6-1 单链表统计大写字母个数

int CharacterCount(LinkList L) {
int count = 0;
LNode* p = L->next;
while (p != NULL) {
if (p->data >= 'A' && p->data <= 'Z') {
count++;
}
p = p->next;
}
return count;
}

6-2 逆置链表

void reverseList(LinkList La) {
if (La.head == NULL || La.head->next == NULL) {
return;
}

LNode *prev = NULL;
LNode *curr = La.head->next;
while (curr) {
LNode *next_node = curr->next;
curr->next = prev;
prev = curr;
curr = next_node;
}

La.head->next = prev;
}

6-3 求一组数中的最大值、最小值和平均值

float fun(int a[],int n,int *max,int min)
{
float sum=0;
max=min=a[0];
for(int i=0;i<n;i++)
{
if(a[i]>max)
max=a[i];
if(a[i]<min)
*min=a[i];
sum+=a[i];
}
return sum/n;
}

6-4 从尾到头输出单链表

void printListFromTail2Head(LinkNode* head) {
if (head != NULL) {
printListFromTail2Head(head->next);
printf("%d ", head->data);
}
}

6-5 统计单链表的数据元素结点个数并输出最大最小值【可本地编译器调试】

int getListLen(LinkList h, DataType* min, DataType* max)
{
if (h->next == NULL) {
*min = *max = 0;
return 0;
}
PNode p = h->next;
int len = 0;
*min = p->data;
*max = p->data;
while (p != NULL) {
len++;
if (p->data < *min) {
*min = p->data;
}
if (p->data > *max) {
*max = p->data;
}
p = p->next;
}
return len;
}

6-6 单链表统计奇数个数

int OddNumber(LinkList L)
{
int count = 0;
LNode* p = L->next;
while (p)
{
if (p->data % 2 != 0)
{
count++;
}
p = p->next;
}
return count;
}

6-7 有序单链表去重

LNode* DelR(LNode *h){
if(h == NULL) return NULL;//一定要有这步,判断是否为空,有测试点设置
LNode *p1 = h, *p2 = h->next;
LNode *head, tail, p;
head = (struct node) malloc(sizeof(struct node));
head->next = NULL;
tail = head;
while(p2){
if(p2->data == p1->data){
//插入新链表
p = (struct node) malloc(sizeof(struct node));
p->data = p2->data;
tail->next = p;
tail = p;

//删除
p1->next = p2->next;
free(p2);
}else p1 = p2;
p2 = p1->next;
}
tail->next = NULL;
return head->next;
}

6-8 合并链表

void mergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {
LNode *pa = La.head->next;
LNode *pb = Lb.head->next;
LNode *pc = Lc.head = La.head; // 将Lc的头结点指向La的头结点
while (pa && pb) {
if (pa->data < pb->data) { // 如果pa的数据小于pb的数据
pc->next = pa;
pc = pa;
pa = pa->next;
} else if (pa->data > pb->data) { // 如果pa的数据大于pb的数据
pc->next = pb;
pc = pb;
pb = pb->next;
} else { // 如果pa和pb的数据相等，则只取一个节点，跳过另一个节点
pc->next = pa;
pc = pa;
pa = pa->next;
LNode *temp = pb;
pb = pb->next;
delete temp; // 释放重复节点的内存
}
}
pc->next = pa ? pa : pb; // 将剩余的节点接在合并后的链表末尾
delete Lb.head; // 释放Lb的头结点
}