qsort函数使用方法总结

news2024/11/17 20:21:40

目录

一、qsort函数原型

二、compar参数

三、各种类型的qsort排序

1. int 数组排序 

2. 结构体排序 

3. 字符串指针数组排序 

4. 字符串二维数组排序

四、回调函数

1. 什么是回调函数

2. 为什么要用回调函数？

3. 怎么使用回调函数？

4.下面是一个四则运算的简单回调函数例子：

五、qsort函数的模拟实现

一、qsort函数原型

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

头文件:<stdlib.h> 函数功能：qsort()函数的功能是对数组进行排序，数组有nmemb个元素，每个元素大小为size。 

参数base - base指向数组的起始地址，通常该位置传入的是一个数组名 

参数nmemb - nmemb表示该数组的元素个数 

参数size - size表示该数组中每个元素的大小（字节数） 

参数(*compar)(const void *, const void *) - 此为指向比较函数的函数指针，决定了排序的顺序。 

函数返回值：无 

注意：如果两个元素的值是相同的，那么它们的前后顺序是不确定的。也就是说qsort()是一个不稳定的排序算法。

二、compar参数

compar参数是qsort函数排序的核心内容，它指向一个比较两个元素的函数，注意两个形参必须是const void *型，同时在调用compar 函数（compar实质为函数指针，这里称它所指向的函数也为compar）时，传入的实参也必须转换成const void *型。在compar函数内部会将const void *型转换成实际类型，见下文。

int compar(const void *p1, const void *p2);

如果compar返回值小于0（< 0），那么p1所指向元素会被排在p2所指向元素的前面，如果compar返回值等于0（= 0），那么p1所指向元素与p2所指向元素的顺序不确定，如果compar返回值大于0（> 0），那么p1所指向元素会被排在p2所指向元素的后面。因此，如果想让qsort()进行从小到大（升序）排序，那么一个通用的compar函数可以写成这样： 

int compare (const void * a, const void * b)
 {
   if ( *(MyType*)a <  *(MyType*)b ) return -1;
   if ( *(MyType*)a == *(MyType*)b ) return 0;
   if ( *(MyType*)a >  *(MyType*)b ) return 1;
 }

注意：你要将MyType换成实际数组元素的类型。 或者

//升序排序
int compare(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}
//降序排列
int compare(const void* a, const void* b)
{
	return (*(int*)b - *(int*)a);
}

三、各种类型的qsort排序

1. int 数组排序 

#include <stdio.h>     
#include <stdlib.h>     

int values[] = { 40, 10, 100, 90, 20, 25 };

int compare(const void* a, const void* b)
{
    return (*(int*)a - *(int*)b);
}

int main()
{
    int n;
    qsort(values, sizeof(values) / sizeof(values[0]), sizeof(int), compare);
    for (n = 0; n < sizeof(values) / sizeof(values[0]); n++)
        printf("%d ", values[n]);
    return 0;
}

2. 结构体排序 

#include <stdio.h>
#include<stdlib.h>
// void qsort(void* base, size_t num, size_t size, int(*compare)(const void*, const void*))

typedef struct
{
    char name[30];   // 学生姓名
    int Chinese;    // 语文成绩
    int Math;        // 数学成绩  
    int English;     // 英语成绩
}st;
int cmp(const void* a, const void* b)
{
    st* pa = (st*)a;
    st* pb = (st*)b;
    int num1 = pa->Chinese + pa->English + pa->Math;
    int num2 = pb->Chinese + pb->English + pb->Math;

    //return (int)num1 - num2;   // 从小到大，
    return (int)num2 - num1;   //  从大到小
}
int main(void)
{
    st students[7] = {
        {"周",97,68,45},
        {"吴",100,32,88},
        {"郑",78,88,78},
        {"王",87,90,89},
        {"赵",87,77,66},
        {"钱",59,68,98},
        {"孙",62,73,89}
    };
    qsort(students, 7, sizeof(st), cmp);   // 注意区别 students 与 st

    for (int i = 0; i < 7; i++)
    {
        printf("%s%4d%4d%4d\t", students[i].name, students[i].Chinese, students[i].Math, students[i].English);
        printf("总分：%d\n", students[i].Chinese + students[i].English + students[i].Math);
    }

    system("pause");
    return 0;
}

3. 字符串指针数组排序 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int compare(const void* arg1, const void* arg2);

