#include＜初见C语言之指针（4）＞

最新推荐文章于 2024-07-12 18:22:32 发布

不谦虚的谦虚

最新推荐文章于 2024-07-12 18:22:32 发布

阅读量1.2k

点赞数 37

分类专栏： C 文章标签：数据结构 c语言学习开发语言排序算法

本文链接：https://blog.csdn.net/weixin_62408950/article/details/136972203

版权

C 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文介绍了如何使用回调函数实现C语言计算器，展示了qsort函数及其在冒泡排序中的应用，以及如何通过模拟qsort实现自定义排序。

摘要由CSDN通过智能技术生成

一、回调函数

顾名思义：就是通过函数指针调用函数

我们这里要知道，有了函数指针之后，函数的调用，可以使用函数名调用，也可以使用函数指针来调用。

下面运用回调函数来实现一个计算器的功能

代码如下：

调用函数之前
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;
}
//想写一个计算器
//完成2个整数的运行
//1.加法
//2.减法
//3.乘法
//4.除法
void menu()
{
	printf("**************************\n");
	printf("*****1.Add     2.Sub******\n");
	printf("*****3.Mul     4.Div******\n");
	printf("*****     0.exit    ******\n");
	printf("**************************\n");
	printf("**************************\n");
	printf("**************************\n");
}
void calc(int(*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n",ret);

}
int main()
{
	int input = 0;

	do
	{
		
		menu();
		int input = 0;
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

画图演示：

之前之后

我们使用回调函数之后，比之前所写代码更加清爽

二、qsort函数

qsort——用来排序，并且是库函数，底层使用的是快速排序的方式

我们之前写过的冒泡排序

代码如下：

 void bulle_sort(int arr[],int sz )
{
	//趟数
	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])
			{
				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[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bulle_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

我们可以发现之前的冒泡排序只能对整型元素排序，如果要对其他类型进行排序就要用到qsort函数了。

下面我们看看qsort函数的组成部分：

解析：

知道了qsort函数的组成部分后，我们就可以对冒泡排序进行优化了

使用qsort函数注意事项：

qsort 函数的使用者 - 明确的知道要排序的是什么数据，这些数据应该如何比较，所以提供两个元素的比较函数

代码如下：

#include<stdio.h>

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

   }
   printf("\n");
}

int cmp_int(const void* p1, const* p2)
{
   if (*(int*)p1 > *(int*)p2)
       return 1;
   else if (*(int*)p1 == *(int*)p2)
       return 0;
   else
       return -1;

}
简化
int cmp_int(const void* p1, const* p2)
{
   return *(int*)p2 - *(int*)p1;
   //> ------> >0
   //< ------> <0
   //== ----> ==0

}
void test1()
{
   int arr[] = { 9,9,7,6,5,4,3,2,1,0 };
   int sz = sizeof(arr) / sizeof(arr[0]);
   qsort(arr, sz, sizeof(arr[0]), cmp_int);
   print_arr(arr, sz);
}

struct Stu
{
   char name[20];
   int age;
};
//这里的两个结构体元素怎么比较大小？
//1.按照名字比较 - 字符串比较
//2.按年龄比较 - 整型

int com_stu_by_name(const void* p1,const void* p2)
{
   return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
int com_stu_by_age(const void* p1, const void* p2)
{
   return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

void test2()
{

   struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
   int sz = sizeof(arr) / sizeof(arr[0]);
   qsort(arr, sz, sizeof(arr[0]), com_stu_by_name);
   print_arr(arr, sz);
}

int main()
{
   //写一段代码使用qsort排序整型数据
   //test1();
   //写一段代码使用qsort排序结构体的数据
   test2();
   return 0;
}

画图演示：

拓展：

//结构体指针的用法
//struct Stu
//{
//   char name[20];
//   int age;
//};
/*struct Stu
{
   char name[20];
   int age;
}s,s2,s3;*///s,s1,s2是结构体变量
//
//typedef struct Stu
//{
//   char name[20];
//   int age;
//}stu;//stu是类型名

三、模拟qsort实现冒泡排序

首先我们要先知道冒泡排序的核心思想：两两相邻的元素相比较，如果不满足顺序就交换，满足顺序就不换。

画图演示：

代码实现：

int count = 0;
void bubble_sort(int* arr, int sz2)
{
	int i = 0;
	//趟数
	for (i = 0; i < sz2 - 1; i++)
	{
		//一趟冒泡
		int flag = 1;
		int j = 0;
		for (j = 0; j < sz2 - 1 - i; j++)
		{
			count++;
			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;
		}

	}
}
void print_arr(int arr[], int sz2)
{
	int i = 0;
	for (i = 0; i < sz2; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };//降序
	int sz2 = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz2);
	bubble_sort(arr, sz2);
	print_arr(arr, sz2);
	printf("count = %d", count);
	return 0;
}

代码如下：

void Swap(char* buff1, char* buff2,size_t width )
{
   int i = 0;
   for (i = 0; i < width; i++)
   {
       char tmp = *buff1;
       *buff1 = *buff2;
       *buff2 = tmp;
       buff1++;
       buff2++;
   }
}
void bulle_sort(void* base,size_t sz, size_t width,int(*cmp)(const void*p1, const void* p2))
{
   //趟数
   int i = 0;
   for (i = 0; i < sz-1; i++)
   {
       //一趟内部比较
       int j = 0;
       for (j = 0; j < sz-1-i; j++)
       {
           //比较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("\n");
}
//测试的是bulle_sort排序整型数据
void test3()
{
   int arr[] = { 9,9,7,6,5,4,3,2,1,0 };
   int sz = sizeof(arr) / sizeof(arr[0]);
   bulle_sort(arr, sz, sizeof(arr[0]), cmp_int);
   print_arr(arr, sz);
   //bulle_sort(arr1, );//排序整型
   //bulle_sort(arr2, );//排序结构体
}
void test4()
{
   struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
   int sz = sizeof(arr) / sizeof(arr[0]);
   //qsort(arr, sz, sizeof(arr[0]), com_stu_by_name);
   //bulle_sort(arr, sz, sizeof(arr[0]), com_stu_by_name);
   bulle_sort(arr, sz, sizeof(arr[0]), com_stu_by_age);
}
int main()
{

   //int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
   //int sz = sizeof(arr) / sizeof(arr[0]);
   //test3();
   test4();
   //print_arr(arr, sz);
   return 0;
}