进阶指针（三）--- qsort函数(快速排序)的使用和（用冒泡排序）模拟实现

已于 2023-10-02 18:00:06 修改
阅读量316 收藏 30
点赞数 40
分类专栏： 进阶C语言 文章标签： 软件工程 学习 c语言 笔记 开发语言
于 2023-09-29 23:22:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xue_bian_cheng_/article/details/133421098
版权

图片来源于网络

✨博客主页：小钱编程成长记
🎈博客专栏：进阶C语言
🎈推荐相关博文：进阶C语言（一）、进阶C语言（二）

进阶指针（三）

8.回调函数（下）

我们接着上次的回调函数开始讲解剩下的qsort部分，如果没看过的话，大家可以先看看进阶C语言（二）

8.2 qsort函数的使用

8.2.1 介绍：

回调函数的案例：qsort

  • qsort是一个库函数，头文件是stdlib.h，声明头文件后可直接使用。
  • qsort是底层使用的快速排序的方式，是对数据进行排序的。
  • qsort可以用来排序任意类型的数据。

我们可以在网站cplusplus中查询这个函数的使用方法。
来自网络截图

qsort函数，有四个参数： 
void qsort(void* base,//待排序数组的第一个元素的地址，并将其转化为void*型
			size_t num,//待排序数组的元素的个数
			size_t size,//待排序数组的一个元素的大小（单位字节）
			
			int (*compar)(const void* e1, const void* e2)
			//函数指针---compar指向了一个函数，这个函数是用来比较两个元素的; 
			//e1,e2中存放的是需要比较的两个元素的的地址
			);
compar函数: 
//举例： 
比较函数--提供整型数据的比较方法 
int compar(const void* e1, const void* e2)  
{ 		
	return *(int*)e1 - *(int*)e2;//升序排序， 	
//当结果>0（e1指向的元素位于e2之后）时，返回一个>0的数； 	 	 
//当结果==0（e1指向的元素和e2指向的元素相同），返回0；
//当结果<0（e1指向的元素位于e2之前）时，返回一个<0的数； 
}
注意重点：

1.排序整型数组，两个元素可以直接用>比较
2.排序结构体数组，两个结构体的数据可能不能直接使用>比较，
》也就是说，不同类型的数据，比较大小的方式有差异。

  • void* 是无具体类型的指针类型
  • void* 类型的指针可以存放各种类型数据的地址
  • void* 类型的指针不能解引用，也不能进行 ± 整数的操作(因为是无类型，不知道要跳过几个字节)

void* 类型的指针不能解引用，我们可以先强转为其它类型再进行±操作。
qsort并不知道它要排序的数组中元素的类型，并且不同类型数据的比较方式不同。
所以在使用qsort之前，要先给它提供要比较的类型数据的比较方法。

8.2.1 用qsort函数排序整型数组

用qsort函数排序整型数组

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

//比较函数--提供整型数据的比较方法
int int_compar(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;//升序排序，
	//当结果>0（e1指向的元素位于e2之后）时，返回一个>0的数；
	//当结果==0（e1指向的元素等于e2指向的元素）时，返回0；
	//当结果<0（e1指向的元素位于e2之前）时，返回一个<0的数；
}

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

int main()
{
	int arr[] = { 0,9,8,7,6,5,4,3,2,1 };
	size_t sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	//快速排序
	qsort(arr, sz, sizeof(arr[0]), int_compar);
	print(arr, sz);
	return 0;
}

8.2.3 用qsort函数排序结构体数组

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

//结构体
struct Stu
{
	char name[20];
	int age;
};



按年龄排序
打印函数
//void print_test1(struct Stu *s1, size_t sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%s %d ", s1[i].name, s1[i].age);
//	}
//	printf("\n");
//}
//
比较函数
//int compare_age(const void* e1, const void* e2)
//{
//	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
//}
//
//void test1()
//{
//	struct Stu s1[] = { {"zhangsan", 20},{"lisi", 12},{"wangwu", 30} };
//	size_t sz = sizeof(s1) / sizeof(s1[0]);
//
//	print_test1(s1, sz);//排序前
//	qsort(s1, sz, sizeof(s1[0]), compare_age);
//	print_test1(s1, sz);
//}



//按名字字母ASCII从小到大排序
//打印函数
void print_test2(struct Stu* s2, size_t sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d ", s2[i].name, s2[i].age);
	}
	printf("\n");
}

//比较函数
int compare_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void test2()
{
	struct Stu s2[] = { {"zhangsan", 20},{"lisi", 12},{"wangwu", 30} };
	size_t sz = sizeof(s2) / sizeof(s2[0]);

	print_test2(s2, sz);//排序前
	qsort(s2, sz, sizeof(s2[0]), compare_name);
	print_test2(s2, sz);
}

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

