C语言qsort函数详解

1.qsort函数是什么

这里我们使用MSDN软件查找
qsort()函数：快速排序的函数 -引用stdlib.h头文件

参数说明：
void qsort (
void* base, //指向要排序的目标数组的指针
size_t num, //待排序的元素个数
size_t width, //一个元素的大小，单位是字节
int(cmp)(const void e1, const void* e2)
);
其中，cmp是函数指针，指针指向一个函数，这个函数需要我们自己编写，用来比较两个元素

关于qsort函数第四个参数说明：
定义：

参数compare是指向用户提供的例程的指针–也就是我们自己编写的排序函数的函数指针
elem1与elem2是qsort在排序期间调用例程一次或多次，每次调用时传递指向两个数组元素的指针
const void* 表示接收任何数组元素类型常量的指针

例程：为了比较传入的数组元素的大小，我们需要编写一个自定义排序算法的函数称为例程，在这里传入函数的指针就可以通过函数指针调用这个函数进行排序
关于函数指针讲解详见：

返回值类型为int

比较两个数组元素elem1与elem2的大小：
elem1<elem2 返回值<0
elem1=elem2 返回值=0
elem1>elem2 返回值>0

关于void*型指针：

无具体类型指针，即可接收任何类型指针指向的地址
缺点：不可进行运算，不能±整数，不能进行解引用操作

	int a = 10;
	float f = 3.14f;
	void* p1 = &a;
	void* p2 = &f;
	p1 = p1 + 1;//error

2.使用qsort函数排序

2.1整型数组排序

注意参数类型是const void*，要强制类型转换并解引用操作才能得到要比较的值
如果按降序排列：写成e2-e1形式即可

void Print(char* str, int sz) {//打印排序之后的数组
	for (int i = 0; i < sz; i++) {
		printf("%d ", *(str + i));
	}
	printf("\n");
}
//注意函数类型是const void*，要强制类型转换并解引用操作才能得到要比较的值
int cmp_int(const void* e1, const void* e2) {
	return (*(int*)e1 - *(int*)e2);
}
int main() {
	int arr[] = { 1,4,3,2,5,8,9,0,6,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	Print(arr, sz);
	return 0;
}

2.2浮点型数组排序

这里需要注意在比较e1与e2大小时返回值类型可能因int发生强制类型转换，所以我们用1和-1转换一下

int cmp_float(const void* e1, const void* e2) {
	//写法1
	//return (int)(*(float*)e1 - *(float*)e2);//当(int)(e1-e2)=(int)(0.2-0.1)=0,返回0--error
	//写法2
	if ((*(float*)e1 - *(float*)e2) > 0.00000) {
		return 1;
	}
	if ((*(float*)e1 - *(float*)e2) == 0.00000) {
		return 0;
	}
	if ((*(float*)e1 - *(float*)e2) < 0.00000) {
		return -1;
	}
}
int main() {
	float arr[] = { 5.6f,3.4f,9.7f,1.4f,3.5f,8.0f,2.6f,4.7f,7.8f,0.1f };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_float);
	Print(arr, sz);//承接整形数组排序的Print函数--打印排序后的数组
	return 0;
}

2.3字符数组排序

void Print(char* str, int sz) {//打印排序之后的数组
	for (int i = 0; i < sz; i++) {
		printf("%c ", *(str + i));
	}
	printf("\n");
}
//对于字符类型数组，强制类型转换后比较的实际上是比较字符的ascii码值大小
int cmp_char(const void* e1, const void* e2) {
	return ((int)*(char*)e1 - (int)*(char*)e2);
}
int main() {
	char str[] = "qwertyuiopasdfghjklzxcvbnm";
	int sz = sizeof(str) / sizeof(str[0]);
	qsort(str, sz-1, sizeof(str[0]), cmp_char);
	Print(str, sz-1);
	//注意：sizeof读取到字符串结束标志'\0'才停止,最终返回值的字符串长度+1，也就是把'\0'也统计进去，所以需要-1得到字符串实际长度
	return 0;
}

