• qsort函数使用方法总结

    目录

    一、qsort函数原型

    二、compar参数

    三、各种类型的qsort排序

    1. int 数组排序 

    2. 结构体排序 

    3. 字符串指针数组排序 

    4. 字符串二维数组排序

    四、回调函数

    1. 什么是回调函数

    2. 为什么要用回调函数？

    3. 怎么使用回调函数？

    4.下面是一个四则运算的简单回调函数例子：

    五、qsort函数的模拟实现

    一、qsort函数原型

    1. void qsort( void *base,
    2.             size_t nmemb,
    3.             size_t size,
    4.             int (*compar)(const void *, const void *)
    5.           );

    头文件: 函数功能：qsort()函数的功能是对数组进行排序，数组有nmemb个元素，每个元素大小为size。 

    参数base - base指向数组的起始地址，通常该位置传入的是一个数组名 

    参数nmemb - nmemb表示该数组的元素个数 

    参数size - size表示该数组中每个元素的大小（字节数） 

    参数(*compar)(const void *, const void *) - 此为指向比较函数的函数指针，决定了排序的顺序。 

    函数返回值：无 

    注意：如果两个元素的值是相同的，那么它们的前后顺序是不确定的。也就是说qsort()是一个不稳定的排序算法。

    二、compar参数

    compar参数是qsort函数排序的核心内容，它指向一个比较两个元素的函数，注意两个形参必须是const void *型，同时在调用compar 函数（compar实质为函数指针，这里称它所指向的函数也为compar）时，传入的实参也必须转换成const void *型。在compar函数内部会将const void *型转换成实际类型，见下文。

    int compar(const void *p1, const void *p2);

    如果compar返回值小于0（< 0），那么p1所指向元素会被排在p2所指向元素的前面，如果compar返回值等于0（= 0），那么p1所指向元素与p2所指向元素的顺序不确定，如果compar返回值大于0（> 0），那么p1所指向元素会被排在p2所指向元素的后面。因此，如果想让qsort()进行从小到大（升序）排序，那么一个通用的compar函数可以写成这样： 

    1. int compare (const void * a, const void * b)
    2.  {
    3.    if ( *(MyType*)a <  *(MyType*)b ) return -1;
    4.    if ( *(MyType*)a == *(MyType*)b ) return 0;
    5.    if ( *(MyType*)a >  *(MyType*)b ) return 1;
    6.  }

    注意：你要将MyType换成实际数组元素的类型。 或者

    1. //升序排序
    2. int compare(const void* a, const void* b)
    3. {
    4. 	return (*(int*)a - *(int*)b);
    5. }
    6. //降序排列
    7. int compare(const void* a, const void* b)
    8. {
    9. 	return (*(int*)b - *(int*)a);
    10. }

    三、各种类型的qsort排序

    1. int 数组排序 

    1. #include      
    2. #include      
    3.  
    4. int values[] = { 40, 10, 100, 90, 20, 25 };
    5.  
    6. int compare(const void* a, const void* b)
    7. {
    8.     return (*(int*)a - *(int*)b);
    9. }
    10.  
    11. int main()
    12. {
    13.     int n;
    14.     qsort(values, sizeof(values) / sizeof(values[0]), sizeof(int), compare);
    15.     for (n = 0; n < sizeof(values) / sizeof(values[0]); n++)
    16.         printf("%d ", values[n]);
    17.     return 0;
    18. }

    2. 结构体排序 

    1. #include 
    2. #include
    3. // void qsort(void* base, size_t num, size_t size, int(*compare)(const void*, const void*))
    4.  
    5. typedef struct
    6. {
    7.     char name[30];   // 学生姓名
    8.     int Chinese;    // 语文成绩
    9.     int Math;        // 数学成绩  
    10.     int English;     // 英语成绩
    11. }st;
    12. int cmp(const void* a, const void* b)
    13. {
    14.     st* pa = (st*)a;
    15.     st* pb = (st*)b;
    16.     int num1 = pa->Chinese + pa->English + pa->Math;
    17.     int num2 = pb->Chinese + pb->English + pb->Math;
    18.  
    19.     //return (int)num1 - num2;   // 从小到大，
    20.     return (int)num2 - num1;   //  从大到小
    21. }
    22. int main(void)
    23. {
    24.     st students[7] = {
    25.         {"周",97,68,45},
    26.         {"吴",100,32,88},
    27.         {"郑",78,88,78},
    28.         {"王",87,90,89},
    29.         {"赵",87,77,66},
    30.         {"钱",59,68,98},
    31.         {"孙",62,73,89}
    32.     };
    33.     qsort(students, 7, sizeof(st), cmp);   // 注意区别 students 与 st
    34.  
    35.     for (int i = 0; i < 7; i++)
    36.     {
    37.         printf("%s%4d%4d%4d\t", students[i].name, students[i].Chinese, students[i].Math, students[i].English);
    38.         printf("总分：%d\n", students[i].Chinese + students[i].English + students[i].Math);
    39.     }
    40.  
    41.     system("pause");
    42.     return 0;
    43. }

    3. 字符串指针数组排序 

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int compare(const void* arg1, const void* arg2);
    6.  
    7. int main(int argc, char** argv)
    8. {
    9.     int i;
    10.  
    11.     char* arr[5] = { "i", "love", "c", "programming", "language" };
    12.  
    13.     qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(char*), compare);
    14.  
    15.     for (i = 0; i < 5; i++) {
    16.         printf("%s ", arr[i]);
    17.     }
    18.     printf("\n");
    19.  
    20. }
    21.  
    22. int compare(const void* arg1, const void* arg2) {
    23.     char* a = *(char**)arg1;
    24.     char* b = *(char**)arg2;
    25.     int result = strcmp(a, b);
    26.     if (result > 0) {
    27.         return 1;
    28.     }
    29.     else if (result < 0) {
    30.         return -1;
    31.     }
    32.     else {
    33.         return 0;
    34.     }
    35. }

    那么我们向qsort传入arr之后，qsort将arr理解为指向数组中第一个元素的指针，所以形参表中，arg1和arg2其实是指向“指向常量字符串的指针”的指针，是char**。而我们需要传给strcmp这个字符串比较函数的，是“指向字符串的指针”，是char*，所以我们将void*转换为char**，然后解引用，得到char*，赋予a和b。接下来使用strcmp对a和b进行比较。(数组名本身算一层指针，而里面的内容又是一层指针，数组存放的是指向字符串的地址) 

    4. 字符串二维数组排序

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int compare(const void* arg1, const void* arg2);
    6.  
    7. int main(int argc, char** argv)
    8. {
    9.     int i;
    10.  
    11.     char arr[5][16] = { "i", "love", "c", "programming", "language" };
    12.  
    13.     qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare);
    14.     printf("%s\n", arr[0]);
    15.     for (i = 0; i < 5; i++) {
    16.         printf("%s ", arr[i]);
    17.     }
    18.     printf("\n");
    19. }
    20.  
    21. int compare(const void* arg1, const void* arg2) 
    22. {
    23.     char* a = (char*)arg1;
    24.     char* b = (char*)arg2;
    25.     int result = strcmp(a, b);
    26.     if (result > 0) {
    27.         return 1;
    28.     }
    29.     else if (result < 0) {
    30.         return -1;
    31.     }
    32.     else {
    33.         return 0;
    34.     }
    35. }

    这里对二维数组进行排序，其实是对二维数组的第二维中存放的字符串进行排序。所以qsort(arr, sizeof(arr)/sizeof(arr[0]), sizeof(arr[0]), compare);对qsort函数的调用中，第二个参数是待排元素的个数（5个），第三个参数是待排元素的大小（16）。

    我们将arr传入qsort函数，qsort函数将arr理解为指向数组第一个元素的指针，arr的第一个元素是arr[0][0]，所以参数arg1和arg2指的是指向"a[i][0]"的指针，我们知道，a[i][0]是字符，就是char，所以arg1和arg2指的是char *。我们将void*转换为char*，赋予a和b，调用strcmp函数对a和b进行比较。

    四、回调函数

    1. 什么是回调函数

    我们先来看看百度百科是如何定义回调函数的：

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

    这段话比较长，也比较绕口。下面我通过一幅图来说明什么是回调：

    假设我们要使用一个排序函数来对数组进行排序，那么在主程序(Main program)中，我们先通过库，选择一个库排序函数(Library function)。但排序算法有很多，有冒泡排序，选择排序，快速排序，归并排序。同时，我们也可能需要对特殊的对象进行排序，比如特定的结构体等。库函数会根据我们的需要选择一种排序算法，然后调用实现该算法的函数来完成排序工作。这个被调用的排序函数就是回调函数(Callback function)。

    结合这幅图和上面对回调函数的解释，我们可以发现，要实现回调函数，最关键的一点就是要将函数的指针传递给一个函数(上图中是库函数)，然后这个函数就可以通过这个指针来调用回调函数了。注意，回调函数并不是C语言特有的，几乎任何语言都有回调函数。在C语言中，我们通过使用函数指针来实现回调函数。

    我的理解是：把一段可执行的代码像参数传递那样传给其他代码，而这段代码会在某个时刻被调用执行，这就叫做回调。

    如果代码立即被执行就称为同步回调，如果过后再执行，则称之为异步回调。

    回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

    回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

    2. 为什么要用回调函数？

    因为可以把调用者与被调用者分开，所以调用者不关心谁是被调用者。它只需知道存在一个具有特定原型和限制条件的被调用函数。

    简而言之，回调函数就是允许用户把需要调用的方法的指针作为参数传递给一个函数，以便该函数在处理相似事件的时候可以灵活的使用不同的方法。

    1. int Callback()    ///< 回调函数
    2. {
    3.     // TODO
    4.     return 0;
    5. }
    6. int main()     ///<  主函数
    7. {
    8.     // TODO
    9.     Library(Callback);  ///< 库函数通过函数指针进行回调
    10.     // TODO
    11.     return 0;
    12. }

    回调似乎只是函数间的调用，和普通函数调用没啥区别。

    但仔细看，可以发现两者之间的一个关键的不同：在回调中，主程序把回调函数像参数一样传入库函数。

    这样一来，只要我们改变传进库函数的参数，就可以实现不同的功能，这样有没有觉得很灵活？并且当库函数很复杂或者不可见的时候利用回调函数就显得十分优秀。

    3. 怎么使用回调函数？

    1. #include 
    2. int Callback_1(int a)   ///< 回调函数1
    3. {
    4.     printf("Hello, this is Callback_1: a = %d \n", a);
    5.     return 0;
    6. }
    7.  
    8. int Callback_2(int b)  ///< 回调函数2
    9. {
    10.     printf("Hello, this is Callback_2: b = %d \n", b);
    11.     return 0;
    12. }
    13.  
    14. int Callback_3(int c)   ///< 回调函数3
    15. {
    16.     printf("Hello, this is Callback_3: c = %d \n", c);
    17.     return 0;
    18. }
    19.  
    20. int Handle(int x, int (*Callback)(int)) ///< 注意这里用到的函数指针定义
    21. {
    22.     Callback(x);
    23. }
    24.  
    25. int main()
    26. {
    27.     Handle(4, Callback_1);
    28.     Handle(5, Callback_2);
    29.     Handle(6, Callback_3);
    30.     return 0;
    31. }

    看看结果：

     

    如上述代码：可以看到，Handle()函数里面的参数是一个指针，在main()函数里调用Handle()函数的时候，给它传入了函数Callback_1()  /  Callback_2()  /  Callback_3()的函数名，这时候的函数名就是对应函数的指针，也就是说，回调函数其实就是函数指针的一种用法。

    4.下面是一个四则运算的简单回调函数例子：

    1. #include 
    2. #include 
    3.  
    4. /****************************************
    5.  * 函数指针结构体
    6.  ***************************************/
    7. typedef struct _OP {
    8.     float (*p_add)(float, float);
    9.     float (*p_sub)(float, float);
    10.     float (*p_mul)(float, float);
    11.     float (*p_div)(float, float);
    12. } OP;
    13.  
    14. /****************************************
    15.  * 加减乘除函数
    16.  ***************************************/
    17. float ADD(float a, float b)
    18. {
    19.     return a + b;
    20. }
    21.  
    22. float SUB(float a, float b)
    23. {
    24.     return a - b;
    25. }
    26.  
    27. float MUL(float a, float b)
    28. {
    29.     return a * b;
    30. }
    31.  
    32. float DIV(float a, float b)
    33. {
    34.     return a / b;
    35. }
    36.  
    37. /****************************************
    38.  * 初始化函数指针
    39.  ***************************************/
    40. void init_op(OP* op)
    41. {
    42.     op->p_add = ADD;
    43.     op->p_sub = SUB;
    44.     op->p_mul = &MUL;
    45.     op->p_div = &DIV;
    46. }
    47.  
    48. /****************************************
    49.  * 库函数
    50.  ***************************************/
    51. float add_sub_mul_div(float a, float b, float (*op_func)(float, float))
    52. {
    53.     return (*op_func)(a, b);
    54. }
    55.  
    56. int main(int argc, char* argv[])
    57. {
    58.     OP* op = (OP*)malloc(sizeof(OP));
    59.     init_op(op);
    60.  
    61.     /* 直接使用函数指针调用函数 */
    62.     printf("ADD = %f, SUB = %f, MUL = %f, DIV = %f\n", (op->p_add)(1.3, 2.2), (*op->p_sub)(1.3, 2.2),
    63.         (op->p_mul)(1.3, 2.2), (*op->p_div)(1.3, 2.2));
    64.  
    65.     /* 调用回调函数 */
    66.     printf("ADD = %f, SUB = %f, MUL = %f, DIV = %f\n",
    67.         add_sub_mul_div(1.3, 2.2, ADD),
    68.         add_sub_mul_div(1.3, 2.2, SUB),
    69.         add_sub_mul_div(1.3, 2.2, MUL),
    70.         add_sub_mul_div(1.3, 2.2, DIV));
    71.  
    72.     return 0;
    73. }

    五、qsort函数的模拟实现

    使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。

    注意：这里第⼀次使用 void* 的指针，讲解 void* 的作⽤。

    1. #include 
    2.  
    3. int cmp_int(const void* p1, const void* p2)
    4. {
    5. 	return *(int*)p1 - *(int*)p2;
    6. }
    7.  
    8. void Swap(char* buf1, char* buf2, size_t width)
    9. {
    10. 	int i = 0;
    11. 	for (i = 0; i < width; i++) 
    12. 	{
    13. 		char tmp = *buf1;
    14. 		*buf1 = *buf2;
    15. 		*buf2 = tmp;
    16. 		buf1++;
    17. 		buf2++;
    18. 	}
    19. }
    20.  
    21. void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
    22. {
    23. 	int i = 0;
    24. 	//趟
    25. 	for (i = 0; i < sz - 1; i++)
    26. 	{
    27. 		//每一趟冒泡排序的过程
    28. 		int j = 0;
    29. 		for (j = 0; j < sz - 1 - i; j++)
    30. 		{
    31. 			//if (arr[j] > arr[j + 1])
    32. 			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
    33. 			{
    34. 				/*int tmp = arr[j];
    35. 				arr[j] = arr[j + 1];
    36. 				arr[j + 1] = tmp;*/
    37. 				//交换
    38. 				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
    39. 			}
    40. 		}
    41. 	}
    42. }
    43.  
    44. void print_arr(int arr[], int sz)
    45. {
    46. 	int i = 0;
    47. 	for (i = 0; i < sz; i++)
    48. 	{
    49. 		printf("%d ", arr[i]);
    50. 	}
    51. 	printf("\n");
    52. }
    53.  
    54. void test()
    55. {
    56. 	//设计和实现bubble_sort2(),这个函数能够排序任意类型的数据
    57. 	int arr[] = { 3,1,5,7,9,2,4,0,8,6 };
    58. 	int sz = sizeof(arr) / sizeof(arr[0]);
    59. 	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    60. 	print_arr(arr, sz);
    61. }
    62.  
    63. int main()
    64. {
    65. 	test();
    66. 	return 0;
    67. }
  • 相关阅读:
    快速搭建和部署ArkID构建IDaaS，实现简单的标准化用户身份体系
    华硕电脑自带壁纸位置
    AutoDL上传数据详细步骤（自己用的步骤，可能没有其他大佬用的那么高级）
    10. 用Rust手把手编写一个wmproxy(代理，内网穿透等), HTTP内网穿透支持修改头信息
    vue点击按钮收缩菜单
    探索C嘎嘎的奇妙世界:第三关---缺省参数与函数重载
    浅谈云原生Cloud Native
    如何在自己的项目中实现脚手架的命令行交互
    laravel常用辅助函数
    P2014 [CTSC1997] 选课（树形DP）
  • 原文地址：https://blog.csdn.net/Evan26/article/details/134489974