您好，欢迎来到刀刀网。
科技 教育 生活 旅游 时尚 美容 美食 健康 体育 游戏 汽车 家电
搜索
您的当前位置：首页指针的奥秘（四）：回调函数+qsort使用+qsort模拟实现冒泡排序

指针的奥秘（四）：回调函数+qsort使用+qsort模拟实现冒泡排序

来源：刀刀网

一.回调函数是什么？

上一篇我们写了一个简单的计算器，如下：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("*************************\n");
	printf("**1:add***********2:sub**\n");
	printf("**3:mul***********4:div**\n");
	printf("*********0:exit**********\n");
	printf("*************************\n");

}
int main()
{
	int x = 0;
	int y = 0;
	int input = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请输入：");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			break;
		case 1:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d+%d=%d\n", x, y, ret);
			break;
		case 2:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d-%d=%d\n", x, y, ret);
			break;
		case 3:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d*%d=%d\n", x, y, ret);
			break;
		case 4:
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d/%d=%d\n", x, y, ret);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void Calc(int(*pf)(int, int))
{
	int ret = 0;
	int x = 0;
	int y = 0;
	printf("请输入两个数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}
void menu()
{
	printf("*************************\n");
	printf("**1:add***********2:sub**\n");
	printf("**3:mul***********4:div**\n");
	printf("*********0:exit**********\n");
	printf("*************************\n");

}
int main()
{
	int x = 0;
	int y = 0;
	int input = 0; 
	do
	{
		menu();
		printf("请输入：");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			break;
		case 1:
			Calc(Add);
			break;
		case 2:
			Calc(Sub);
			break;
		case 3:
			Calc(Mul);
			break;
		case 4:
			Calc(Div);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

二.qsort函数使用

1.qsort介绍

  qsort函数是C语言中的一个库函数，头文件——stdlib.h，这个函数对任意类型的数据都能排序。

注意：int compare(const void *elem1, const void *elem2)——比较函数，需要使用qsort函数的程序员自己提供，并且有下面这些要求：

2.qsort排序整型数据

#include<stdio.h>
#include<stdlib.h>
//1.0测试qsort排序整形数据
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int cmp_int(const void* e1, const void* e2)
{
    //e1指向的一个数组元素，e2指向的是下一个数组元素
	/*if (*(int*)e1 > *(int*)e2)
		return 1;
	else if (*(int*)e1 < *(int*)e2)
		return -1;
	else
		return 0;*/
	return (*(int*)e1 - *(int*)e2);//想逆序改变e1与e2即可
}
void test1()
{
	int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	Print(arr, sz);
}
int main()
{
	test1();
	return 0;
}

3.qsort排序结构体数据

  结构体成员访问操作符有两种

操作符 . 结构体变量.成员名
操作符 -> 结构体指针->成员名

int main()
{
	struct stu s = { "zhangsan",66 };
	printf("%s %d\n", s.name, s.age);

	struct stu* ps = &s;
	printf("%s %d\n", (*ps).name, (*ps).age);
	printf("%s %d\n", ps->name, ps->age);
	return 0;
}

1.通过结构体中的整形成员排序

#include<stdio.h>
#include<stdlib.h>
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
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*)e2)).age;
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void test2()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//通过age排序
}
int main()
{
	test2();
	return 0;
}

2.通过结构体中的字符串成员排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
struct stu
{
	char name[20];
	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 test2()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	test2();
	return 0;
}

三.qsort模拟实现冒泡排序

给出简单的冒泡排序，代码如下：

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

该函数只能排序整形元素，我们可以借助qsort函数来模拟实现冒泡排序用于排序各种类型数据。如下代码：

void Print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
struct stu
{
	char name[20];
	int age;
};
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	char temp;
	for (i = 0; i < width; i++)
	{
		temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}
}
void BubbleSort(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 - 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);
			}
			
		}
	}
}
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
void test4()
{
	int arr[] = { 3,1,7,9,4,2,6,5,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_int);
	Print(arr, sz);
}
int cmp_stu_by_int(const void* e1, const void* e2)
{
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
void test5()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_int);
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void test6()
{
	struct stu arr[] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	//test4();
	//test5();
	test6();
	return 0;
}

思考：为什么使用的都是泛型指针void*呢？

  1. 由于不知道排序什么数据类型。若排序整形，用int*，那排序短整型，字符串呢？就不方便了。
  2. 泛型指针void*可以配合数组元素的个数与每个元素字节的大小，精准定位每个元素的地址，就很方便交换元素了。
  3. 交换元素由于不知道元素的类型，可以考虑交换每一个字节的内容，配合每个元素字节的大小，可以达到整体交换的效果，可谓是精彩绝伦！

指针部分到这就结束了，但是学习仍未止步！！！
创作不易，如果能帮到你的话能赏个三连吗？感谢啦！！！

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- gamedaodao.com 版权所有 湘ICP备2022005869号-6

违法及侵权请联系：TEL:199 18 7713 E-MAIL:2724546146@qq.com

本站由北京市万商天勤律师事务所王兴未律师提供法律服务