用冒泡排序模拟C语言中的内置快排函数qsort！

目录

目录

 

                                            悟已往之不谏，知来者犹可追  

创作不易，宝子们！如果这篇文章对你们有帮助的话，别忘了给个免费的赞哟~

1.回调函数的介绍

这里首先介绍一下回调函数的概念~

回调函数是使用函数指针（地址）调用的函数。

如果我们把一个函数的指针（地址）作为一个参数传递给另一个函数，当我们通过指针找到这个函数并对其进行调用时，这个被调用的函数就是回调函数。

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

#include<stdio.h>
test(void (*print)())
{
	print();
}
void print()
{
	printf("这是一个回调函数\n");
}
int main()
{
	test(print);
	return 0;
}

2. 回调函数实现转移表

现在我们来实现一个简单的计算器~

#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a * b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf(" 0:exit \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输⼊操作数：");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("输⼊操作数：");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("输⼊操作数：");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("输⼊操作数：");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}

我们可以很容易的观察到上述代码有一部分是多次重复的~

 这部分只有函数的调用是不一样的，所以我们是不是可以把这部分封装成一个函数calc()，在calc函数中调用不同的加减乘除函数就行了呢~

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
void cacl(int(*p)(int x, int y))
{
	int x = 0;
	int y = 0;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	int ret = p(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 1;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			cacl(add);
			break;
		case 2:
			cacl(sub);
			break;
		case 3:
			cacl(mul);
			break;
		case 4:
			cacl(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

3. 冒泡排序的实现

常见的排序有插入排序、选择排序、希尔排序、冒泡排序、快速排序等等~

在讲qsort前，这里我们先了解一下冒泡排序~

顾名思义，冒泡排序就是让元素像泡泡一样慢慢往上移动~

 这里我用C语言来实现一下~

void bull_sort(int* arr,int len)
{
	assert(arr);//判断指针的有效性
	for (int i = 0; i < len - 1; i++)
	{
		int flag = 1;//假设已经有序
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	bull_sort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行效果~

 

4. qsort的介绍和使用

接下来我们就来看看qsort啦~

注意我们在使用qsort时要引入头文件#include<stdlib.h>

这里简单的举个栗子来使用一下qsort啦~

int cmp_int(const void* a, const void* b)
{
	assert(a && b);
	return *(int*)a - *(int*)b;
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	assert(arr);//判断指针的有效性
	qsort(arr, len, sizeof(arr[0]), cmp_int);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;;
}

效果如下~

 我们还可以使用qsort比较结构体类型的变量！

我们通过结构体中的名字来比较结构体变量的大小~

struct S
{
	char name[20];
	int age;
};//定义一个结构体类型
int cmp_stu_by_age(const void* a,const void* b)
{
	return strcmp(((struct S*)a)->name, ((struct S*)b)->name);
}
int main()
{
	struct S student[3] = { {"zhangsan",18},{"lisi",17},{"wanglaowu",16} };//定义一个结构体数组并初始化
	int len = sizeof(student) / sizeof(student[0]);
	qsort(student, len, sizeof(student[0]), cmp_stu_by_age);
	return 0;
}

排序前~

排序后~

5. qsort的模拟实现 

对比上面我们自己写的冒泡排序和C语言中的内置快排，我们会发现我们自己写的冒泡排序只能对int类型的数据进行排序(有局限性），而qsort却可以对任意类型的数据进行排序。

接下来这里我就使用冒泡排序的算法模拟实现qsort~

int cmp_int(const void* a, const void* b)
{
	assert(a && b);
	return *(int*)a - *(int*)b;
}
void swap(char* buf1,char* buf2,size_t num)//一个一个字节交换
{
	while (num--)
	{
		char tmp = *(buf1);
		*(buf1) = *(buf2);
		*(buf2) = tmp;
		buf1++;
		buf2++;
	}
}
void my_qsort(void* arr, size_t len, size_t num, int (*cmp_int)(const void*,const void*))
{
	assert(arr);//判断指针的有效性
	for (int i = 0; i < len - 1; i++)
	{
		int flag = 1;//假设已经有序
		for (int j = 0; j < len - 1 - i; j++)
		{
			if(cmp_int((char*)arr + j * num, (char*)arr + (j + 1) * num)>0);
			{
				swap(((char*)arr + j * num), ((char*)arr + (j + 1) * num),num);
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	size_t len = sizeof(arr) / sizeof(arr[0]);
	my_qsort(arr, len, sizeof(arr[0]), cmp_int);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行效果如下~

 

6. 完结散花

好了，这期的分享到这里就结束了~

如果这篇博客对你有帮助的话，可以用你们的小手指点一个免费的赞并收藏起来哟~

如果期待博主下期内容的话，可以点点关注，避免找不到我了呢~

我们下期不见不散~~