使用回调函数模拟实现qsort（冒泡的方式）

最新推荐文章于 2024-09-21 00:11:16 发布
最新推荐文章于 2024-09-21 00:11:16 发布
阅读量838 收藏 17
点赞数 40
文章标签： 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjyioo/article/details/141307056
版权

目录

回调函数

qsort函数

冒泡排序

模拟实现

交换条件的编写

交换方法的编写

不同类型参数比较函数的编写

调试

元素类型为int的数组

排序结构数据：（name）

排序结构数据：（age）

总结

回调函数

回调函数就是⼀个通过函数指针调⽤的函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

qsort函数

qsort - C++ 参考 (cplusplus.com)

 qsort函数的介绍如下图:

void qsort (void* base, size_t num, size_t size,
            int (*compar)(const void*,const void*));

冒泡排序

 冒泡排序的核心思想就是：两两相邻的元素进行比较

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

模拟实现

在原bubble_sort中，我们根据整形数组的地址以及计算所得其中的元素个数进行排序，这一点与qsort函数中前两项的参数恰好符合。

需要进行调整的是，size_t size（数组中每个元素的大小），int(*compar)(const void*,const void*)（指向比较两个元素函数的指针） 。

建立新的函数：

void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void*, const void*)

所以对比原bubble_sort，我们所建立的两层循环可以随数组的变化而变化，但是交换条件却要进行调整。原本的交换条件已经无法适应新的交换数据。

//符合条件进行交换
if(arr[j]>arr[j+1])
{
    int tmp = arr[j];
    arr[j] = arr[j+1];
    arr[j+1] = tmp;
}

//需要对交换部分进行修改

交换条件的编写

根据qsort函数，我们得知，qsort是根据函数指针的返回结果来判断是否需要进行交换的，因此，我们也需要调用函数指针来完成交换条件的编写：

//按照升序排序
if(cmp(函数参数,后一个函数参数)>0)
{
    //交换
}

 类比整形数据的交换，我们需要找到每个元素在数组中所对应的下标进行访问，并且找到下一个元素进行比较。

//原bubble_sort交换条件
if(arr[j]>arr[j+1])

如何解决？

首先，我们需要根据数组的类型来确定数组+1能变化的步长。

当数组中的每个元素为char类型时，+1会跳过1个字节。为int类型时，+1会跳过4个字节。每个类型+1跳过的字节数各有差异。同时，bubble_sort在传参时的参数之一 size_t width 表示的是数组中每一个元素的大小（以字节为单位）。以单位字节的步长确定每个元素在数组中的位置是最精确方法。所以需要将数组指针类型强制转换为char*

根据循环条件j++，我们可以利用j的变化来完成对交换条件的编写

if(cmp((char*)base+j*width,(char*)base+(j+1)*width)>0)
{
    //交换
}
(char*)base+j*width//前一个要进行比较的元素

(char*)base+(j+1)*width//后一个要进行比较的元素

交换方法的编写

因为传入的数组指针类型各不相同，要进行交换的方法也必须要符合各个类型。

根据交换条件，我们找到了要进行比较的前一个元素和后一个元素，所以在交换时，也同样是对这两个元素进行交换。同时，因为我们将这两个元素的数组指针类型强制转换位char*，所以当交换时也需要一个字节一个字节进行交换，这里可以调用形参width（表示数组中每个元素的大小，以字节为单位）套用循环进行交换。

我们可以自定义函数Swap来完成交换：

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

自定义函数Swap的定义：

void Swap(char* f1, char* f2, int width)
{
    char tmp = 0;
    int i = 0;
    for(i = 0;i<width;i++)//一个字节一个字节交换两个元素
    {
        tmp = *f1;
        *f1 = *f2;
        *f2 = tmp;
        
        f1++;
        f2++;
    }
}

不同类型参数比较函数的编写

对于bubble_sort中形式参数int(*cmp)(const void*, const void*)，这个函数需要自己设计，对于不同类型需要给出不同的解决方案。

但相同的是，返回类型始终为int