8.3 用冒泡排序模拟实现qsort函数的快速排序

目标： 包含回调函数，使用冒泡排序的算法，模拟实现一个排序函数(qsort)，可以排序任意类型的数据。

8.3.1 回顾冒泡排序

冒泡排序的思想： 两两相邻的元素进行比较

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

//冒泡排序
#include <stdio.h>

//冒泡排序函数
void bubble_sort(int arr[], size_t 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[], size_t sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void test()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };//降序
	size_t sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);//排序前
	
	//升序排列
	bubble_sort(arr, sz);
	print_arr(arr, sz);//排序后
}


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

8.3.2 开始模拟

通过上面对冒泡排序的回顾，我们得到冒泡排序函数的基本框架：

//冒泡排序函数
void bubble_sort(int arr[], size_t 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;
			}		
		}
	}
}
qsort函数：

在这里插入图片描述

如何模拟：

  1. 首先要给冒泡排序函数传递数组的首元素地址，
    因为我们要模仿qsort排序任意类型的数据，所以形参要能接收任意类型的地址。
    上篇文章讲了void* 类型的指针可以接收任意类型的地址，所以参数我们可以这样写bubble_sort(void *base)

  2. 想要给任意一个数组排序，都要先知道数组有几个元素，
    因为计算数组 / 元素大小的操作数sizeof的返回值是size_t类型的，
    所以参数可以写成bubble_sort(void *base, size_t num)

  3. 有了首元素地址和数组元素个数还不够，还不能知道每个元素的地址。
    站在冒泡排序函数的角度并不知道传来的是什么类型的地址，所以不能通过指针+1的方式找到下一个元素的地址，
    在这里插入图片描述
    但是我们可以将要排序数组每个元素的大小（字节）传过来，知道了一个元素有几个字节，指针跳过这几个字节就指向了下一个元素。 所以参数可以写成bubble_sort(void *base, size_t num, size_t size)

  4. 进阶指针（三）中讲过，不同类型的数据比较大小的方式可能不同， 所以要排序数据的程序员需要先给冒泡排序函数 传 数据的比较函数，冒泡排序函数用函数指针接收，所以参数可以写成 bubble_sort(void *base, size_t num, size_t size, int compar(const void *e1, const void *e2))

  5. 比较函数:
    int compar(const void *e1, const void *e2)
    因为要排序多种类型的数据，所以要用void*类型的指针接收。
    e1是一个指针，存放一个要比较元素的地址
    e2是一个指针，存放一个要比较元素的地址
    e1指向的元素 > e2指向的元素，返回 > 0的整型数字
    e1指向的元素 == e2指向的元素，返回整型数字0
    e1指向的元素 < e2指向的元素，返回 < 0的整型数字
    这也是比较函数返回类型是int的原因。

  6. 在冒泡排序函数中要调用比较函数，来判断两个元素是否需要交换，返回值>0交换。
    比较函数中的参数应该填要比较元素，那就要先找到元素的地址。
    站在冒泡排序函数的角度并不知道传来的是什么类型的地址，所以不能通过指针+1的方式找到下一个元素的地址。
    已知首元素的地址，元素的个数num，一个元素占size字节，我们可以将首元素的地址强转成char*型的，指针向后移size个字节就指向了下一个元素，（一个size个字节大小的元素的地址，在数值上==这个元素所占的第一个字节的地址）
    (char *) base + size * 1 就是下标为1的元素的地址，
    (char *)base + size * j 是下标为 j 的元素的地址,
    (char *)base + size * (j+1) 是下标为 j+1 的元素的地址。
    在这里插入图片描述

//冒泡排序函数
void bubble_sort(const void *base, size_t num, size_t size, int compar(const void *e1, const void *e2))
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < num-1; i++)
	{
		int j = 0;
		//每趟要比较的对数
		for (j = 0; j < num - 1 - i; j++)
		{
			//判断是否要交换
			if ((compar((char*)base + size*j, (char*)base + size*(j+)) > 0)
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}		
		}
	}
}
  1. 如果两个元素需要交换，因为站在冒泡排序函数的角度不知道有排序数组的类型，所以不能直接用 * 解地址将元素整个交换。（*访问的范围是类型的大小）。
    我们知道一个元素有size个字节，所以可以一个字节一个字节的交换，先创建一个字节的空间用来过渡，通过这个空间来交换。
    在这里插入图片描述
//注意：函数不能嵌套定义
//交换函数
void swap(char *buf1, char *buf2)
{
	char tmp = *buf1;
	*buf1 = *buf2;
	*buf2 = tmp;
} 

