【c语言——指针详解（4）】

已于 2024-10-07 01:42:00 修改
阅读量1.1k 收藏 29
点赞数 15
文章标签： c语言 算法 排序算法
于 2024-10-06 23:25:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80475881/article/details/142732093
版权

文章目录

作者主页

一、回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数
时，被调⽤的函数就是回调函数。在上一篇文章中，我们实现计算器的第三种代码其实就是运用了回调函数。

//回调函数
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");
}

void Calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个数\n");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Calc(Add);//Add是地址，传递给函数指针Calc，Calc再去调用函数
			break;
		case 2:
			Calc(Sub);
			break;
		case 3:
			Calc(Mul);
			break;
		case 4:
			Calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

相似的代码抽象成函数：有了函数指针后，函数的调用，可以使用函数名来调用，也可以使用函数指针来调用。

二、qsort的使⽤

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件

qsort是用来排序的库函数，直接用来排序数据
底层使用的是快速排序的方式，qsort函数可以排序任意类型的数据。
排序方式有很多种，例如：
选择排序
插入排序
冒泡排序
快速排序
希尔排序
…

1、使⽤qsort函数排序整型数据

使用qsort函数前，我们先写一个冒泡排序的函数，对一组整型数据进行排序，排序为升序。

void bubble_sort(int arr[], int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟内部的两两比较
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz ; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

像这个函数只能排序整型数据，如果要排序其他类型数据的时候就无能为力了，这时就要用到qsort函数了。
接下来我们看一下qsort函数的原型：


void qsort(void* base, //指针，指向的是待排序的数组的第一个元素
           size_t num, //是base指向的待排序数组的元素个数
           size_t size,//base指向的待排序数组的元素的大小
           int(*compar)(const void*)//函数指针-指向的就是两个元素的比较函数
           )
           
void*类型的指针是无具体类型的指针，它的作用就是接收任何类型的地址。
这种类型的指针不能直接解引用，也不能+-整数的运算

qsort 函数的使用者-明确的知道要排序的是什么数据，这些数据应该如何比较，所以提供两个元素的比较函数

用qsort函数来实现一下冒泡排序：

#include<stdlib.h>//qsort函数的头文件

void print_arr(int arr[], int sz)//打印整数
{
	int i = 0;
	for (i = 0; i < sz ; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int cmp_int(const void* p1, const void* p2)//比较函数
{
	/* if (*(int*)p1 > *(int*)p2)//将void*类型的指针p1强制转换为int*类型再解引用，p1和p2就是两个要比较的元素，如9和8
	{
		return 1;
	}
	else if (*(int*)p1 == *(int*)p2)
		return 0;
	else
		return -1; */

	//简化：
		return *(int*)p1 - *(int*)p2;//想要降序就交换这两个数据
}

void test1()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);//4个参数
	print_arr(arr, sz);
}

int main()
{
	test1();
	return 0;
}

在这里插入图片描述

2、使⽤qsort排序结构数据

写一段代码私用qsort排序结构体的数据：

struct Stu
{
	char name[20];
	int age;
};

这里的两个结构体元素怎么比较大小？

  1. 按照名字比较-字符串比较–strcmp，strcmp是按照对应着字符串中的字符的ASCII码值比较的
  2. 按照年龄比较-整型比较
#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件

struct Stu 
{
    char name[20];
    int age;
};

int cmp_stu_by_age(const void* p1, const void* p2) //按年龄排序
{
    return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age; // 升序  
    // return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age; // 降序  
}

 
int cmp_stu_by_name(const void* p1, const void* p2) //按名字排序
{
    return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//强制类型转换为结构体指针
}


void print_stu_arr(struct Stu arr[], int sz) //打印结构体数据
{
    for (int i = 0; i < sz; i++) 
    {
        printf("Name: %s, Age: %d\n", arr[i].name, arr[i].age);
    }
}

void test2() 
{
    struct Stu arr[3] = { {"zhangsan", 20}, {"lisi", 35}, {"wangwu", 18} };
    int sz = sizeof(arr) / sizeof(arr[0]);
    //qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//按年龄排序
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);//按名字排序
    print_stu_arr(arr, sz);
}

