函数题

汇总

单链表统计大写字母个数
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的头结点
}