当前一个参数大于后一个参数时，返回大于0的数

当前一个参数等于后一个参数时，返回0

当前一个参数小于后一个参数时，返回小于0的数

以int类型的参数为例：

当函数对参数进行接收时，我们不知道参数的类型，所以需要用void*来进行接收。

当数组为整形数组时，我们需要根据条件调用对应的回调函数。因为void*类型的指针不能进行解引用和+-整数的操作，我们需要先将指针类型强制转换为int*类型，再进行解引用操作。

比较前后两个元素的大小，我们可以利用减法，大时返回>0的数，等时返回0，小时返回<0的数。

int int_cmp(const void* p1, const void* p2)
{
    return *(int*)p1-*(int*)p2;
}

以结构数据为例：

我们同样需要比较大小来返回值。

struct Stu
{
    char name[20];
    int age;
};

当根据name来进行比较时，我们需要对比字符串来完成。对比字符串就需要一个库函数strcmp来完成。

strcmp：

对比strcmp和qsort，它们的相同点是，返回值相同：

当前一个参数大于后一个参数时，返回大于0的数

当前一个参数等于后一个参数时，返回0

当前一个参数小于后一个参数时，返回小于0的数

 所以在比较name时，可以如此编写：

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

在比较age时，与int类型相似，可以如此编写：

int age_cmp(const void* p1, const void* p2)
{
    return ((struct Stu*)p1)->age-((struct Stu*)p2)->age;
}

调试

