qsort（）（C语言）

前言：qsort是一个库函数，一种快速排序。

qsort的使用模型：                                                                                                             

可以写成：void qsort( void *base,

                                      size_t mun,

                                       size_t wight,

                                         int (*compare)(const void *elme1, const void *elme1) );

qsort的头文件:<stdlib.h>。（int arr[]={1,2,3,4,5,6}）

void *base：就是目标的起始位置。(一般都是arr)

size_t mun：数组大小，单位字节。（sizeof （arr）/sizeof(arr[0]))

size_t wight：就是一个元素所占的大小，单位字节（比如int占4个，char占1个）(sizeof(int))

 int (*compare)(const void *elme1, const void *elme2) )：这个第一眼看的是函数指针，compare的意思是比较，比较elme1和elme2指向的元素大小。

注意：没有返回值。

关于这个 int (*compare)(const void *elme1, const void *elme2)，他们的返回值。

 应该可以看得懂吧，算了直接上案例吧。

 整形使用

int compare(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}
void ponit(int arr[], int sz) {
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main() {
	int	arr[] = { 3,8,9,7,5,6,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(int), compare);
	ponit(arr, sz);
	return 0;
}

 如果是想降序叙的话，可以吧a和b换一下位置。

主要看段代码：

 void*是一种比较特殊的指针：

1.是一种无类型的指针，无具体类型的指针。

2.指针变量可以存放任意类型的地址。

3.指针不能直接进行解引用操作。

4.指针不能直接进行+—整数。

所以用void*传的，但是用的时候需要强制类型转化成所需排序的类型。

void *base这个也就晓得，为啥用void*了，因为我们从发明qsort函数作者的角度出发，他一开始也不晓得他所排序的数据的类型，所以统一用void*。

结构体的使用

浮点数的比较，不能直接相减，因为返回值是int类型，小于1的都会返回成0。

struct Stu {
	char name[20];
	int age;
	float score;
};
//成绩
//int cmp_stu_by_socre(const void* e1, const void* e2)
//{
//	if (((struct Stu*)e1)->score > ((struct Stu*)e2)->score)
//	{
//		return 1;
//	}
//	else if (((struct Stu*)e1)->score < ((struct Stu*)e2)->score)
//	{
//		return -1;
//	}
//	else
//	{
//		return 0;
//	}
//	浮点数之间不能直接-，因为返回类型是int
//}
//年龄
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
//名字
//int cmp_stu_by_name(const void* e1, const void* e2)
//{
//	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
//}
void print_stu(struct Stu arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score);
	}
	printf("\n");
}
void text2() {
	struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
	//按照成绩
	int sz = sizeof(arr) / sizeof(arr[0]);
	/*qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_socre);*/
	//按照年龄
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	/*按照名字*/
	/*qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);*/
	print_stu(arr, sz);
}
int main() {
	
	text2();
	return 0;
}

qsort用冒泡排序思想模拟模拟

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-i-1; j++)
		{
			if (arr[j]>arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main() {
	int arr[] = { 8,7,5,6,1,4,3,2,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

上面代码是用冒泡排序整形数组的代码。然后我们按照冒泡排序的思想模拟qsort函数吧。

int cmp_int(const void* e1, const void* e2)//有浮点型，不能这样写
{
	return *(int*)e1 - *(int*)e2;//这里看类型，记得改
}
void Swap(char* buf1, char* buf2, int width)//一个一个字节的交换。
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
//用void*base因为不知道是什么类型
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			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_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//根据不同的类型，写printf
	}
	printf("\n");
}
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };//举一个例子
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
int main() {
	test3();
	return 0;
}

然后其他类型的比较，都是大差不差的，但是浮点型，注意点。