回调函数qsort()的使用介绍

目录

 简介：

冒泡排序：

 qsort的基本组成结构：

qsort对整型升序 ：

qsort对结构体数据排序：

 改造冒泡排序，使之能实现qsort的功能

---

 简介：

qsort是一个库函数

基于快速排序算法实现的一个排序的函数

是c语言本身提供给我们的一种排序函数

qsort的优点是它能够实现任意类型的数据进行排序，不论是int，char，结构体...类型都可以

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个

函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数

的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进

行响应。

冒泡排序：

#include <stdio.h>
void bubble_sort(int arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz - 1;i++)
	{
		int j = 0;
		for (j = 0;j < sz-1;j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d", arr[i]);
	}
}

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

但是对于冒泡排序的一大缺点就是它只能排列整型数据！！

不具有通用性

这就体现了qsort的优势，qsort它能够实现任意类型的数据进行排序，不论是int，char，结构体...类型都可以

 qsort的基本组成结构：

void qsort(void* base,//Start of target array:待排序数据的起始位置
	       size_t num,//Array size in elements:数组的元素个数
	     size_t width,//Element size in bytes:一个元素的字节大小
	int(* comp)(const void* e1, const void* e2)//函数指针
);

cmp:比较函数，专门用来比较的 ，要求qsort函数的使用者，自定义一个比较函数

当排序一个整型数组是用< >比较就行了，但是如果排序的是结构体数据呢？

可能不方便直接使用> <比较了

使用者根据实际情况，提供一个函数，实现两个数据的比较

e1，e2:待比较的两个元素的地址

函数指针返回的是一个int类型的数据

对于其返回值有：

 即

如果e1小于e2返回一个小于0的数字

如果e1等于e2返回0

如果e1大于e2返回一个大于0的数字

qsort对整型升序 ：

#include <stdio.h>
#include <stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
	/*if (*e1 > *e2)
	{

	}*///err void*是一个无确切类型的指针，无法直接解应用，如果是一个char*访问一个字节，如果是int*访问4个字节
	//void*就想一个垃圾桶，什么类型的指针都可以望里面丢，用来接受任意类型的数据
	//right
	/*if (*(int*)e1 > *(int*)e2)
	{
		return 1;
	}
	else if (*(int*)e1 == *(int*)e2)
	{
		return 0;
	}
	else
		return 0;*/
	return (*(int*)e1 - *(int*)e2);
}

void test2()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

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

qsort对结构体数据排序：

//按照年龄来排序
int cmp_stu_by_age(const void* e1, const void* e2)//e1,e2都是指向的结构体数据
{
	//转换为结构体指针
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}

void test3()
{
	struct stu arr[3] = { {"zhangsan",20,55.5},{"lisi",21,75.0},{"wangwu",22,80.0} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_age);
}

int main()
{
	test3();
	return 0;
}
//按照姓名来排序
struct stu
{
	char name[20];
	int age;
	double score;
};

int cmp_stu_by_name(const void* e1, const void* e2)//e1,e2都是指向的结构体数据
{
	//转换为结构体指针
	return strcmp(((struct stu*)e1)->name , ((struct stu*)e2)-> name));
}

void test3()
{
	struct stu arr[3] = { {"zhangsan",20,55.5},{"lisi",21,75.0},{"wangwu",22,80.0} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_name);
}

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

对于qsort的升降序的改变：我们只需要在cmp函数里面的返回值return出交换e1和e2

这里就使返回的值相反，升序自然就变成降序，降序就变成升序

注意：qsort本身排序的就是升序！！

 改造冒泡排序，使之能实现qsort的功能

首先我们先想一下，qsort函数的作者，能不能想到我们使用qsort排序什么具体类型的数据？

void qsort(void* base,//Start of target array:待排序数据的起始位置
	       size_t num,//Array size in elements:数组的元素个数
	     size_t width,//Element size in bytes:一个元素的字节大小
	int(* comp)(const void* e1, const void* e2)//函数指针
);

我们在这里再看一下qsort函数的使用条件：

void* base:我们之所以使用void*类型，是因为需要兼容int*,char*,结构体等等,而void*能够完美得接受各种数据类型的数据，可以说void*指针是一个无类型指针，它什么类型都可以望里面放

size_t num：数组元素个数

size_t width:宽度 ，即一个元素的大小，如int类型的4个字节，char类型的1个字节

int(* comp)(const void* e1, const void* e2):函数指针:函数指针，因为如果需要排序的类型不一样的话，比较的方法也不一样，使用需要额外写一个比较函数来进行比较

 代码：

void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0;i < width;i++)
	{
		char temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}

}

void bubble_sort(void* base,int num,int width,int(*cmp)(const void* e1,const void* e2))//如同qsort函数一样给其void*来修饰不同类型
{
	int i = 0;
	for (i = 0;i < num - 1;i++)
	{
		int j = 0;
		for (j = 0;j < num-1;j++)//比较
		{
			/*if (arr[j] > arr[j + 1])*/
			if(cmp(((char*)base + j * width),((char*)base + (j+1) * width))>0)
			{
				//交换
				/*int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp*/;
				Swap((char*)base + j * width, ((char*)base + (j + 1) * width),width);
			}
		}
	}
}

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d", arr[i]);
	}
}

int cmp_int(const void* e1, const void* e2)
{
	/*if (*e1 > *e2)
	{

	}*///err void*是一个无确切类型的指针，无法直接解应用，如果是一个char*访问一个字节，如果是int*访问4个字节
	//void*就想一个垃圾桶，什么类型的指针都可以望里面丢，用来接受任意类型的数据
	//right
	/*if (*(int*)e1 > *(int*)e2)
	{
		return 1;
	}
	else if (*(int*)e1 == *(int*)e2)
	{
		return 0;
	}
	else
		return 0;*/
	return (*(int*)e1 - *(int*)e2);//判断的是整型使用强制转换为int*
}
void test4()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz,sizeof(arr[0]),cmp_int);
	print_arr(arr, sz);
}


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