指针的奥秘（四）：回调函数+qsort使用+qsort模拟实现冒泡排序

最新推荐文章于 2024-05-21 23:16:53 发布
最新推荐文章于 2024-05-21 23:16:53 发布
阅读量1.2k 收藏 51
点赞数 69
分类专栏： C语言 文章标签： 算法 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_76003626/article/details/138706698
版权

指针

一.回调函数是什么？

  回调函数就是一个通过函数指针调用的函数。
  如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

上一篇我们写了一个简单的计算器，如下：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("*************************\n");
	printf("**1:add***********2:sub**\n");
	printf("**3:mul***********4:div**\n");
	printf("*********0:exit**********\n");
	printf("*************************\n");

}
int main()
{
	int x = 0;
	int y = 0;
	int input = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请输入：");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			break;
		case 1:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d+%d=%d\n", x, y, ret);
			break;
		case 2:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d-%d=%d\n", x, y, ret);
			break;
		case 3:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d*%d=%d\n", x, y, ret);
			break;
		case 4:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d/%d=%d\n", x, y, ret);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

可以看到输入输出操作是冗余的，有没有办法，简化⼀些呢？只有调用函数的逻辑是有差异的，我们可以把调用的函数的地址以参数的形式传递过去，使用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实使用的就是回调函数的功能。如下：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void Calc(int(*pf)(int, int))
{
	int ret = 0;
	int x = 0;
	int y = 0;
	printf("请输入两个数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}
void menu()
{
	printf("*************************\n");
	printf("**1:add***********2:sub**\n");
	printf("**3:mul***********4:div**\n");
	printf("*********0:exit**********\n");
	printf("*************************\n");

}
int main()
{
	int x = 0;
	int y = 0;
	int input = 0; 
	do
	{
		menu();
		printf("请输入：");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			break;
		case 1:
			Calc(Add);
			break;
		case 2:
			Calc(Sub);
			break;
		case 3:
			Calc(Mul);
			break;
		case 4:
			Calc(Div);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

二.qsort函数使用

1.qsort介绍

  qsort函数是C语言中的一个库函数，头文件——stdlib.h，这个函数对任意类型的数据都能排序。

void qsort(void* base, size_t num, size_t size, int( *compare)(const void *elem1, const void *elem2);

  1. void* base：指向待排序数组的第一个元素的指针。
  2. size_t num：待排序数组中的元素个数。
  3. size_t size：待排序数组中的每个元素的大小，单位是字节。
  4. int( *compare)(const void *elem1, const void *elem2)：函数指针——传递函数的地址。

注意：int compare(const void *elem1, const void *elem2)——比较函数，需要使用qsort函数的程序员自己提供，并且有下面这些要求：
在这里插入图片描述

2.qsort排序整型数据

#include<stdio.h>
#include<stdlib.h>
//1.0测试qsort排序整形数据
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int cmp_int(const void* e1, const void* e2)
{
    //e1指向的一个数组元素，e2指向的是下一个数组元素
	/*if (*(int*)e1 > *(int*)e2)
		return 1;
	else if (*(int*)e1 < *(int*)e2)
		return -1;
	else
		return 0;*/
	return (*(int*)e1 - *(int*)e2);//想逆序改变e1与e2即可
}
void test1()
{
	int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	Print(arr, sz);
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

3.qsort排序结构体数据

  结构体成员访问操作符有两种

操作符 . 结构体变量.成员名
操作符 -> 结构体指针->成员名

int main()
{
	struct stu s = { "zhangsan",66 };
	printf("%s %d\n", s.name, s.age);

	struct stu* ps = &s;
	printf("%s %d\n", (*ps).name, (*ps).age);
	printf("%s %d\n", ps->name, ps->age);
	return 0;
}

在这里插入图片描述

1.通过结构体中的整形成员排序

#include<stdio.h>
#include<stdlib.h>
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
struct stu
{
	char name[20];
	int age;
};
//按照年龄比较，排序结构体数组
int cmp_stu_by_age(const void* e1, const void* e2)
{
	//return (*((struct stu*)e1)).age > (*((struct stu*)e2)).age;
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void test2()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//通过age排序
}
int main()
{
	test2();
	return 0;
}

在这里插入图片描述

2.通过结构体中的字符串成员排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
struct stu
{
	char name[20];
	int age;
};
//按照名字比较，排序结构体数组
int cmp_stu_by_name(const void* e1, const void* e2)
{
	//注意：强转是暂时的需要带上()
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
	//这里借助strcmp函数比较字符串，返回值恰好与函数的返回值要求相同
}
void test2()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	test2();
	return 0;
}

在这里插入图片描述

三.qsort模拟实现冒泡排序

给出简单的冒泡排序，代码如下：

void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
void BubbleSort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz);
	Print(arr, sz);
}

该函数只能排序整形元素，我们可以借助qsort函数来模拟实现冒泡排序用于排序各种类型数据。如下代码：

void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
struct stu
{
	char name[20];
	int age;
};
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	char temp;
	for (i = 0; i < width; i++)
	{
		temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}
}
void BubbleSort(void* base,size_t sz,size_t width,int(*cmp)(const void* e1,const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			//比较两个元素
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换两个元素
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
			
		}
	}
}
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
void test4()
{
	int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_int);
	Print(arr, sz);
}
int cmp_stu_by_int(const void* e1, const void* e2)
{
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void test5()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_int);
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void test6()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	//test4();
	//test5();
	test6();
	return 0;
}

