C语言进阶版第10课—qsort函数排序

于 2024-09-15 23:51:26 发布
阅读量389 收藏 4
点赞数 20
分类专栏： C语言 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70620792/article/details/142255086
版权

文章目录

1. 回调函数

  • 回调函数就是一个通过指针调用的函数
  • 如果将函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指的函数时，被调用的函数就是回调函数
//回调函数
#include <stdio.h>
void menu()
{
	printf("----------------------------\n");
	printf("-------1.add      2.sub-----\n");
	printf("-------3.mul      4.div-----\n");
	printf("-------     0.exit    ------\n");
	printf("----------------------------\n");
}
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 x, y;
	int ret = 0;
	printf("输入操作数>:");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	system("cls");     //清屏
	printf("ret=%d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请输入>:");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(add);
			break;
		case 2:
			calc(sub);
			break;
		case 3:
			calc(mul);
			break;
		case 4:
			calc(div);
			break;
		case 0:
			system("cls");
			printf("退出\n");
			break;
		default:
			system("cls");
			printf("输入错误\n");
			break;
		}
	} while (input);
	return 0;
}

  上述代码中的add、sub、mul、div函数就是回调函数

2. qsort排序函数（定义）

  • qsort( void* base , size_t num , size_t size, int (*compare)(const void*,const void*) )
  • qsort函数一共有四个参数，该函数可用来排任意类型的数
  • 第一个参数void* base —> base中存放的是待排序数组首元素的地址（void*表示base是无符号类型的指针，用来存储不同类型数组的地址）
  • 第二个参数size_t num —> num指待排数组元素个数（size_t为无符号整形）
  • 第三个参数size_t size —> size指待排数组中每个元素的大小（单位字节）
  • 第四个参数int (*compare)(const void*, const void*) —> 函数指针，指向一个比较函数，用const void* 类型的指针分别接收两个参数，函数返回类型int
  • 第四个参数（函数指针）的作用是用来比较数组中的两个元素的
  • 如果p1指向的元素<p2指向的元素，则返回小于0的数；
  • p1指向的元素=p2指向的元素，则返回0;
  • p1指向的元素>p2指向的元素，则返回大于0的数
  • qsort函数接收到大于0的数时，会调换两个参数的位置
  • 比较字符串时用strcmp函数
  • strcmp函数在比较两个参数时 → strcmp（int p1, int p2)
  • 如果p1 > p2 ,strcmp会返回一个大于0的数字
  • 如果p1 = p2 ,strcmp会返回0
  • 如果p1 < p2 ,strcmp会返回一个小于0的数字
  • strcmp函数接收到大于0的数时，会调换两个参数的位置

3. bubble冒泡函数

  对于冒泡函数，这里不过多赘述，忘记的可直接跳转冒泡函数

//冒泡函数
#include <stdio.h>
void bubble_arr(int* p_arr, int sz)
{
	//排序的趟数
	for (int i = 0; i < sz; i++)
	{
		//每趟对比的次数
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (p_arr[j] > p_arr[j + 1])
			{
				int tmp = p_arr[j];
				p_arr[j] = p_arr[j + 1];
				p_arr[j + 1] = tmp;
			}
		}
	}
}