元素类型为int的数组

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int int_cmp(const void* p1, const void* p2)
{
    return *(int*)p1 - *(int*)p2;
}
void print(int arr[], int sz)//打印数组
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
void Swap(char* f1, char* f2, int width)
{
    char tmp = 0;
    int i = 0;
    for (i = 0; i < width; i++)//一个字节一个字节交换两个元素
    {
        tmp = *f1;
        *f1 = *f2;
        *f2 = tmp;

        f1++;
        f2++;
    }
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void* , const void* ))//冒泡排序
{
    int i = 0;
    //需要进行多少趟排序
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        //每趟需要进行多少次
        for (j = 0; j < sz - 1 - i; 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 main()
{
    int arr[] = { 0,9,8,7,6,5,4,3,2,1 };
    int sz = sizeof(arr) / sizeof(arr[0]);

    print(arr, sz);//0 9 8 7 6 5 4 3 2 1
    bubble_sort(arr, sz, sizeof(arr[0]), int_cmp);
    print(arr, sz);//0 1 2 3 4 5 6 7 8 9   
    return 0;
}

排序结构数据：（name）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Stu
{
    char name[20];
    int age;
};
int name_cmp(const void* p1, const void* p2)
{
    return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void Swap(char* f1, char* f2, int width)
{
    char tmp = 0;
    int i = 0;
    for (i = 0; i < width; i++)//一个字节一个字节交换两个元素
    {
        tmp = *f1;
        *f1 = *f2;
        *f2 = tmp;

        f1++;
        f2++;
    }
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void* , const void* ))//冒泡排序
{
    int i = 0;
    //需要进行多少趟排序
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        //每趟需要进行多少次
        for (j = 0; j < sz - 1 - i; 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 main()
{
    struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
    int sz = sizeof(arr) / sizeof(arr[0]);

    bubble_sort(arr, sz, sizeof(arr[0]), name_cmp);  
    return 0;
}

排序结构数据：（age）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Stu
{
    char name[20];
    int age;
};
int age_cmp(const void* p1, const void* p2)
{
    return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
void Swap(char* f1, char* f2, int width)
{
    char tmp = 0;
    int i = 0;
    for (i = 0; i < width; i++)//一个字节一个字节交换两个元素
    {
        tmp = *f1;
        *f1 = *f2;
        *f2 = tmp;

        f1++;
        f2++;
    }
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void* , const void* ))//冒泡排序
{
    int i = 0;
    //需要进行多少趟排序
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        //每趟需要进行多少次
        for (j = 0; j < sz - 1 - i; 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 main()
{
    struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
    int sz = sizeof(arr) / sizeof(arr[0]);

    bubble_sort(arr, sz, sizeof(arr[0]), age_cmp);  
    return 0;
}

总结

使用回调函数模拟实现qsort（冒泡的方式）对于我来说有些难度，尤其是在对交换条件和交换方法进行编写时需要考虑到数组指针的类型以及不同类型给指针带来的不同权重。但是通过类比原bubble_sort函数，对照着思考便可以理清我们的思路。在用回调函数对各个不同类型的参数进行比较时，也要考虑到类型所带来的差异。这次模拟实现对我们学习指针以及提高自己的思维能力有很大的帮助！

sjyioo
关注
C语言——使用回调函数模拟实现qsort
CPP_ZhouXuyang的博客
09-05 590
通过模拟qosrt和对bulble_sort的改造，了解学习泛型编程
使用回调函数，模拟实现qsort（采用冒泡的方式）
KYG__U_O的博客
08-30 220
冒泡排序算法的原理 1.比较相邻的元素，如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 代码演示 冒泡排序 - 只能排序整型数组 #include<stdio.h> void BubbleSort(int arr[], int sz) { in...
使用冒泡排序和回调函数模拟实现qsort函数
qq_43167575的博客
11-22 169
qsort函数是一个快速排序函数，在stdlib.h文件中定义，函数原型为viod qsort(void* base, size_t nelem,size_t width,int(*Comp)(const void* ,const void*));*base为要排序的数组名，nelem 为要排序数组的长度，width为数组元素的大小（一字节为单位）默认是从小到大排序的， （*Comp）(const...
C语言 回调函数 · qsort函数使用 · 采用冒泡和回调方式模拟实现qsort
sfg0861的博客
07-09 365
是不是一脸懵？ 没事，先把回调函数的定义放在一边，我们看一下冒泡排序吧还记得冒泡排序吗？ 冒泡排序是比较基础的排序方法。其中有个弊端就是，设计出来只能对一种同类型的数据排序。有没有一种方法，能让我对 int 类型数据排序后，再去对 double 类型数据排序，甚至对结构体类型数据排序呢？有，这就是要介绍的 qsort函数，它也算是回调函数的一种。 它一共有四个参数，返回类型是 void。解析： 通俗来说： 我 qsort 函数什么类型都能排序， 但是你要把要排序的数组arr告诉我，数组元素有几个告诉我，数组
【使用回调函数利用冒泡排序的思想模拟实现qsort函数】
qq_73900397的博客
09-29 271
一招学会——使用回调函数利用冒泡排序的思想模拟实现qsort函数
回调函数（模拟实现qsort,采用冒泡的方式）
sophia__yu的博客
02-25 280
回调函数是一个通过函数指针调用的函数。如果把函数指针（地址）作为参数传给另一个函数，当这个指针被用来调用其所指的函数时，称为回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外一方调用的，用于对该事件或条件进行响应。首先，了解下qsort函数：利用qsort写代码：如果数组类型为float呢？下面模拟实现qsort(采用冒泡的方式）：请看下列代码：结果为：如果是指针数...
使用回调函数，模拟实现qsort(采用冒泡的方式)
lxt-st
04-01 142
首先，我们说一下什么是回调函数？ 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另一方调用的，用于对该事件或条件进行响应。 如果你还不了解函数指针的相关内容，可先选择看我的上一篇博客，点击下方进入： ...
C语言回调函数和qsort的使用与模拟
cccyi7的博客
06-14 364
C语言回调函数的含义，回调函数的使用。C语言库函数qsort的使用方法与模拟
回调函数及qsort应用实例&&使用回调函数模拟实现冒泡排序
weixin_50601177的博客
02-25 116
回调函数及qsort应用实例&&使用回调函数模拟实现冒泡排序
回调函数，qsort函数，与qsort函数的模拟
GangStudyIT的博客
12-01 380
回调函数： 回调函数就是一个通过函数指针调用的函数，如果你把函数的指针作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这个函数为回调函数， 回调函数不是由该函数的实现方法直接调用，而是在特定的事件或者条件时由另外的一方调用，用于对该事件或者条件响应。 简单的说，就是一个函数的参数里面有一个函数指针参数，而这个函数指针对应的函数要自己用函数实现。很通俗，具体用途，我们来
使用冒泡排序思想模拟实现库函数qsort()
TRick_Love的博客
09-15 243
模拟实现库函数。运用冒泡排序算法和回调函数
C语言--指针进阶2--函数指针、函数指针数组、指向函数指针数组的指针、回调函数、qsort()函数示例与模拟实现
羟基与苯的博客
03-24 749
文章目录六、函数指针七、函数指针数组7.1函数指针数组的定义7.2函数指针数组的用途--转移表八、指向函数指针数组的指针九、回调函数9.1回调函数演示之一9.2回调函数演示之二（qsort()函数） 六、函数指针 顾名思义，函数指针就是指向函数的指针，即存放函数地址的指针。 void test() { printf("hehe\n"); } int main() { printf("%p\n", test); printf("%p\n", &test); return 0; } 输出结果
qsort排序函数的模拟实现
zhanghangqian的博客
09-22 163
引言 大家都知道，我们在平常的C语言学习中，经常会遇到一些整型、字符串的排序，因此就要用到qsort函数来进行排序，今天我们就来莫模拟库函数qsort的实现 常用的整型排序函数（从小到大） 1.使用for循环排序整型jiandan void bubble_sort(int arr[], int sz) { //趟数 int i = 0;//一趟冒泡排序 for (i = 0; i < sz - 1; i++) { int j = 0; for (j = 0; j ...
《C语言回调函数详解——模拟实现qsort万能排序函数》
whelloworldw的博客
11-11 123
当我们谈及回调函数时，qsort函数可以说是回调函数应用中的一个经典案例。qosrt函数的功能是非常强大的，之所以称之它为万能排序函数，顾名思义它可以对任意数据类型的数据进行排序，它底层实现排序的算法是快速排序，并不受外界条件所限制。而这种强大的功能就是建立在回调函数所实现的。函数原型接受排序的数组名、数组元素的个数、每个元素所占空间的大小（单位是字节）、以及回调函数//qsort函数的应用//函数原型：//void qsort(void* base, //接收的需要排序的数组，数组名。
程序人生-2024我的个人总结
车轮的博客
09-21 872
其实从裁到现在变化最大的是心境，以前尼是总有各种项目，无尽的电话，以及各种事在屁股后面追着我，而且每天三点一线，家-单位-家，最主要是每天就是盼着周末和节假日，之后等到被裁之后，天天家里一待，都快抑郁了，主要是也去面试了很多，不是挂羊头卖狗肉，就是培训班，要不就是稍微沾点边的工作，左思右想之下，决定创业，创业之后，是不闲着了，但是确实心里没底，以前在单位，每个月起码不用担心五险一金，而且还有商业保险，累了还能请假，创业了就是给自己打工，这还是没招人，招人还得心思工资啥的。
基于Vue、JavaScript、HTML、CSS的myshop电商平台设计源码
09-27
该项目是一款基于Vue、JavaScript、HTML和CSS构建的myshop电商平台设计源码，总计包含94个文件，涵盖32个PNG图片、22个JavaScript文件、13个Vue组件文件、13个JPG图片文件、3个GIF图片文件、3个SCSS样式文件，以及其他必要的配置和管理文件。
基于c语言的对自己电脑系统测试.zip
09-27
基于c语言的对自己电脑系统测试.zip
基于Labview的-转子动平衡测控系统
最新发布
09-27
基于Labview的--转子动平衡测控系统
C语言函数指针与回调函数详解
回调函数则是利用函数指针实现的一种高级特性，它使得在特定条件下调用函数成为可能，而调用时机不由函数自身决定，而是由其他代码控制。 首先，我们要了解函数指针的基本用法。在C语言中，我们可以定义一个函数...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值