回调函数qsort

回调函数概念

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

qsort 函数的特点：

1. 快速排序的方法 quick
2. 适用于任意类型数据的排序

qsort函数

qsort函数有四个参数

void qsort (
void * base, ------指向数组中要排序的第一个对象的指针，转换为void。
size_t num, ------base指向的数组中元素的个数。Size_t是一个无符号整型。
size_t size, ------数组中每个元素的字节大小。Size_t是一个无符号整型。
int ( * compar)(const void * ,const void * )----指向比较两个元素的函数的指针
);*

compar：

1. 这个函数被qsort反复调用以比较两个元素。应遵循以下原型:
   Int (const void* p1, const void* p2);
2. 以两个指针作为参数(都转换为const void*)。该函数通过返回(以稳定和传递的方式)来定义元素的顺序:
   p1 < p2 -----> 返回 <0 的数
   p1 = p2 -----> 返回 0
   p1 > p2 -----> 返回 >0 的数

目的：

对数组元素进行排序
按base对数组的num个元素进行排序，每个元素的长度（size）为字节大小，使用比较函数（compar）确定顺序。

qsort函数的头文件为（#include<stdlib.h>）

演示qsort函数的使用代码

void * 类型的指针不能直接解引用操作，也不能直接进行指针运算
void * 的指针 - 无具体类型的指针，可以接收任意类型的地址

#include<stdlib.h>
#include <stdio.h>
//void qsort(void* base, //指向了需要排序的数组的第一个元素
//		     size_t num,   //排序的元素个数
//		     size_t size,  //一个元素的大小，单位是字节
//		     int (*compar)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数，能够比较base指向数组中的两个元素
//		    );
int int_cmp(const void* p1, const void* p2)
{
	//将p1强制类型转换为(int*)再解引用
	return (*(int*)p1 - *(int*)p2);//升序
	//return (*(int*)p2 - *(int*)p1);//降序
}
void Pint(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//默认升序
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	Pint(arr, sz);
	return 0;
}

打印结果为：

字母比较不能相减，用strcmp函数进行比较
strcmp函数的头文件为 ------> #include<string.h>

#include<stdlib.h>
#include <stdio.h>
#include<string.h>//strcmp函数的头文件
//测试qsort排序结构体数据 - 名字
struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
int main()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",36}, {"wangwu",28} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_name);
	struct Stu* p;
	for (p = arr; p < arr + sz; p++)
	{
		printf("%s %d\n", p->name, p->age);
	}
	return 0;
}

打印结果为：

使用冒泡排序的方式实现qsort代码

一般冒泡排序（点击可跳转）的使用

冒泡排序与qsort的不同处

问题	解决方法
参数只能接收整型数组	使用void*的指针，同时传num和size
对于不同类型的数据，不能简单使用>/</==比较	将两个元素的比较方法，以函数参数的方式传递

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

struct Stu
{
	char name[20];
	int age;
};
//交换
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
	int i = 0;
	char tmp = 0;
	for (i = 0; i < size; i++)
	{
		tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
//bubble_sort运行根据qsore函数
//void qsort(void* base, //指向了需要排序的数组的第一个元素
//		     size_t num,   //排序的元素个数
//		     size_t size,  //一个元素的大小，单位是字节
//		     int (*compar)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数，能够比较base指向数组中的两个元素
//		    );
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//一趟内部比较的对数
		for (j = 0; j < num - i - 1; j++)
		{
			//升序cmp>0,交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//两个元素比较，需要将arr[j],arr[j+1]的地址传给cmp
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
//测试排序整型数据
int int_cmp(const void* p1, const void* p2)
{
	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]);
	//默认升序
	bubble_sort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//测试排序结构体数据 - name
int cmp_stu_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void test2()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",36}, {"wangwu",28} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_name);
	printf("----------------按名字排序----------------\n");
	struct Stu* p;
	for (p = arr; p < arr + sz; p++)
	{
		printf("%s %d\n", p->name, p->age);
	}
}
//测试排序结构体数据 - age
int cmp_stu_age(const void* p1, const void* p2)
{
	return (((struct Stu*)p1)->age - ((struct Stu*)p2)->age);
}
void test3()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",36}, {"wangwu",28} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_age);
	printf("----------------按年龄排序----------------\n");
	struct Stu* p;
	for (p = arr; p < arr + sz; p++)
	{
		printf("%s %d\n", p->name, p->age);
	}
}
int main()
{
	test1();
	test2();
	test3();
	return 0;
}

打印结果为：

对于使用冒泡排序的方式实现qsort函数的代码分析

以测试排序整型数据为例

1. 根据 qsort 函数的形式写出 bubble_sort 函数

	//主函数中传参
	bubble_sort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
//自定义函数接收参数
void bubble_sort(void* base,int num,int size, int (*cmp)(const void*, const void*))
{
	//冒泡函数
}

这里使用了函数指针
此时函数指针 int (*cmp)(const void*, const void*)指向int_cmp函数

使用void*base接收arr的原因为：为了实现任意类型数据的排序
任意类型的数据，字节不同，故需要将字节与有多少个元素传给size和num

2. 冒泡函数 bubble_sort 的实现

void bubble_sort(void* base,int num,int size, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//一趟内部比较的对数
		for (j = 0; j < num - i - 1; j++)
		{
			//比较大小之后交换
		}
	}
}

冒泡排序的原理不变，不同的是比较大小与交换

比较大小时，不同的类型数据，需要进行不同的函数进行比较，故调用函数指针 int (*cmp)(const void*, const void*)指向的函数

//升序cmp>0,交换
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
//两个元素比较，需要将arr[j],arr[j+1]的地址传给cmp
{
	//交换
}
//调用的函数
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

调用函数int_cmp，若p1>p2，则返回大于0的数；若p1=p2，则返回0；若p1<p2，则返回小于0的数
返回的数若>0，则说明arr[j]>arr[j+1]，因为是升序排序，所以需要交换

交换时需要一个字节一个字节进行交换

//交换
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
//交换函数
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
	int i = 0;
	char tmp = 0;
	for (i = 0; i < size; i++)
	{
		tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

char*类型为一个字节
起始位置+第 j 个元素 * 类型的字节 = 第 j 个元素的起始位置
一个一个字节进行交换，需要知道交换多少字节，所以也要将字节数传给Swap函数中

---