int main() 
{
    test2();
    return 0;
}

三、qsort函数的模拟实现

可以使⽤回调函数，来模拟实现qsort（采⽤冒泡的⽅式），bubble—sort来模拟实现qsort,。在这之前我们先看一组代码。


void bubble_sort(int arr[], int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟内部的两两比较
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

上述代码可以用来排序整数数据。
在使用冒泡排序的情况下，假设我要改造这个函数，让他能够排序任意类型的数据，哪些地方需要改造呢？我们知道两个整型元素可以直接使用>比较，但是两个字符串，两个结构体元素是不能使用>比较的。
可以把两个元素比较的方法，封装成函数，然后把函数的地址传给排序函数。

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件

void print_arr(int arr[], int sz)//打印
{
    int i = 0;
    for ( i = 0; i < sz; i++) 
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int cmp_int(const void* p1, const void* p2) //比较函数
{
    return (*(int*)p1 - *(int*)p2); // 升序  
    // return (*(int*)p2 - *(int*)p1); // 降序  
}

void Swap(char* buf1, char* buf2, size_t width) //这是对地址的四个字节（width）一 一交换从而实现整个交换
{
    int i = 0;
    for ( i = 0; i < width; i++) 
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
{
    //趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        //一趟内部的两两比较
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            //比较arr[j]和arr[j+1]
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//改变
            {
                //交换两个元素
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

void test3() 
{
    int arr[] = { 3, 1, 7, 8, 5, 3, 4, 9, 0, 6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr, sz);
}

int main() 
{
    test3();
    return 0;
}

在这里插入图片描述

这段代码实现了一个冒泡排序算法，用于对一个整型数组进行排序，并打印排序后的结果。

  • print_arr(int arr[], int sz)：这个函数接受一个整型数组arr和数组的大小sz作为参数，并打印数组中的每个元素。
  • cmp_int(const void* p1, const void* p2)：这是一个比较函数，用于比较两个整型值。它接受两个指向void的指针（任何类型），将它们转换为指向int的指针，并返回两个整数的差值。这个函数的返回值用于确定排序的顺序（升序或降序）。
  • Swap(char* buf1, char* buf2, size_t width)：这个函数用于交换两个元素的内容。它接受两个指向char的指针（代表元素的起始地址）和一个size_t类型的值width（代表元素的宽度，以字节为单位）。然后，它逐个字节地交换两个元素的内容。注意，对于整型数组来说，这种方法不是最高效的，因为它逐个字节地处理数据，而不是直接交换整个整型值。
  • bubble_sort(void* base, size_t sz, size_t width, int (cmp)(const void p1, const void* p2))：这是冒泡排序算法的实现。它接受一个指向数组起始位置的指针base、数组的大小sz、元素的宽度width和一个比较函数cmp作为参数。算法通过多次遍历数组，比较并交换相邻的元素，直到数组完全排序。

同样这个模拟实现的冒泡排序算法也能对结构体元素进行比较：

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件

struct Stu
{
    char name[20];
    int age;
};

int cmp_stu_by_age(const void* p1, const void* p2) //按年龄排序
{
    return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age; // 升序  
    // return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age; // 降序  
}


int cmp_stu_by_name(const void* p1, const void* p2) //按名字排序
{
    return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//强制类型转换为结构体指针
}


void print_stu_arr(struct Stu arr[], int sz) //打印结构体数据
{
    for (int i = 0; i < sz; i++)
    {
        printf("Name: %s, Age: %d\n", arr[i].name, arr[i].age);
    }
}



void Swap(char* buf1, char* buf2, size_t width) //这是对地址的四个字节（width）一 一交换从而实现整个交换
{
    int i = 0;
    for ( i = 0; i < width; i++) 
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
{
    //趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        //一趟内部的两两比较
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            //比较arr[j]和arr[j+1]
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//改变
            {
                //交换两个元素
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}


void test4()
{
    struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
    //bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
    print_stu_arr(arr, sz);
}

int main() 
{
    test4();
    return 0;
}

按名字排序：
在这里插入图片描述

怀旧,
关注
C语言——链表的归并_c语言链表详解
12-21
标题“C语言——链表的归并_c语言链表详解”和描述“用c语言写链表归并”明确指出了本文的主要内容：使用C语言实现链表的归并操作，并对C语言中的链表进行详细讲解。 #### 代码解析 ##### 1. 结构体定义 ```c ...
C语言——医院挂号系统.zip
08-21
《C语言实现的医院挂号系统详解》 C语言作为计算机科学的基础编程语言，因其简洁、高效的特点，在教学和实际项目开发中都有着广泛的应用。在这个C语言的课程设计中，我们探讨了一个具体的实例——医院挂号系统。这...
C语言指针详解(经典,非常详细)
12-27
创建指针并赋值涉及到一个重要的概念——取地址符(&)。例如，如果我们有一个整型变量`int num = 10;`，我们可以用`&num`获取num的地址，并将其赋值给指针，如`int *p = &num;`。现在，`p`就指向了`num`所在的内存...
C语言指针详解——不错的文章
09-20
### C语言指针详解 #### 一、指针定义与基本类型 在C语言中，指针是一种非常重要的数据类型，它存储的是另一个变量或数据结构的内存地址。通过使用指针，我们可以更加灵活地操作内存空间，实现高效的数据处理。 -...
打印九九乘法表（全部，左上，左下，右上，右下）（C语言）
xinghuitunan的博客
11-07 933
愿我们都能成为我们想要去成为的人！但行前路，不负韶华！余生很长，不必慌张！
算法基础-链表
August的专栏
11-05 227
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 248
100种算法【Python版】第51篇——希尔排序
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 334
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 314
Leetcode 160. 相交链表
二叉树(一)
m0_74340589的博客
11-05 438
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1529
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 731
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
二分查找习题篇(上)
zoelinkailuo的博客
11-07 678
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
AI 写作（三）文本生成算法：创新与突破（3/10）
最新发布
小相探索IT世界
11-08 570
本文深入探讨了 AI 写作中的多种文本生成算法。首先介绍了生成式与判别式模型的区别与特点，包括优化准则、对观察序列的处理、训练复杂度以及支持的训练方式等方面的差异，并对比了它们在 AI 写作中的优缺点。接着详细阐述了长短期记忆网络（LSTM）在文本生成中的应用，包括技术原理与结构、实现步骤与流程以及应用示例与效果。还深入分析了 Transformer 与自注意力机制，介绍了其模型架构与组成、自注意力机制的作用以及在 AI 写作中的重要作用。
数据结构初阶排序全解
枫の大一分享
11-03 2076
排序顾名思义，就是将一组乱序的数，按从大到小或者从小到大进行排列的操作。常见的排序如下可以看到排序也是有分类的，既然有分类，那么这边给出宝子们一个思考，在最后测试的时候给出答案，思考1：排序方法这么多，哪个最好呢？最差的有什么用呢？那么废话不多说，今天的重点内容就是理解并写出一个个排序算法，现在直接上高速，带着宝子们攻破一个个排序算法！这边给出各个排序算法的声明，会在对应内容进行解释，宝子们先有个印象即可~~今天讲解了各种类型的排序算法，最常用的还是时间复杂度最小的堆排序、快排、归并排序。
水仙花求和
2301_77501988的博客
11-04 216
如果一个三位整数，等于它各位数字的立方和，则称为水仙花数，编程求100到整数N之间所有水仙花数的和。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 255
LeetCode 416. 分割等和子集
蒙特卡洛方法（MC Greedy算法例子）
edgarrr的博客
11-04 647
本文章为深度学习蒙特卡洛MC Greedy方法的代码复现，课程来自bilibili中西湖大学赵世钰老师的【强化学习的数学原理】课程。
C语言函数指针详解：概念与区别深度解析
本文主要讲解了C语言中的两个概念——指针函数和函数指针，这两个概念虽然在名称上相似，但在实际应用中有着显著的区别。首先，指针函数（type* function_name(parameters)）是指返回指针类型的函数，它在定义时，星...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值