//判断是否要交换
if ((compar((char*)base + size*j, (char*)base + size*(j+)) > 0)
{
	//交换
	swap((char*)base + size*j, (char*)base + size*(j+1))
}

8.3.3 代码展示

//交换函数
void swap(char *buf1, char *buf2)
{
	char tmp = *buf1;
	*buf1 = *buf2;
	*buf2 = tmp;
} 

//冒泡排序函数---泛型编程-什么类型都支持的编程
void bubble_sort(const void *base, size_t num, size_t size, int compar(const void *e1, const void *e2))
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < num-1; i++)
	{
		int j = 0;
		//每趟要比较的对数
		for (j = 0; j < num - 1 - i; j++)
		{
			//判断是否要交换
			if ((compar((char*)base + size*j, (char*)base + size*(j+)) > 0)//此时，compar指向的函数就是回调函数
			{
				//交换
				swap((char*)base + size*j, (char*)base + size*(j+1))
			}		
		}
	}
}

8.3.4 用新的冒泡排序函数排序整型数组

#include <stdio.h>


通用冒泡函数
//交换函数
void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

//泛型编程---什么类型都支持的编程
void bubble_sort(const void* base, size_t num, size_t size, int compar(const void* e1, const void* e2))
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//通过比较判断两个元素是否需要交换
			if (compar((char*)base + size * j, (char*)base + size * (j + 1)) > 0)
			{
				//交换
				swap((char*)base + size * j, (char*)base + size * (j + 1), size);
			}
		}
	}
}



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

//比较函数
int compare_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

//主要程序
void test1()
{
	int arr[] = { 0,9,8,7,6,5,4,3,2,1 };
	size_t sz = sizeof(arr) / sizeof(arr[0]);

	print_test1(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), compare_int);
	print_test1(arr, sz);
}

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

流程图展示

在这里插入图片描述

8.3.5 用新的冒泡排序函数排序结构体数组

注意：
  • ->的优先级比 强制转换操作符 高。
  • strcmp用来比较字符串，头文件是string.h
  • 函数在使用之前要先声明，函数的定义也是一种特殊的声明
#include <stdio.h>
#include <string.h>

通用冒泡函数
//交换函数
void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

//泛型编程---什么类型都支持的编程
void bubble_sort(const void* base, size_t num, size_t size, int compar(const void* e1, const void* e2))
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < num-1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for(j=0; j<num-1-i; j++)
		{
			//通过比较判断两个元素是否需要交换
			if (compar((char*)base + size * j, (char*)base + size * (j + 1)) > 0)
			{
				//交换
				swap((char*)base + size * j, (char*)base + size * (j + 1), size);
			}
		}
	}
}





//结构体
struct Stu
{
	char name[20];
	int age;
};


按年龄比较
比较函数——给排序函数提供要排序的数据的比较方法。函数在使用之前要先声明，函数的定义也是一种特殊的声明
//int compar_age(const void* e1, const void* e2)
//{
//	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
//}
//
//
//
打印函数
//void print_test1(struct Stu* S1, size_t sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%s %d  ", S1[i].name, S1[i].age);
//	}
//	printf("\n");
//}
//
//
主要程序
//void test1()
//{
//	struct Stu S1[] = { {"zhangsan", 20},{"lisi", 12},{"wangwu", 30} };
//	size_t sz = sizeof(S1) / sizeof(S1[0]);
//
//	print_test1(S1, sz);//排序前
//
//	bubble_sort(S1, sz, sizeof(S1[0]), compare_age);//按年龄排序
//	print_test1(S1, sz);//排序后
//}




//按名字的字母大小(ASCII)从小到大排序

//打印函数
void print_test2(struct Stu* S2, size_t sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d ", S2[i].name, S2[i].age);
	}
	printf("\n");
}


//比较函数
int compare_name(const void *e1, const void *e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);//->的优先级比 强制转换操作符 高。strcmp用来比较字符串，头文件是string.h
}


//主要程序
void test2()
{
	struct Stu S2[] = { {"zhangsan", 20},{"lisi", 12},{"wangwu", 30} };
	size_t sz = sizeof(S2) / sizeof(S2[0]);

	print_test2(S2, sz);//排序前
	bubble_sort(S2, sz, sizeof(S2[0]), compare_name);//按名字排序
	print_test2(S2, sz);
}



int main()
{
	//test1();
	test2();
}

总结

本篇文章我们学习了qsort函数，如何用冒泡排序模拟qsort函数实现能够排序任意类型的数据。最后，感谢大家的阅读！大家一起进步！

点赞收藏加关注，C语言学习不迷路！
图片来源于网络

小钱编程成长记
关注
  • 40
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 32
    评论