2.4字符指针数组排序

int cmp_chars(const void* e1, const void* e2)
{
	return strcmp(*(char**)e1, *(char**)e2);
}
int main()
{
	char* arr1 = "abc";
	char* arr2 = "wcad";
	char* arr3 = "cab";
	char* arr4 = "dfhi";
	char* p[4] = { arr1,arr2,arr3,arr4};
	int sz = sizeof(p) / sizeof(p[0]);
	qsort(p, sz, sizeof(p[0]), cmp_chars);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s\n", p[i]);
	}
}

2.5对结构体数组排序

typedef struct Stu {
	char name[20];
	int age;
}Stu;

int cmp_name(const void* e1, const void* e2)
{
	return strcmp (((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}//排序字符串
//strcmp判断两个字符串长度大小
int cmp_age(const void* e1, const void* e2) {
	return (struct Stu*)e1 - (struct Stu*)e2;
}//排序年龄
int main() {
	Stu s[4] = { {"zhang",20},{"xiaoqi",19},{"wen",17} ,{"lisi",37}};//创建结构体数组
	qsort(s, sizeof(s) / sizeof(s[0]), sizeof(struct Stu), cmp_name);
	for (int i = 0; i < 4; i++) {
		printf("%s %d\n", s[i].name, s[i].age);
	}
	printf("===\n===\n");
	qsort(s, sizeof(s) / sizeof(s[0]), sizeof(struct Stu), cmp_age);
	for (int i = 0; i < 4; i++) {
		printf("%s %d\n", s[i].name, s[i].age);
	}
	return 0;
}

3.使用冒泡排序模拟实现qsort函数：

typedef struct Stu {
	char name[20];
	int age;
}Stu;

int cmp_Stu_name(const void* e1, const void* e2) {
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_Stu_age(const void* e1, const void* e2) {
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_int(void* p1, void* p2) {
	return *(int*)p1 - *(int*)p2;
}
int cmp_float(void* e1, void* e2) {
	if (*(float*)e1 - *(float*)e2 > 0) {
		return -1;
	}
	if (*(float*)e1 - *(float*)e2 == 0) {
		return 0;
	}
	if (*(float*)e1 - *(float*)e2 > 0) {
		return 1;
	}
}//float数据比较返回值会发生强制类型转换，这里用 1 -1 0 来替换 >0 <0 ==0 的情况

void swap(char* p1, char* p2,int width) {
	for (int i = 0; i < width; i++) {//传入符合比较条件的两个元素(每个元素大小为width个字节)，交换width个字节
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

//width为一个结构体数组的大小
//模拟实现qsort函数
void bubble_qsort(void* base,int sz, int width, int (*cmp)(void* e1, void* e2)) {
	for (int i = 0; i < sz - 1; i++) {
		for (int j = 0; j < sz - i - 1; j++) {
			//两个元素的比较
			if (cmp((char*)base+j*width,(char*)base+(j+1)*width)>0) {//传相邻的两个元素
				swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
			}
		}
	}
}
void test_int() {
	int arr[] = { 0,1,4,2,3,5,6,8,9,7 };
	bubble_qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp_int);
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}
}
void test_Stu_age() {
	Stu s[] = { {"zhang",20},{"xiaoqi",19},{"wen",17} ,{"lisi",37} };//创建结构体数组
	int sz = sizeof(s) / sizeof(s[0]);
	int width = sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_Stu_age);
	for (int i = 0; i < 4; i++) {
		printf("%s %d\n", s[i].name, s[i].age);
	}
}
void test_Stu_name() {
	Stu s[] = { {"zhang",20},{"xiaoqi",19},{"wen",17} ,{"lisi",37} };//创建结构体数组
	int sz = sizeof(s) / sizeof(s[0]);
	int width = sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_Stu_name);
	for (int i = 0; i < 4; i++) {
		printf("%s %d\n", s[i].name, s[i].age);
	}
}

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