在这里插入图片描述
这里的cmp_int，cmp_struct_by_age，cmp_struct_by_name就是典型的回调函数，在冒泡排序中传入函数指针，通过函数指针调用的函数就是回调函数，可以传入不同的函数指针，实现排序不同的数据。

思考：为什么使用的都是泛型指针void*呢？

  1. 由于不知道排序什么数据类型。若排序整形，用int*，那排序短整型，字符串呢？就不方便了。
  2. 泛型指针void*可以配合数组元素的个数与每个元素字节的大小，精准定位每个元素的地址，就很方便交换元素了。
  3. 交换元素由于不知道元素的类型，可以考虑交换每一个字节的内容，配合每个元素字节的大小，可以达到整体交换的效果，可谓是精彩绝伦！

指针部分到这就结束了，但是学习仍未止步！！！
创作不易，如果能帮到你的话能赏个三连吗？感谢啦！！！
在这里插入图片描述

清风~徐~来
关注
  • 69
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 57
    评论
专栏目录
c语言从入门到实战-回调函数与qsort的讲解和模拟实现
11-21
`qsort`需要三个参数：要排序的数组、数组元素的个数和一个指向回调函数的指针。回调函数必须满足两个条件：能够比较数组中的元素，返回一个整数表示它们之间的大小关系；并且它应该能够被`qsort`函数调用。
C生万物 | 一探指针函数与函数指针的奥秘
做技术人 · 产优质博客 · 找好工作
04-17 1340
一文带你真正搞懂🔥指针函数与函数指针🔥
c语言进阶之《一个超级好用的函数qsort和代码实现》
CodeApe_的博客
03-21 881
前言 欢迎大家来到我的c语言进阶系列，我们将更深入的剖析c语言的奥秘 今天来讲解一个c语言中超级好用的函数qsort以及它的模拟代码实现。 在今天内容开始之前，我们需要了解一下回调函数 回调函数 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。 可能大家现在还是比较蒙，是不是看不太懂呢
【C语言系列】从0到1的指针详解——让你看破指针的奥秘
qq_74411357的博客
11-07 606
我们首先要了解指针的概念，明白变量在内存中的存储情况。在存储的过程当中，内存被一块块的分配好，每一块都有着自己独特的编号，而这个编号就是所谓的指针，当它存放到一个变量当中时，指针变量就由此诞生。
【C语言进阶笔记】深入了解进阶指针
ljp
10-30 471
前言 指针进阶 我们在初级指针章节已经接触过了指针，我们知道了指针的概念： 1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。 2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。 3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。 4. 指针的运算。 在这里我们将继续探索指针的奥秘，掌握高级指针初识以及运用计算，本篇内容将详细介绍各种指针，内容较多，干货满满????，相信大家会收获很多！！话不多说，进入正题： 字符指针 在指
【C 语言进阶】一篇文章将你的 C 语言指针升华
吞吞吐吐大魔王的博客
07-03 2949
文章目录1. 字符指针定义用法2. 指针数组定义用法3. 数组指针定义补充注意用法4. 数组传参和指针传参一维数组二维数组一级指针二级指针小结5. 函数指针定义用法注意练习小结6. 函数指针数组定义用法7. 指向函数指针数组的指针定义用法8. 回调函数定义用法补充（qsort函数）9.总结 指针的一些基础知识我已经在【初阶指针】这章总结过了，如果大家有些地方不清楚，可以点击链接回过去看一下。【初阶指针】了解后，我们了解了指针的概念： 指针就是个变量，用来存放地址。地址可以唯一标识一块内存空间 指针的大小
那些关于前端数据结构与算法
技术杂谈
11-21 5682
本文来自作者 张振 在 GitChat 上分享「前端数据结构与算法的奥秘」，「阅读原文」查看交流实录 「文末高能」 编辑 | 嘉仔 目前前端的在互联网行业比重越来越加深,前端不仅限于网页制作，还包括移动端及其服务端的搭建。 所以对从业人员要求越来越高,如果自身不重视数据结构与算法这样基础知识，很有可能数年来从事单一的毫无成长的职业发展，只有基础牢固，算法精通的人 才能未来的
回调函数（callback）详解
Happysky_1的博客
08-05 3121
回调函数(callback)的应用，冒泡排序的模拟实现
C中qsort快速排序使用实例
01-01
代码如下:/************************************************************************qsort原型：void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *...
C语言快速排序函数用法（qsort）
01-01
本文实例为大家分享了C语言快排函数用法，供大家参考，具体内容如下 #include #include #include struct student { int id; char name[12]; char sex; }; int compare(const void* a,const void* b)//基本...
c++ qsort 与sort 对结构体排序实例代码
01-19
//qsort的比较函数 int cmp(const void * a, const void * b) { return (*(Book*)a).num > (*(Book*)b).num ? 1 : 0; } //sort的比较函数 bool cmp_(Book a, Book b) { return a.num > b.num; } int main() { ...
链接表存储图(C++注释详解): 构建表 & 深度优先遍历 (DFS)
H13420972436的博客
05-15 440
代码实现: 构建表 & 深度优先遍历 (DFS)
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 805
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
day09
2202_76101487的博客
05-17 743
正值少年的日常打卡！！！
BERT系列算法解读
qq_52053775的博客
05-19 74
从而提高模型在SQuAD、MNLI和SST-2数据集上的性能。总的来看，这些优化措施显著增强了模型的表现。
基于地理坐标的高阶几何编辑工具算法（8）——整形面
HouGISer的博客
05-19 615
整形面算法常用于快速修改一个几何面的局部形状。
【算法】前缀和——二维前缀和模板题
最新发布
2302_79031646的博客
05-21 223
用“二维前缀和模板题”来介绍二位前缀和算法模板
算法练习第22天|39. 组合总和、40.组合总和II
Brillian123的博客
05-15 829
39. 组合总和39. 组合总和 - 力扣（LeetCode）
模仿qsort的功能实现一个通用的冒泡排序
03-16
冒泡排序是一种简单的排序算法，它的基本思想是通过不断比较相邻的元素，将较大的元素向后移动，较小的元素向前移动，从而实现排序的目的。下面是一个通用的冒泡排序的实现： ```c void bubble_sort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)) { char *p = (char *)base; char *q = (char *)base + size; char *end = (char *)base + nmemb * size; for (; p < end - size; p += size) { for (q = (char *)base + size; q < end; q += size) { if (compar(p, q) > ) { char tmp[size]; memcpy(tmp, p, size); memcpy(p, q, size); memcpy(q, tmp, size); } } } } ``` 这个函数的参数和qsort的参数类似，其中： - `base`：待排序的数组的首地址； - `nmemb`：待排序的数组的元素个数； - `size`：待排序的数组的每个元素的大小； - `compar`：比较函数，用于比较两个元素的大小，它的定义和qsort的比较函数相同。 这个函数的实现和qsort的实现类似，都是通过指针操作来实现通用性。具体来说，它使用了两个指针p和q来遍历数组，每次比较相邻的两个元素，如果它们的顺序不对，则交换它们的位置。这个过程重复n-1次，直到数组中的所有元素都排好序为止。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值