重庆企业网站推广方案,金华做网站公司,网络销售适合什么人做,什么网站最好✨博客主页#xff1a;小钱编程成长记 #x1f388;博客专栏#xff1a;进阶C语言 #x1f388;推荐相关博文#xff1a;进阶C语言#xff08;一#xff09;、进阶C语言#xff08;二#xff09; 进阶指针#xff08;三#xff09; 8.回调函数#xff08;下#x… ✨博客主页小钱编程成长记 博客专栏进阶C语言 推荐相关博文进阶C语言一、进阶C语言二 进阶指针三 8.回调函数下8.2 qsort函数的使用8.2.1 介绍8.2.1 用qsort函数排序整型数组8.2.3 用qsort函数排序结构体数组 8.3 用冒泡排序模拟实现qsort函数的快速排序8.3.1 回顾冒泡排序8.3.2 开始模拟8.3.3 代码展示8.3.4 用新的冒泡排序函数排序整型数组8.3.5 用新的冒泡排序函数排序结构体数组 总结 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;//升序排序
//当结果0e1指向的元素位于e2之后时返回一个0的数
//当结果0e1指向的元素和e2指向的元素相同返回0
//当结果0e1指向的元素位于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;//升序排序//当结果0e1指向的元素位于e2之后时返回一个0的数//当结果0e1指向的元素等于e2指向的元素时返回0//当结果0e1指向的元素位于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函数 如何模拟 首先要给冒泡排序函数传递数组的首元素地址 因为我们要模仿qsort排序任意类型的数据所以形参要能接收任意类型的地址。 上篇文章讲了void* 类型的指针可以接收任意类型的地址所以参数我们可以这样写bubble_sort(void *base) 想要给任意一个数组排序都要先知道数组有几个元素 因为计算数组 / 元素大小的操作数sizeof的返回值是size_t类型的 所以参数可以写成bubble_sort(void *base, size_t num) 有了首元素地址和数组元素个数还不够还不能知道每个元素的地址。 站在冒泡排序函数的角度并不知道传来的是什么类型的地址所以不能通过指针1的方式找到下一个元素的地址 但是我们可以将要排序数组每个元素的大小字节传过来知道了一个元素有几个字节指针跳过这几个字节就指向了下一个元素。 所以参数可以写成bubble_sort(void *base, size_t num, size_t size) 进阶指针三中讲过不同类型的数据比较大小的方式可能不同 所以要排序数据的程序员需要先给冒泡排序函数 传 数据的比较函数冒泡排序函数用函数指针接收所以参数可以写成 bubble_sort(void *base, size_t num, size_t size, int compar(const void *e1, const void *e2)) 比较函数: int compar(const void *e1, const void *e2) 因为要排序多种类型的数据所以要用void*类型的指针接收。 e1是一个指针存放一个要比较元素的地址 e2是一个指针存放一个要比较元素的地址 e1指向的元素 e2指向的元素返回 0的整型数字 e1指向的元素 e2指向的元素返回整型数字0 e1指向的元素 e2指向的元素返回 0的整型数字 这也是比较函数返回类型是int的原因。 在冒泡排序函数中要调用比较函数来判断两个元素是否需要交换返回值0交换。 比较函数中的参数应该填要比较元素那就要先找到元素的地址。 站在冒泡排序函数的角度并不知道传来的是什么类型的地址所以不能通过指针1的方式找到下一个元素的地址。 已知首元素的地址元素的个数num一个元素占size字节我们可以将首元素的地址强转成char*型的指针向后移size个字节就指向了下一个元素一个size个字节大小的元素的地址在数值上这个元素所占的第一个字节的地址 (char *) base size * 1 就是下标为1的元素的地址 (char *)base size * j 是下标为 j 的元素的地址, (char *)base size * (j1) 是下标为 j1 的元素的地址。
//冒泡排序函数
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;} }}
}如果两个元素需要交换因为站在冒泡排序函数的角度不知道有排序数组的类型所以不能直接用 * 解地址将元素整个交换。*访问的范围是类型的大小。 我们知道一个元素有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*(j1))
} 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*(j1))} }}
}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(j0; jnum-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语言学习不迷路
