用回调函数实现冒泡排序

最新推荐文章于 2022-01-26 15:30:19 发布
最新推荐文章于 2022-01-26 15:30:19 发布
阅读量772 收藏 3
点赞数 2
分类专栏： C语言 C语言之旅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snow_5288/article/details/52138156
版权
本文介绍了回调函数的概念，机制及使用原因，并以回调函数为例，展示了如何模拟实现冒泡排序，强调了回调函数在排序不同类型数组时的灵活性。
摘要由CSDN通过智能技术生成

（一）什么是回调函数呢？

答：回调函数就是通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

（二）回调函数的实现机制

1.定义一个回调函数

2.提供函数实现的一方在初始化时。将回调函数的函数指针注册给调用者。

3.当特定的条件发生时，调用者使用函数指针调用回调函数对事件进行处理。

（三）回调函数的使用原因

通过回调函数，可以将调用者与被调用者分开。


可能你不知道，在库函数中有一个qsort函数，即我们通常说的快速排序，让我们看它是如何调用和实现的。

原型：void qsort( void *base, size_t num, size_t width, 

           int (__cdecl *compare ) (const void *elem1, const void *elem2 ) )

base:目标数组的首位置

num:元素个数

width:每个元素所占字节数

compare:函数指针，指向一个比较函数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>


int compare_int(const void *elem1,const void *elem2)//排序整型数组
{
    return *(int *)elem1-*(int *)elem2;
}

int compare_float(const void *elem1,const void *elem2)//排序浮点型数组
{
	if((*(float *)elem1)-(*(float *)elem2) > 0)//不可以直接返回二者的差,\
		                                     转化为整型时可能漏掉部分数据     
         return 1;

	else if((*(float *)elem1)-(*(float *)elem2) == 0)
         return 0;

	else
         return -1;
}

int compare_string(const void *elem1,const void *elem2)、
{
    return strcmp(*(char **)elem1,*(char **)elem2);//应先找到每个字符串\
	                                                 的首地址再进行解引用
}

void print_int_arr(int arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%d ",arr[i]);
	}
	printf("\n");
}
void print_float_arr(float arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%f ",arr[i]);
	}
	printf("\n");
}
void print_string_arr(char **arr,int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%s ",arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr1[]={2,4,6,8,0,1,3,5,7,9};
	int sz1 = sizeof(arr1)/sizeof(arr1[0]);
	float arr2[]={2.0f,4.4f,6.5f,8.3f,0.0f,1.2f,3.7f,5.6f,7.9f,9.8f};
	int sz2 = sizeof(arr2)/sizeof(arr2[0]);
	char *arr3[]={"abcd", "bbdd", "aabc", "dfer","dghjf"};
	int sz3 = sizeof(arr3)/sizeof(arr3[0]);
	qsort(arr1,sz1,sizeof(int),compare_int);
	qsort(arr2,sz2,sizeof(int),compare_float);
	qsort(arr3,sz3,sizeof(int),&compare_string);
	print_int_arr(arr1,sz1);
	print_float_arr(arr2,sz2);
	print_string_arr(arr3,sz3);
	system("pause");
	return 0;
}

程序运行结果：


是的，你没看错，通过回调函数，我们同时排序了不同类型的数组元素，是不是很方便呢，同时让程序也更灵活了。



通过上面的调用和部分实现，让我们来一起模拟一个通过回调函数实现冒泡排序的算法吧！

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int compare_int(const void *elem1,const void *elem2)
{
    return *(int *)elem1-*(int *)elem2;
}

int compare_float(const void *elem1,const void *elem2)
{
	if((*(float *)elem1)-(*(float *)elem2) > 0)//不可以直接返回二者的差,\
		                                       //转化为整型时可能漏掉部分数据     
         return 1;   

	else if((*(float *)elem1)-(*(float *)elem2) == 0)
         return 0;

	else
         return -1;
}

int compare_double(const void *elem1,const void *elem2)
{
	if((*(double *)elem1)-(*(double *)elem2) > 0)//不可以直接返回二者的差,\
		                                     //转化为整型时可能漏掉部分数据     
         return 1;

	else if((*(double *)elem1)-(*(double *)elem2) == 0)
         return 0;

	else
         return -1;
}

int compare_char(const void *elem1,const void *elem2)
{
    return *(char *)elem1-*(char *)elem2;//应先找到每个字符串\
	                                     // 的首地址再进行解引用
}

int compare_string(const void *elem1,const void *elem2)
{
    return strcmp(*(char **)elem1,*(char **)elem2);//应先找到每个字符串\
	                                               // 的首地址再进行解引用
}