int main(int argc, char** argv)
{
    int i;

    char* arr[5] = { "i", "love", "c", "programming", "language" };

    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(char*), compare);

    for (i = 0; i < 5; i++) {
        printf("%s ", arr[i]);
    }
    printf("\n");

}

int compare(const void* arg1, const void* arg2) {
    char* a = *(char**)arg1;
    char* b = *(char**)arg2;
    int result = strcmp(a, b);
    if (result > 0) {
        return 1;
    }
    else if (result < 0) {
        return -1;
    }
    else {
        return 0;
    }
}

那么我们向qsort传入arr之后，qsort将arr理解为指向数组中第一个元素的指针，所以形参表中，arg1和arg2其实是指向“指向常量字符串的指针”的指针，是char**。而我们需要传给strcmp这个字符串比较函数的，是“指向字符串的指针”，是char*，所以我们将void*转换为char**，然后解引用，得到char*，赋予a和b。接下来使用strcmp对a和b进行比较。(数组名本身算一层指针，而里面的内容又是一层指针，数组存放的是指向字符串的地址) 

4. 字符串二维数组排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int compare(const void* arg1, const void* arg2);

int main(int argc, char** argv)
{
    int i;

    char arr[5][16] = { "i", "love", "c", "programming", "language" };

    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare);
    printf("%s\n", arr[0]);
    for (i = 0; i < 5; i++) {
        printf("%s ", arr[i]);
    }
    printf("\n");
}

int compare(const void* arg1, const void* arg2) 
{
    char* a = (char*)arg1;
    char* b = (char*)arg2;
    int result = strcmp(a, b);
    if (result > 0) {
        return 1;
    }
    else if (result < 0) {
        return -1;
    }
    else {
        return 0;
    }
}

这里对二维数组进行排序，其实是对二维数组的第二维中存放的字符串进行排序。所以qsort(arr, sizeof(arr)/sizeof(arr[0]), sizeof(arr[0]), compare);对qsort函数的调用中，第二个参数是待排元素的个数（5个），第三个参数是待排元素的大小（16）。

我们将arr传入qsort函数，qsort函数将arr理解为指向数组第一个元素的指针，arr的第一个元素是arr[0][0]，所以参数arg1和arg2指的是指向"a[i][0]"的指针，我们知道，a[i][0]是字符，就是char，所以arg1和arg2指的是char *。我们将void*转换为char*，赋予a和b，调用strcmp函数对a和b进行比较。

四、回调函数

1. 什么是回调函数

我们先来看看百度百科是如何定义回调函数的：

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

这段话比较长，也比较绕口。下面我通过一幅图来说明什么是回调：

假设我们要使用一个排序函数来对数组进行排序，那么在主程序(Main program)中，我们先通过库，选择一个库排序函数(Library function)。但排序算法有很多，有冒泡排序，选择排序，快速排序，归并排序。同时，我们也可能需要对特殊的对象进行排序，比如特定的结构体等。库函数会根据我们的需要选择一种排序算法，然后调用实现该算法的函数来完成排序工作。这个被调用的排序函数就是回调函数(Callback function)。

结合这幅图和上面对回调函数的解释，我们可以发现，要实现回调函数，最关键的一点就是要将函数的指针传递给一个函数(上图中是库函数)，然后这个函数就可以通过这个指针来调用回调函数了。注意，回调函数并不是C语言特有的，几乎任何语言都有回调函数。在C语言中，我们通过使用函数指针来实现回调函数。

我的理解是：把一段可执行的代码像参数传递那样传给其他代码，而这段代码会在某个时刻被调用执行，这就叫做回调。

如果代码立即被执行就称为同步回调，如果过后再执行，则称之为异步回调。

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

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

2. 为什么要用回调函数？

因为可以把调用者与被调用者分开，所以调用者不关心谁是被调用者。它只需知道存在一个具有特定原型和限制条件的被调用函数。

简而言之，回调函数就是允许用户把需要调用的方法的指针作为参数传递给一个函数，以便该函数在处理相似事件的时候可以灵活的使用不同的方法。

int Callback()    ///< 回调函数
{
    // TODO
    return 0;
}
int main()     ///<  主函数
{
    // TODO
    Library(Callback);  ///< 库函数通过函数指针进行回调
    // TODO
    return 0;
}

回调似乎只是函数间的调用，和普通函数调用没啥区别。