void print_arr(int* p, int sz)
{
	for (int k = 0; k < sz; k++)
	{
		printf("%d ", p[k]);
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 223,45,81,999,289,5241,6666,8888,524188,250 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_arr(arr, sz);
	print_arr(arr, sz);
	return 0;
}

  那么接下来我将在冒泡函数的基础上对上述代码修改，采用qsort函数对整型数组排序.

4. qsort函数对整型数组排序

//qsort排序整型数组
#include <stdio.h>
#include <stdlib.h>
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

void print_arr(int* p, size_t sz)
{
	for (int k = 0; k < sz; k++)
	{
		printf("%d ", p[k]);
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 223,45,81,999,289,5241,6666,8888,524188,250 };
	size_t sz = sizeof(arr) / sizeof(arr[0]);
	qsort( arr , sz , sizeof(arr[0]) , cmp_int );
	print_arr(arr, sz);
	return 0;
}

在这里插入图片描述

5. qsort函数对字符指针数组排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int cmp_by_char(const void* p1, const void* p2)
{
	//p1和p2分别指向数组ch中的元素（char*类型的指针）
	//由于ch是一个char*数组，因此ch数组中的每个元素都是一个char*（指向字符的指针）
	//p1和p2实际上是char**类型的，它们分别指向ch数组中的两个char*元素
	return strcmp(*(char**)p1, *(char**)p2);//p1与p2被强制转换为char**类型
}
int main()
{
	//ch是char*类型的数组，该数组每个元素都是一个指针，分别指向两个字符串的起始地址，ch(数组名）是该指针数组的首地址
	//ch[0] ---> 指向字符串"welcome  to my world"第一个字符'w'的指针
	//ch[1] ---> 指向字符串"I am a student"第一个字符'I'的指针

	char* ch[2] = {  "welcome  to my world","I am a student"};
	size_t sz = sizeof(ch) / sizeof(ch[0]);
	printf("%p\n", ch);  //数组名，数组首元素地址
	qsort(ch, sz, sizeof(char*), cmp_by_char);//这里的ch是指向一个char*类型指针数组（即char**类型）的指针
	for (int i = 0; i < sz; i++)
	{
		printf("%s\n", ch[i]);
	}
	return 0;
}

在这里插入图片描述

6. qsort函数对结构体数组排序

//结构体排序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//创建结构体
struct Stu
{
	char name[1000];
	int age;
};
//名字排序
int cmp_Stu_s_1(const void* p1, const void* p2)
{
	//将指针p1和p2转换为结构体指针类型（struct Stu*），再解引用访问结构体成员
	return strcmp((*(struct Stu*)p1).name , (*(struct Stu*)p2).name);
	/*return strcmp(((struct Stu*)p1)->name , ((struct Stu*)p2)->name);*/
}
//年龄排序
int cmp_Stu_s_2(const void* p1, const void* p2)
{
	return (*(struct Stu*)p1).age - (*(struct Stu*)p2).age;
}

//传址打印
print_s(struct Stu* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n",p->name,(*p).age);//  (*p).age 等同 p->age
		p++;
	}
}
int main()
{
	struct Stu s[3] = { {"tangmuding",44},{"yuliang",56},{"tongwei",37} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_Stu_s_1);
	print_s(&s, sz);
	printf("----------------------\n");
	qsort(s, sz, sizeof(s[0]), cmp_Stu_s_2);
	print_s(&s, sz);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

7. 模拟实现qsort排序函数

7.1 模拟实现排序整型数组

//模拟实现qsort函数（整形数组）
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int cmp_int(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

//void Swap(void* p1, void* p2,int width)
//{
//	//逐字节交换，交换次数根据数组类型而定
//	for (int i = 0; i < width; i++)
//	{
//		char tmp = *((char*)p1 + i);
//		*((char*)p1 + i) = *((char*)p2 + i);
//		*((char*)p2 + i) = tmp;
//	}
//}
//Swap函数在传参时已经将base强转为char*类型了
void Swap(char* p1, char* p2, int width)
{
	//逐字节交换，交换次数根据数组类型长度width而定
	for (int i = 0; i < width; i++)
	{
		//p1和p2指向的是对应元素的地址（字节）
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}
void bubble(void* base, int sz, int width, int (*cmp)(const void* e1,const void* e2))
{
	//要排序的趟数
	for (int i = 0; i < sz; i++)
	{
		//每趟需要对比的次数
		for (int j = 0; j < sz - 1 - i; j++)
		{
			//base中存放的是数组首元素地址，用void*接收
			//将base转换为char*类型的指针，j*width表示一次跳过j * width个字节，找到下个元素
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换参数位置
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

void print_arr(int* p, int count)
{
	for (int k = 0; k < count; k++)
	{
		printf("%d ", p[k]);
	}
}
void test1()
{
	int arr[10] = { 22,31,45,89,378,2345,21493984,327,341,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz, sizeof(arr[0]), cmp_int);//cmp_int函数地址
	print_arr(arr,sz);
}
int main()
{
	test1();
	return 0;
}
  • 接下来我将从头理一遍代码的逻辑
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

7.2 模拟实现排序结构体数组

//模拟实现qsort函数（结构体数组）
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//创建结构体
struct Stu
{
	char name[1000];
	int age;
};
//名字排序
int cmp_Stu_s_1(const void* p1, const void* p2)
{
	/*return strcmp((*(struct Stu*)p1).name , (*(struct Stu*)p2).name);*/
	return strcmp(((struct Stu*)p1)->name , ((struct Stu*)p2)->name);
}
//年龄排序
int cmp_Stu_s_2(const void* p1, const void* p2)
{
	return (*(struct Stu*)p1).age - (*(struct Stu*)p2).age;
}

//传址打印
print_s(struct Stu* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n",p->name,(*p).age);//  (*p).age 等同 p->age
		p++;
	}
}

//Swap函数在传参时已经将base强转为char*类型了
void Swap(char* p1, char* p2, int width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}
void bubble(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{
	//要排序的趟数
	for (int i = 0; i < sz; i++)
	{
		//每趟需要对比的次数
		for (int j = 0; j < sz - 1 - i; 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 main()
{
	struct Stu s[3] = { {"tangmuding",44},{"yuliang",56},{"tongwei",37} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof(s[0]), cmp_Stu_s_1);
	print_s(&s, sz);
	printf("----------------------\n");
	bubble(s, sz, sizeof(s[0]), cmp_Stu_s_2);
	print_s(&s, sz);     //结构体打印尽量采用传址打印
	return 0;
}

8. 结构体访问

//结构体访问
#include <stdio.h>
struct s
{
	int arr[100];
	int n;
};

void set_ps(struct s* pa)
{
	//(*pa).arr[0] = -1;
	//(*pa).arr[1] = -2;
	//(*pa).n = 200;
	pa->arr[0] = -1;
	pa->arr[1] = -2;
	pa->n = 300;
}

void print(struct s* pp)
{
	printf("%d\n", pp->n);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", pp->arr[i]);
	}
	printf("\n");
}
int main()
{
	struct s ps = { {1,2,3,4,5},100 };
	set_ps(&ps);
	print(&ps);
	return 0;
}

在这里插入图片描述

小比卡丘
关注
专栏目录
【C语言】进阶版冒泡排序（qsort函数思想）
weixin_52587478的博客
10-11 692
本文包含冒牌排序、qsort函数的讲解与实例、以及用代码实现qsort功能的进阶版冒泡排序法。
【C语言】qsort()函数详解：能给万物排序的神奇函数
C/C++领域,数据结构,linux,MySQl学习者
05-16 3万+
有关qsort()函数的介绍及使用方法详解。同时仿照qsort()函数模拟实现自己的bubble_sort（）函数.
C语言-qsort函数详解
热门推荐
chuxinchangcun的博客
09-01 3万+
目录 一.qsort函数是什么 二.使用qsort排序-以升序为例 关于void*型指针： 1.整形数组排序 2.字符数组排序 3.字符指针数组排序 4.结构体数组排序 5.浮点型数组排序 三.使用冒泡排序思想模拟实现qsort函数 1.什么是冒泡排序： 2.冒泡排序代码 3.使用冒泡排序思想模拟实现qsort函数 一.qsort函数是什么 我们可以使用搜索库函数网址或者MSDN软件进行查找。 qsort()函数：快速排序的函数 -引用stdlib.h头...
C语言 快速排序——qsort函数详解
chara9885的博客
07-21 2万+
还在用冒泡排序吗！来试试万能的快速排序函数吧！
【C语言进阶篇】快排函数 qsort 详细解析
鸽芷咕的博客
07-18 1177
我们都知道冒泡排序是时间复杂度，和空间复杂的最高的因为他把所有的情况都列举出了关于复杂，今天就教大家一种新的方法不仅效率高而且任何数据类型都可以排序！还不快来学！
【C语言进阶】qsort函数详解以及它的模拟实现
春人.的博客
01-09 2664
本篇文章详细介绍了qsort函数，并且通过对普通的冒泡排序进行改造，使得其可以对任意数组进行排序
C语言qsort快速排序函数详解
Raikkonen_love的博客
09-01 966
C语言qsort快速排序函数的基本使用和模拟实现
详解c语言中的qsort函数（有图）
xy_hzz的博客
09-27 4856
根据自己的理解，详细解释了c语言的qsort函数的使用场景和原理
C语言标准库函数qsort( )——数据排序
保护小周ღ的博客
08-18 1万+
大家好！我是保护小周ღ，本期为大家带来的是深度解剖C语言标准库函数 qsort()，qsort()函数他可以对任意类型的数据排序，博主会详细解释函数使用方法，以及使用快速排序的左右指针法模拟实现函数功能，这样的排序确定不来学习一下吗？？？...
C语言中qsort函数的用法实例详解
08-28
C语言中的qsort函数是标准库中提供的一种排序算法，主要用于对数组进行排序。qsort函数的声明在stdlib.h头文件中，函数原型为： void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, ...
C语言进阶练习题
niubilitygeorge的博客
10-21 632
a表示数组首元素的地址，(int)a强制类型转换后，+1只会跳过1个字节，赋值给ptr2，如图所示ptr2指向第二个字节，由于ptr2是int*类型，解引用权限是4byte，所以从第二个字节开始往后数4byte，由于是小端存储模式，所以倒着取，结果是02 00 00 00，%x表示以16进制形式打印，且高位不要0，所以打印结果是2 00 00 00。，&a表示整个数组的地址，+1表示跳过整个数组后的地址，（int*)强制类型转换后赋值给ptr1，如上图所示ptr1指向数组末端。
C语言-怎么写一个自己的qsort函数
qq_45967533的博客
02-17 786
本篇是用冒泡排序的方法来实现qsort函数（排序函数）的功能 要写一个自己的qsort函数，我们首先要知道qsort函数的功能与使用方法 由上面的介绍我们可以知道，qsort函数的作用是用来对数组里的元素进行排序，一共有4个参数，分别是他们的作用是先把数组的地址以void*的形式传过去，然后再传入这个数组的元素个数与每个元素的大小（单位字节），最后的参数是一个函数指针，这个函数指针指向的函数的作用是要告诉程序我们数组中的元素要如何进行比较，有两个参数，p1与p2，如果p1<p2该函数返回-1.
C语言 qsort()函数详解 （笔记）
远赴人间惊鸿客的博客
12-27 740
（c语言）qsort函数
C语言蓝桥杯:语言基础
kkkkkkkok的博客
09-07 1730
、
Codeforces Round 969 (Div. 2) A-C
iwant_的博客
09-11 435
Codeforces Round 969 (Div. 2) A-C
详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
最新发布
hw_happy的博客
09-13 356
但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为 TypeScript 和 Vue 的默认导出行为在某些情况下不完全一致，特别是在与一些工具链（如 Vite、Webpack）和 TypeScript 配置一起使用时。在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有export default ，在。如果你使用的是 Vite 或 Webpack，确保它们的配置能够正确处理 Vue 文件。
C语言双向链表
2301_79840227的博客
09-11 856
2。
C/C++ let __DATE__ format to “YYYY-MM-DD“
大道之行，始于足下
09-10 191
C/C++ : Let '__DATE__' format to "YYYY-MM-DD"
c语言qsort二维数组排序
05-31
要使用qsort函数对二维数组进行排序，需要先定义一个比较函数，然后将二维数组作为参数传递给qsort函数。比较函数需要返回一个整数值，表示两个元素的大小关系，如果返回值小于0，则表示第一个元素应该排在第二个元素之前，如果返回值大于0，则表示第二个元素应该排在第一个元素之前，如果返回值等于0，则表示两个元素相等，排序时可以按照任意一维来排序。 以下是示例代码： ```c #include <stdio.h> #include <stdlib.h> #define ROWS 3 #define COLS 4 int compare(const void *a, const void *b) { const int *ia = *(const int **)a; const int *ib = *(const int **)b; return ia[0] - ib[0]; } int main() { int arr[ROWS][COLS] = {{3, 2, 1, 4}, {6, 5, 8, 7}, {9, 11, 10, 12}}; int *p[ROWS]; int i, j; for (i = 0; i < ROWS; i++) { p[i] = arr[i]; } qsort(p, ROWS, sizeof(p[0]), compare); for (i = 0; i < ROWS; i++) { for (j = 0; j < COLS; j++) { printf("%d ", p[i][j]); } printf("\n"); } return 0; } ``` 这段代码会按照二维数组的第一列进行升序排序，并输出排序后的二维数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值