qsort函数的使用及实现

qsort函数是一个库函数，使用时需包含头文件stdlib.h，用来对数据进行排序，可以排序任意类型的数据，所使用的排序思想为快速排序

一·使用

这是该函数的具体情况，该函数有四个参数，具体含义如下 

void qsort(void* base,  //指向待排序的第一个元素
           size_t num,  //待排序的元素个数
           size_t size, //待排序的元素大小（byte）
           int(*compar)(const void*,const void*)  
           //compar为函数指针，指向的函数能够比较e1和e2指向的两个元素并给出返回值
           );

在此介绍一下void*类型和回调函数

void*

void*是一种指针类型，为通用指针类型，可以接受任意类型数据的地址，但void*类型的指针变量只能用来存放地址，不能进行+1,-1和解引用操作（俗称大垃圾桶）

使用void*的目的是未来排序的数据类型未知 

回调函数

回调函数是通过函数指针调用的函数

把函数指针作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数，回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应，把调用的函数的地址以参数形式传递回去，使用函数指针接收，函数指针指向什么函数就调用什么函数

下面举例实现qsort函数排序一组整形数据

#include <stdio.h>
#include<stdlib.h>
void print(int arr[],int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}

}
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;

}
void test()
{
	int arr[] = { 3,4,1,2,0,9,8,5,6,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr, sz);
}
int main()
{
	test();
	return 0;
}

tips：由于形式参数类型为void*，使用时需强制类型转换成int*再解引用 

 既然qsort函数能排序任意类型的数据，那么在此再写一组测试用例用于排序结构体类型的数据

 （结构体类型的数据需选定按某个结构成员排序） 

在此定义一个学生结构体类型，结构体成员为姓名和年龄

按照年龄将结构体类型变量排序：

#include<stdio.h>
#include<stdlib.h>
struct Stu
{
	char name[30];
	int age;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age, ((struct Stu*)e2)->age;   //强转的目的是说明其为结构体指针类型
	//括起来是因为强转有临时性，括起来才为最终结果
}
void test1()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",15},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

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

通过监视窗口查看排序结果

排序前

排序后

 按照姓名将结构体类型变量排序：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
	char name[30];
	int age;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
    //名字是字符串，字符串比较使用库函数strcmp
}
void test1()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",20},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}

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

比较前：

比较后：

想必你已经学会了qsort函数的具体使用，下面我们来使用我们熟悉的排序算法：冒泡排序，来模拟实现qsort函数

模拟实现。。。别着急

插播一条小技巧，你知道面试官在共享桌面远程面试时会关注哪些点嘛

下面是《剑指offer》里的解答：

1.思考清楚再开始写代码

2.有良好的代码命名和缩进对齐习惯

3.能够进行单元测试

如果应聘者能够先写单元测试用例再写解决问题的函数，那么我相信面试官定会对你刮目相看，因为能做到测试在前，开发在后的程序员实在是太稀缺了，他会毫不犹豫的抛出橄榄枝

那么根据这段话，我们也先乖乖写测试用例吧（和上面使用的例子相同）

void test1()
{
	int arr[] = { 3,1,5,2,4,8,7,6,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr,sz);
}
void test2()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",20},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof s[0], cmp_stu_by_name);
}
void test3()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",15},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof s[0], cmp_stu_by_age);
}

qsort函数用来排序，但是数据的比较需额外操作，故将排序函数和比较函数分开实现，使用冒泡排序来实现一个对任意类型能够排序的函数，compare指针指向的函数的参数是：要比较的两个元素的地址

bubble（排序）函数的实现：

void bubble(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)  //比较函数需单独实现
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);  //相当于赋值
			}
		}
	}
}

 swap（拷贝）函数的实现：

void Swap(char* buf1, char* buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;          //由于不确定比较的两个数据的类型，
	    *buf2 = tmp;           //故赋值（拷贝）时一个字节一个字节的拷贝数据
		buf1++;
		buf2++;
	}
}

compare（比较）函数的实现（分别对应三组测试用例）： 

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*) e2;
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e1)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
	//字符串比较用库函数strcmp
}

以上就是实现qsort函数的全部过程了

完整代码：

#include <stdio.h>
#include <string.h>
struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e1)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
	//字符串比较用库函数strcmp
}
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*) e2;
}
void Swap(char* buf1, char* buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;          //由于不确定比较的两个数据的类型，
	    *buf2 = tmp;           //故赋值（拷贝）时一个字节一个字节的拷贝数据
		buf1++;
		buf2++;
	}
}
void bubble(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; 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 print(int arr[],int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}
}
void test1()
{
	int arr[] = { 3,1,5,2,4,8,7,6,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr,sz);
}
void test2()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",20},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof s[0], cmp_stu_by_name);
}
void test3()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",15},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble(s, sz, sizeof s[0], cmp_stu_by_age);
}
int main()
{
	test1();
	return 0;
}

你学会了嘛 (*'▽'*)♪