但仔细看，可以发现两者之间的一个关键的不同：在回调中，主程序把回调函数像参数一样传入库函数。

这样一来，只要我们改变传进库函数的参数，就可以实现不同的功能，这样有没有觉得很灵活？并且当库函数很复杂或者不可见的时候利用回调函数就显得十分优秀。

3. 怎么使用回调函数？

#include <stdio.h>
int Callback_1(int a)   ///< 回调函数1
{
    printf("Hello, this is Callback_1: a = %d \n", a);
    return 0;
}

int Callback_2(int b)  ///< 回调函数2
{
    printf("Hello, this is Callback_2: b = %d \n", b);
    return 0;
}

int Callback_3(int c)   ///< 回调函数3
{
    printf("Hello, this is Callback_3: c = %d \n", c);
    return 0;
}

int Handle(int x, int (*Callback)(int)) ///< 注意这里用到的函数指针定义
{
    Callback(x);
}

int main()
{
    Handle(4, Callback_1);
    Handle(5, Callback_2);
    Handle(6, Callback_3);
    return 0;
}

看看结果：

 

如上述代码：可以看到，Handle()函数里面的参数是一个指针，在main()函数里调用Handle()函数的时候，给它传入了函数Callback_1()  /  Callback_2()  /  Callback_3()的函数名，这时候的函数名就是对应函数的指针，也就是说，回调函数其实就是函数指针的一种用法。

4.下面是一个四则运算的简单回调函数例子：

#include <stdio.h>
#include <stdlib.h>

/****************************************
 * 函数指针结构体
 ***************************************/
typedef struct _OP {
    float (*p_add)(float, float);
    float (*p_sub)(float, float);
    float (*p_mul)(float, float);
    float (*p_div)(float, float);
} OP;

/****************************************
 * 加减乘除函数
 ***************************************/
float ADD(float a, float b)
{
    return a + b;
}

float SUB(float a, float b)
{
    return a - b;
}

float MUL(float a, float b)
{
    return a * b;
}

float DIV(float a, float b)
{
    return a / b;
}

/****************************************
 * 初始化函数指针
 ***************************************/
void init_op(OP* op)
{
    op->p_add = ADD;
    op->p_sub = SUB;
    op->p_mul = &MUL;
    op->p_div = &DIV;
}

/****************************************
 * 库函数
 ***************************************/
float add_sub_mul_div(float a, float b, float (*op_func)(float, float))
{
    return (*op_func)(a, b);
}

int main(int argc, char* argv[])
{
    OP* op = (OP*)malloc(sizeof(OP));
    init_op(op);

    /* 直接使用函数指针调用函数 */
    printf("ADD = %f, SUB = %f, MUL = %f, DIV = %f\n", (op->p_add)(1.3, 2.2), (*op->p_sub)(1.3, 2.2),
        (op->p_mul)(1.3, 2.2), (*op->p_div)(1.3, 2.2));

    /* 调用回调函数 */
    printf("ADD = %f, SUB = %f, MUL = %f, DIV = %f\n",
        add_sub_mul_div(1.3, 2.2, ADD),
        add_sub_mul_div(1.3, 2.2, SUB),
        add_sub_mul_div(1.3, 2.2, MUL),
        add_sub_mul_div(1.3, 2.2, DIV));

    return 0;
}

五、qsort函数的模拟实现

使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。

注意：这里第⼀次使用 void* 的指针，讲解 void* 的作⽤。

#include <stdio.h>

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

void Swap(char* buf1, char* buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++) 
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_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++)
		{
			//if (arr[j] > arr[j + 1])
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				/*int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;*/
				//交换
				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");
}