void Swap(size_t width,void *n1,void *n2)
{
    char tmp = 0;
	size_t i = 0;
	for(i=0; i<width; i++)
	{
	    tmp=*((char *)n1+i);
		*((char *)n1+i)=*((char *)n2+i);
		*((char *)n2+i)=tmp;
	}
}
void bubble_sort(void *base,size_t sz,size_t width,
	            int (*compare)(const void*,const void*))
{
    size_t i = 0;
	size_t j = 0;
	for(i=0; i<sz-1; i++)
	{
	    for(j=0; j<sz-1-i; j++)
		{
		    <span style="color:#ff0000;">if(compare(((char*)base+j*width),((char *)base+(j+1)*width))>0)//升序
			//if(compare((char *)base+j*width),(char *)base+(j+1)*width)>0)//降序
			Swap(width,((char *)base+j*width),((char *)base+(j+1)*width));</span>
		}
	}
}
void print_int_arr(int arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%d ",arr[i]);
	}
	printf("\n");
}
void print_float_arr(float arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%f ",arr[i]);
	}
	printf("\n");
}
void print_double_arr(double arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%lf ",arr[i]);
	}
	printf("\n");
}
void print_char_arr(char arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%c ",arr[i]);
	}
	printf("\n");
}
void print_string_arr(char *arr[],int sz)
{
    int i = 0;
	for(i=0; i<sz; i++)
	{
	    printf("%s ",arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr1[]={2,4,6,8,0,1,3,5,7,9};
	int sz1 = sizeof(arr1)/sizeof(arr1[0]);
	float arr2[]={2.0f,4.4f,6.5f,8.3f,0.0f,1.2f,3.7f,5.6f,7.9f,9.8f};
	int sz2 = sizeof(arr2)/sizeof(arr2[0]);
	double arr3[]={1.1,2.4,3.5,4.6,7.8,9.0};
	int sz3 = sizeof(arr3)/sizeof(arr3[0]);
	char arr4[]={'d','f','b','c','e','g','h','a'};
	int sz4 = sizeof(arr4)/sizeof(arr4[0]);
	char *arr5[]={"abcd", "bbdd", "aabc", "dfer","dghjf"};
	int sz5 = sizeof(arr5)/sizeof(arr5[0]);
	bubble_sort(arr1,sz1,sizeof(int),compare_int);
	bubble_sort(arr2,sz2,sizeof(float),compare_float);
	bubble_sort(arr3,sz3,sizeof(double),compare_double);
	bubble_sort(arr4,sz4,sizeof(char),compare_char);
	bubble_sort(arr5,sz5,sizeof(char *),compare_string);
	print_int_arr(arr1,sz1);
	print_float_arr(arr2,sz2);
	print_double_arr(arr3,sz3);
	print_char_arr(arr4,sz4);
	print_string_arr(arr5,sz5);
    system("pause");
	return 0;
}



各种类型的数据都可调用一个函数来排序了，怎么样，你学会了吗？


snow_5288
关注
专栏目录
冒泡排序（函数实现）
weixin_46117546的博客
11-01 2674
代码目的 实现一个对整形无序数组的冒泡排序 代码思想 （以升序为例） 冒泡排序就是将一组无序数组通过前后两两相比， 将较大者放到后面， 较小者放在前面的思想， 来达到排序的目的。 例如 5 8 2 9 我们先取前两个数字5和8进行比较， 发现符合升序， 则不做改变。（此时数组是 5 8 2 9） 再取8和2进行比较， 发现8大于2 需要调换两者位置， 则定义一个临时变量，交换两者位置。（此时数组是5 2 8 9） 再下来 取8和9进行比较，还是符合规则。则第一轮排序完毕。（此时数组是5
使用回调函数实现一个通用的冒泡排序，可以排序不同的数据类型。
lu_1079776757的博客
07-18 911
冒泡排序我们都知道，就是比较相邻的数字大小，将数组从小到大排序。（前面的博客写过这个排序），那要是用冒泡排序完成不同类型的数据的排序呢？  这一下子就让我想到了sqort，上一篇博客才写过这个函数，特别是这个函数的参数，其中最后一个参数就是一个函数指针，可以指向不同的函数。那么我们可不可以用冒泡排序模拟一下sqort函数呢？  答案是肯定的，我们可以根据不同类型的数据写几个比较函数，然后将函数
回调函数实现冒泡排序
weixin_34187862的博客
12-12 209
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。在C语言库中，有这个函数qsort（）定义在头文件：#include <stdlib.h>它接收四个参数：void qsort( void *base,...
利用函数来冒泡排序
weixin_56035334的博客
01-26 537
代码块： <script> function sort(arr) { for(var i = 0;i <= arr.length - 1;i++){ for(var j = 0;j <= arr.length - i -1;j++){ if (arr[j + 1] > arr[j]) { var temp = arr[j];
使用回调函数实现冒泡排序
loreal8的博客
03-05 190
使用回调函数实现冒泡排序 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。 回调方法 是 任何一个 被 以该回调方法为其第一个参数 的 其它方法 调用 的方法。很多时候，回调是一个当...
函数思想实现冒泡排序
小辉不会编程的博客
11-29 3243
文章目录前言一、思路二、代码解释#include 前言 冒泡排序 <函数思想> 一、思路 冒泡排序的方法为 1.比较相邻的元素，前一个比后一个大（或者前一个比后一个小）调换位置 2.每一对相邻的元素进行重复的工作，从开始对一直到结尾对，这步完成后，结尾为做大或最小的数. 3.针对除了最后一个元素重复进行上面的步骤。 4.重复1-3步骤直到完成排序 二、代码解释 #include <stdio.h> #include <stdlib.h> void fun(int a[]
[C语言] 使用回调函数实现冒泡排序
07-29
使用回调函数实现冒泡排序 本文将详细介绍如何使用C语言中的回调函数实现冒泡排序算法。冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。回调...
C++ 课程作业 数组指针与字符串1——冒泡排序（函数指针，回调函数）
04-01
本题希望通过回调函数，定义一个冒泡排序函数，可以根据函数指针指向不同的比较函数，分别实现从大到小和从小到大的排序。 希望通过这道题目，可以帮助大家理解函数指针与回调函数。本题较为简单，仅能处理整数的...
C语言-利用回调函数以及类比qsort实现冒泡排序
m0_49396613的博客
08-17 183
#include<stdio.h> #include<string.h> #include<stdlib.h> 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-1-i ;j++) { if (arr[j] > arr[j + 1]) { int tmp =
javascript排序函数实现数字排序
10-24
这个规则是可自定义的，你可以根据需要修改这个回调函数来实现不同的排序规则，比如降序排序。 接下来，文章中展示了一个使用示例。我们首先创建了一个包含多个数字的数组 numAry，并将其内容通过 document.write ...
冒泡排序函数实现
热门推荐
奥是奥特曼的奥
06-24 1万+
首先来看一下冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。代码如下：#include&lt;stdio.h&gt;#define N 5int main(){ in...
利用回调函数实现通用冒泡排序
如风逝去
07-09 337
#include #include int cmp_int(const void *e1, const void *e2)//整形数组元素比较e1>e2返回值大于0，e1<e2返回值小于0 { return (*(int *)e1) - (*(int *)e2); } int cmp_str(const void* e1, const void *e2)//字符串比较不能直接加减要用字
用函数来实现冒泡排序
HHHuYYYue的博客
03-28 1万+
冒泡排序: 冒泡排序重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把 他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 也就是说, 一直进行简单的两两比较, 直到符合所指定的顺序即可 比如说: 5, 4, 3, 2, 1, 我要用冒泡排序的方式将其排成 1, 2,...
通过函数调用来实现冒泡排序法
04-17 5175
#include int i,j,k;   int a[5]={2,1,5,6,7}; void sort(int N) {  for(i=0;i  {   for(j=0;j   {    if(a[j]>a[j+1])    {     k=a[j];    a[j]=a[j+1];    a[j+1]=k;    }   }  } } void print
使用函数进行冒泡排序
weixin_44826600的博客
09-22 1485
//冒泡排序 #include <stdio.h> #include <stdlib.h> void Swap(int* x, int* y) { int temp = * x; *x = *y; *y = temp; } //冒泡排序的参数需要设置数组的大小,因为数组作为函数的参数会隐式转换为指针,在32位系统环境下指针的大小为4个字节 BubbleSort(in...
冒泡排序之回调函数！
weixin_33675507的博客
12-16 82
前天，鹏哥上课的时候给我们讲了回调函数。虽然他噼里啪啦讲了一大堆，然而我还是听得云里雾里。。（不是我们鹏哥讲的不好啦，O(∩_∩)O哈哈~） 最重要的是 回调函数是什么，什么是回调函数。我不知道它是干什么的，我当然不会写他了。所以我就各种百度，谷歌。接下来，我就用我的话给你们讲一下 什么是回调函数。。。。。什么是回调函数（callback）回调函数是程序上的概念。本质是...
用函数实现冒泡排序
YYpoor的博客
08-07 1049
编写实现对列表元素进行冒泡排序的函数 def bubble_sort(items, ascending=True, gt=lambda x, y: x > y): """冒泡排序 :param items: 待排序的列表 :param ascending: 是否使用升序 :param gt: 比较两个元素大小的函数 :return: 排序后的列表 """ items = items[:] for i in range(1, len(it
回调函数和排序
m0_49471668的博客
08-16 170
// 实现排序 var f1 = function(){} Array.prototype.mySort = f1; var a = new Array(); var b = [2,3,1,4,5,7,9] console.log(b.sort(function(x,y){ if(x>y){ return 1; }else if(x<y){ return -1 .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值