专栏目录
c语言从入门到实战-回调函数与qsort的讲解和模拟实现
11-21
`qsort`需要三个参数：要排序的数组、数组元素的个数和一个指向回调函数的指针。回调函数必须满足两个条件：能够比较数组中的元素，返回一个整数表示它们之间的大小关系；并且它应该能够被`qsort`函数调用。
C语言qsort函数用法---使用冒泡排序实现qsort函数
L_Naive的博客
05-19 175
C语言qsort函数用法以及使用冒泡排序实现qsort函数
c语言函数指针练习---------模拟实现qsort函数
2302_77261118的博客
10-26 138
我们可以简单的理解为两个两两相邻的元素进行比较，最终排成升序或降序，以升序为例如果较前的数大于较后的数（在数组范围内） ，那进行交换以此类推。如图所示：（最后0是不需要排，在9位数拍好后0自然而然就去了第一位//模拟实现冒泡排序int i = 0;for (i = 0;i < sz;i++)//排几趟int j = 0;for (j=0;j
C语言进阶 -- 回调函数以及qsort函数的使用
ryy1999的博客
11-01 346
qsort函数。
【再识C进阶2(下)】详细介绍指针的进阶——利用冒泡排序算法模拟实现qsort函数，以及一下习题和指针笔试题
加油，考上985的研究生
09-14 1088
再来复习一下sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小；&数组名，这里的数组名表示整个数组，取出的是整个数组的地址；除此之外，所有的数组名都表示首元素的地址。
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)//基本...
《云计算全栈》-python篇：利用递归，实现快速排序
01-20
利用递归，实现快速排序 12 3.2 方案 将要排序的数据分割成独立的三部分，任意选取一个数据作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序，整个排序过程...
软件工程期末复习（8）需求的表达方法和状态转换图
S_CuRrY666的博客
05-15 426
需求分析--需求的表达方法 状态转换图
软件工程模型
最新发布
qq_55961709的博客
05-21 463
当我们谈及制作一款手机应用或电脑程序时，许多人可能会直接联想到编写代码的场景。但在这背后，其实有一套科学而系统的方法在支撑着整个创造过程，这就是“软件工程”。你或许会好奇，什么是软件工程模型？为什么要有软件工程模型？软件工程模型之所以存在，是因为它们为软件开发过程提供了结构、组织和指导原则。这些模型帮助团队高效地完成软件项目，确保软件产品的质量，并且能够适应不断变化的需求和技术环境。：软件开发模型提供了一个清晰、结构化的框架，用于指导从项目启动到交付的整个软件开发生命周期。
吉林大学软件工程1~2
sweet_Mary的博客
05-18 1344
软件开发退化修改软件出故障：无法用备用零件替换来解决，是因为设计开发过程中存在错误软件本身软件开发与维护的方法。
软件工程期末复习（10）数据字典
S_CuRrY666的博客
05-16 289
定义绝大多数复杂事物的方法，都是用被定义的事物的成分的某种组合表示这个事物，这些组成成分又由更低层的成分的组合来定义。语言的正文用基本控制结构进行分割，加工中的操作用自然语言短语来表示 其基本控制结构有三种： 简单陈述句结构；一个数据流词条应有以下几项内容： 数据流名： 说明：简要介绍作用即它产生的原因和结果；主要内容有： 加工名： 加工编号：反映该加工的层次；数据文件名： 简述：存放的是什么数据；在实际应用中，对数据流和数据元素的描述可以灵活地剪裁，数据流元素的描述也可以采用和数据流相似的方式。
软件工程期末复习（7）需求过程
S_CuRrY666的博客
05-14 754
需求过程
软考-软件工程
x2__T的博客
05-11 789
软件开发模型：指导软件开发的体系需求分析确定软件要完成的功能及非功能性要求；概要设计将需求转化为软件的模块划分，确定模块之间的调用关系；详细设计将模块进行细化，得到详细的数据结构和算法；编码根据详细设计进行代码的编写，得到可以运行的软件，并进行单元测试。
软件工程期末复习（9）数据流图
S_CuRrY666的博客
05-15 1302
结构化分析方法最初由Douglas Ross提出，由DeMarco推广，由Ward和Mellor以及后来的Hatley和Pirbhai扩充，形成了今天的结构化分析方法的框架。
软件工程期末复习（11）总体设计 设计过程/设计原理
S_CuRrY666的博客
05-17 215
软件工程 总体设计 设计过程/设计原理
软件工程与软件质量
qq_46444918的博客
05-11 255
软件没有可靠性，只有安全性。一个软件用了几十年，没有几行代码被抹掉。只是发现了新问题。所以软件都不可靠。俄乌冲突比拼的是软件算法能力。实时性高的环境下运行的程序中一个变量不能有两个用途。
FME学习之旅---day27
summer_corner的博客
05-17 197
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
模仿qsort的功能实现一个通用的冒泡排序
03-16
这个函数的实现和qsort的实现类似，都是通过指针操作来实现通用性。具体来说，它使用了两个指针p和q来遍历数组，每次比较相邻的两个元素，如果它们的顺序不对，则交换它们的位置。这个过程重复n-1次，直到数组中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值