C语言——使用回调函数模拟实现qsort

最新推荐文章于 2025-07-31 19:34:28 发布

CPP_ZhouXuyang

最新推荐文章于 2025-07-31 19:34:28 发布

阅读量694

点赞数 15

CC 4.0 BY-SA版权

分类专栏： Mr.狠人C语言学习篇文章标签： c语言算法数据结构 c++ 程序员创富排序算法青少年编程

本文链接：https://blog.youkuaiyun.com/CPP_ZhouXuyang/article/details/141895294

Mr.狠人C语言学习篇专栏收录该内容

15 篇文章

订阅专栏

同学们还记得之前我们已经学过一种排序方法叫“冒泡排序“嘛。代码直接附上咯


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

现在我们已经找到了一些相应的问题，那我们怎么改造呢？

我们先参考学习一下库函数qsort或许你就会有自己的思路了，qsort的头文件<stdlib.h>

已经了解qsort需要包含的元素，那函数指针指向的比较函数我们要怎么去写呢，这边Mr.狠人举个例子哈

当然这样写是为了让你更好理解，如果能理解的话那我们可以简化代码

//自定义比较函数
int compar(const void* e1,const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

int main()
{
	int arr[10] = { 3,1,9,8,5,4,0,2,7,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), compar);
	
	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	
	return 0;
}

当然我们也可以测试一下结构体数据能不能用qsort来排序

//创建一个结构体
struct students
{
	char name[20];
	int age;
};

//比较函数
int compar_students_by_age(const void* e1, const void* e2)
{
	return (*(struct students*)e1).age - (*(struct students*)e2).age;
}

int main()
{
	//为了方便理解我们就不演示回调函数，大家使用回调函数肯定更好
	struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
	int sz = sizeof(classA) / sizeof(classA[0]);
	qsort(classA, sz, sizeof(classA[0]), compar_students_by_age);
	
	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%d %s\n", classA[i].age,classA[i].name);
	}
	
	return 0;
}

当然我们也可以不按照age来比，我们用name来比，字符串的比较方式用strcmp函数比较

//创建一个结构体
struct students
{
	char name[20];
	int age;
};

//比较函数
//字符串的比较不能直接用大于号小于号
int compar_students_by_name(const void* e1, const void* e2)
{
	return strcmp((*(struct students*)e1).name,(*(struct students*)e2).name);
}

int main()
{
	struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
	int sz = sizeof(classA) / sizeof(classA[0]);
	qsort(classA, sz, sizeof(classA[0]), compar_students_by_name);
	
	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%d %s\n", classA[i].age,classA[i].name);
	}
	
	return 0;
}

现在我们已经学会了qsort的使用方法，那么有没有思路去改造我们的冒泡排序了？还是把这张图拿下来哈

我们参考过qsort，我们是不是可以跟他一样用void*指针去接收所有类型的变量的地址

接下来是不是就要解决比较的问题，我们不知道使用者会传来的是什么类型的数组，可能是结构体对吧，那就不难单纯的用大于号小于号去比较

那现在我们的冒泡排序的参数是不是就变成这样了

void bubble_sort(void* base, int sz, int width, int(*compar)(const void* e1, const void* e2))

比较函数的调用就是这样

int i = 0;//趟数
for (i = 0; i < sz - 1; i++)
{
	int j = 0;
	for (j = 0; j < sz - i - 1; j++)
	{
		//我们在这边已经有宽度了，那是不是全用char类型就行，因为char类型是一个字节，乘宽度刚好是我们需要的大小
		if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)//调用比较函数
		{
			//交换
		}
	}
}

现在就剩下交换了

那我们写个函数进行元素交换吧

    Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);

//交换函数
//调用时就已经强制转换成char*，所以这边直接写char*就行
void Swap(char* buf1, char* buf2, int width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

要改的三个点我们都解决了，整理一下升级后的代码吧

//自定义比较函数(int)
int compar_int(const void* e1,const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

//交换函数
void Swap(char* buf1, char* buf2, size_t width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

//冒泡排序函数
void bubble_sort(void* base, size_t sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
	int i = 0;//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			
			if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

//test函数
void test()
{
	int arr[] = { 6,4,1,2,9,3,7,8,10,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	bubble_sort(arr, sz, sizeof(arr[0]), compar_int);

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

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

//创建一个结构体
struct students
{
	char name[20];
	int age;
};

//比较函数(结构体name）
int compar_students_by_name(const void* e1, const void* e2)
{
	return strcmp((*(struct students*)e1).name,(*(struct students*)e2).name);
}

//自定义比较函数(int)
int compar_int(const void* e1,const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

//交换函数
void Swap(char* buf1, char* buf2, size_t width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

//冒泡排序函数
void bubble_sort(void* base, size_t sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
	int i = 0;//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			
			if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

//test函数
void test()
{
	struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
	int sz = sizeof(classA) / sizeof(classA[0]);

	bubble_sort(classA, sz, sizeof(classA[0]), compar_students_by_name);

	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d ", classA[i].name,classA[i].age);
	}
}

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

这样我们的代码也就写完了，通过这一次的改写冒泡排序，我们是不是能感受到void*指针的遍历，这种编程叫做泛型编程。

大家可以在自行梳理一下，有帮助请给一个三连吧！