void test()
{
	//设计和实现bubble_sort2(),这个函数能够排序任意类型的数据
	int arr[] = { 3,1,5,7,9,2,4,0,8,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

int main()
{
	test();
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1226615.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux | C语言中volatile关键字的理解

Linux | C语言中volatile关键字的理解

目录 前言 一、代码引入 二、现象解释 三、具体引用 前言 本章主要讲解介绍volatile关键的作用与使用场合&#xff1b;深刻理解volatile关键字&#xff1b;本文你需要有信号相关的基础知识&#xff1b; Linux | 信号-CSDN博客 一、代码引入 首先&#xff0c;我们来查看下面…
阅读更多...
CICD 持续集成与持续交付（2）

CICD 持续集成与持续交付（2）

目录 gitlab 部署 jenkins 部署 配置 实时触发 自动化构建docker镜像 通过ssh插件交付任务 添加jenkins节点 RBAC pipeline jenkins结合ansible参数化构建 安装ansible 新建gitlab项目 jenkins新建项目playbook gitlab 部署 虚拟机最小需求&#xff1a;4G内存 4核cpu 下载&…
阅读更多...
年货FPS大作，艾尔莎EA B450M-E和你玩转《使命召唤20》

年货FPS大作，艾尔莎EA B450M-E和你玩转《使命召唤20》

说到动视旗下的《使命召唤》系列&#xff0c;相信大家都不陌生&#xff0c;它以出色爽快的游戏体验以及精良的画面著称&#xff0c;而且每年一部的更新节奏也是如今为数不多的“年货”游戏之一了。时至今日&#xff0c;该系列已经来到了第20部作品&#xff0c;也就是《使命召唤…
阅读更多...
第20章 数据库编程

第20章 数据库编程

通过本章需要理解JDBC的核心设计思想以及4种数据库访问机制&#xff0c;理解数据库连接处理流程&#xff0c;并且可以使用JDBC进行Oracle数据库的连接&#xff0c;理解工厂设计模式在JDBC中的应用&#xff0c;清楚地理解DriverManager类的作用&#xff0c;掌握Connection、Prep…
阅读更多...
简历技术栈redis点

简历技术栈redis点

熟悉Redis常见的数据类型以及缓存问题&#xff0c;如缓存穿透、雪崩 、击穿等 Redis五种数据类型 Redis常用命令 查看所有 keys * 字符串类型string 常用命令 举例&#xff1a; 放置一个字符串数据到redis中&#xff0c;先为数据定义一个名称&#xff0c;比如name,age等&am…
阅读更多...
⑩⑤【DB】详解MySQL存储过程：变量、游标、存储函数、循环，判断语句、参数传递..

⑩⑤【DB】详解MySQL存储过程：变量、游标、存储函数、循环，判断语句、参数传递..

个人简介&#xff1a;Java领域新星创作者&#xff1b;阿里云技术博主、星级博主、专家博主&#xff1b;正在Java学习的路上摸爬滚打&#xff0c;记录学习的过程~ 个人主页&#xff1a;.29.的博客 学习社区&#xff1a;进去逛一逛~ MySQL存储过程 1. 介绍2. 使用3. 变量①系统变…
阅读更多...
OceanBase：Zone管理

OceanBase：Zone管理

OceanBase 集群由若干个 Zone 组成。从物理层面来讲&#xff0c;一个 Zone 通常是一个独立的物理部署单元&#xff0c;可以是一个数据中心&#xff08;IDC&#xff09;或者云上的一个 Zone&#xff08;可用区&#xff09;&#xff0c;也可以是一个单独的机架&#xff08;Rack&a…
阅读更多...
大模型的视觉能力

大模型的视觉能力

摘要&#xff1a; 计算机视觉引领了人工智能中深度学习的采用&#xff0c;这表明在大型注释数据集上预训练的模型可以转移到许多下游设置。现在&#xff0c;在网络规模的原始数据而不是策划的数据集上进行预训练&#xff0c;基础大模型在计算机视觉中正在崛起。这些模型…
阅读更多...
时间序列与 statsmodels：预测所需的基本概念（2）

时间序列与 statsmodels：预测所需的基本概念（2）

时间序列与 statsmodels&#xff1a;预测所需的基本概念&#xff08;2&#xff09; 维托米尔约万诺维奇 跟随 出版于 走向发展 4 分钟阅读 2022 年 1 月 31 日 8 一、说明 在使时间序列平稳后&#xff0c;在本博客中我们应用 SARIMAX 预测并进行深入解释。 二、关于平稳性 …
阅读更多...
C++多线程编程（2）：四种线程管理方法

C++多线程编程（2）：四种线程管理方法

文章首发于我的个人博客&#xff1a;欢迎大佬们来逛逛 文章目录 线程管理get_idsleep_forsleep_untilyield 线程管理 有一个this_thread的名称空间中定义了许多的线程管理方法&#xff1a; get_id&#xff1a;获取当前线程idsleep_for&#xff1a;当前线程休眠一段时间sleep_…
阅读更多...
计算机组成原理-双端口RAM和多模块存储器

计算机组成原理-双端口RAM和多模块存储器

文章目录 存取周期总览双端口RAM多体并行存储器低地址交叉编址有多少个存储体合适&#xff08;体号&#xff09;多模块存储器&#xff08;多体存储器&#xff09;总结实际场景 存取周期 总览 双端口RAM RAM&#xff1a;用于主存或高速缓存&#xff0c;断电数据丢失 多体并行…
阅读更多...
实验五：Java多线程程序设计

实验五：Java多线程程序设计

一、线程接力 编写一个应用程序&#xff0c;除了主线程外&#xff0c;还有三个线程&#xff1a;first、second和third。first负责模拟一个红色的按钮从坐标&#xff08;10&#xff0c;60&#xff09;运动到&#xff08;100&#xff0c;60&#xff09;&#xff1b;second负责模…
阅读更多...
自动 ARIMA 超参数搜索

自动 ARIMA 超参数搜索

一、介绍 这种用于自动超参数搜索进行预测的开发方法可能会花费大量时间&#xff0c;但它可以带来回报&#xff0c;因为当您找到预测模型的最佳参数时&#xff0c;它将节省时间并提高预测的精度。此外&#xff0c;手动尝试可能会花费您最多的时间&#xff0c;但这种方法在某些情…
阅读更多...
不知道如何制作产品图册的，赶紧收藏住！

不知道如何制作产品图册的，赶紧收藏住！

产品图册是展示产品外观、功能和特点的重要工具&#xff0c;对于销售和推广产品至关重要。然而&#xff0c;制作一本高质量的产品图册并不是一件容易的事情。如果你没有经验或者不确定如何着手&#xff0c;那么这篇文章将为你提供一些实用的建议和技巧&#xff0c;帮助你轻松制…
阅读更多...
Java调用com组件之jacob

Java调用com组件之jacob

一、背景介绍 现有标准的 win32 com组件&#xff0c;有如下的参数&#xff1a; 属性 值 说明Program IDyinhai.yh_hb_sctrCOM ClassIDCOM ClassName COClass_yh_hb_sctr Interface TypeDual InterfaceInterface NameIyh_hb_sctr 具有一个方法&#xff1a; yh_hb_call( string…
阅读更多...
三、LED闪烁

三、LED闪烁

通过LED的闪烁实验&#xff0c;详解Keil MDK中创建mm32单片机的工程的步骤。 1、开发环境 (1)Keil MDK: V5.38.0.0 (2)MCU: mm320163D7P。 2、Keil工程的创建 (1)打开Keil MDK。 (2)点击“Project”→“New μVision Project...”。 (3)选择工程保存地址及工程文件名&…
阅读更多...
基于Springboot的地方美食分享网站(有报告)。Javaee项目，springboot项目。

基于Springboot的地方美食分享网站(有报告)。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的地方美食分享网站(有报告)。Javaee项目&#xff0c;springboot项目。 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。 项目介绍&#xff1a; 采用…
阅读更多...
数据挖掘复盘——apriori

数据挖掘复盘——apriori

read_csv函数返回的数据类型是Dataframe类型 对于Dataframe类型使用条件表达式 dfdf.loc[df.loc[:,0]2]df: 这是一个DataFrame对象的变量名&#xff0c;表示一个二维的表格型数据结构&#xff0c;类似于电子表格或SQL表。 df.loc[:, 0]: 这是使用DataFrame的.loc属性来进行…
阅读更多...
devops底层是怎么实现的

devops底层是怎么实现的

DevOps的3大核心基础架构 简而言之&#xff0c;实现DevOps工具链&#xff0c;基本需要3个核心基础架构&#xff1a; SCM配置管理系统 Automation自动化系统 Cloud云&#xff08;或者说可伸缩的、自服务的、虚拟化系统&#xff09; SCM配置管理系统 SCM中所放置的内容又可以再…
阅读更多...
系列十、你说你做过JVM调优和参数配置，请问如何盘点JVM系统的默认值？

系列十、你说你做过JVM调优和参数配置，请问如何盘点JVM系统的默认值？

一、JVM的参数类型 1.1、标配参数 java -versionjava -help 1.2、XX参数 1.2.1、Boolean类型 公式&#xff1a;-XX:或者- 某个属性值 表示开启、-表示关闭 # 是否打印GC收集细节 -XX:PrintGCDetails -XX:-PrintGCDetails# 是否使用串行垃圾收集器 -XX:UseSerialGC -XX:-UseS…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023