1. Toy模板网首页
  2. > Toy博客

深入理解回调函数qsort：从入门到模拟实现

9月前 作者：江池俊 分类：Toy博客 阅读(50) 违法举报

这篇具有很好参考价值的文章主要介绍了深入理解回调函数qsort：从入门到模拟实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

  • 💓博客主页：江池俊的博客
  • ⏩收录专栏：C语言进阶之路
  • 👉专栏推荐：✅C语言初阶之路 ✅数据结构探索
  • 💻代码仓库：江池俊的代码仓库
  • ​🎪 社区：GeekHub社区 ​
  • 🎉欢迎大家点赞👍评论📝收藏⭐

深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

前言

回调函数和 qsort 是 C语言编程中重要的概念，它们为我们提供了强大的工具，用于处理函数指针和数组排序。本篇博客将逐步介绍回调函数的概念，详细解释 qsort 函数的用法，并通过一个模拟实现，帮助初学者更好地理解这些概念。如果大家不知道函数指针是说明或还不清楚函数指针的内容，可以移步我这篇文章《掌握指针进阶：一篇带你玩转函数指针、函数指针数组及指向函数指针数组的指针！！》

一、什么是回调函数？

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

📌使用回调函数的优势

  1. 代码重用： 可以将通用的操作封装在回调函数中，以供多个函数重复使用。
  2. 灵活性： 回调函数允许我们在运行时动态地指定要执行的代码，从而实现更高度的灵活性。
  3. 解耦合： 使用回调函数可以将代码分解成独立的模块，减少模块之间的耦合，提高代码的可维护性。

二、qsort 函数及其用法

qsort 是 C 标准库中提供的用于数组排序的函数，它接受一个 比较函数 作为参数，用于确定数组元素的顺序。（这个比较函数是使用者根据自己的需要设计的，因此qsort函数可以实现对任意类型数据的排序）qsort 函数的原型如下：

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

其中，base 是要排序的数组的指针；num 是数组中元素的数量；size 是每个元素的大小，以字节为单位；compar 是用于比较两个元素的函数指针。

这里我们可以通过cplusplus网来查询这个函数的使用方法，也可以使用菜鸟教程网来查询。

📌qsort函数作用

深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

📌qsort函数4个参数的介绍

深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

📌为什么qsort函数的参数是这四个？

qsort 函数之所以有这四个参数，是为了实现通用、灵活且可定制的排序功能。

这些参数的设计和使用有以下几个目的：

  1. 通用性： 由于 qsort 需要适应不同类型的数据，它通过 base 参数接受数组的指针，并使用 size 参数来了解每个元素的大小，从而使得排序操作可以应用于各种不同类型的数组。

  2. 灵活性： 通过传递比较函数的指针作为 compar 参数，我们可以在不同的排序场景中定义不同的比较逻辑。这使得我们可以根据需要实现升序、降序或自定义的排序规则。

  3. 可定制性： qsort 的设计允许我们在排序过程中自定义元素的比较方式。我们可以根据实际需求提供不同的比较函数，从而实现不同的排序需求。

  4. 高效性： qsort 内部使用一种高效的排序算法（通常是快速排序的变种），以确保在大多数情况下能够高效地完成排序操作。

综上所述，这四个参数的设计使得 qsort 函数成为一个强大且通用的排序工具，可以适应不同类型的数据、实现不同的排序规则，并且在实际应用中能够高效地完成排序任务。

📌第4个参数—>compar比较函数的剖析

深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享
在 qsort 函数中，要实现升序或降序排序，这需要根据比较函数的逻辑来确定元素的顺序。比较函数的返回值将决定元素的排列方式。

  • 如果比较函数返回负值，qsort 将认为第一个元素应该在第二个元素之前（即第一个元素应该小于第二个元素），从而实现升序排序。
  • 如果比较函数返回正值，qsort 将认为第一个元素应该在第二个元素之后（即第一个元素应该大于第二个元素），从而实现降序排序。
  • 如果比较函数返回零，qsort 将认为两个元素相等，它们的顺序将是未定义的。

注意：

  • qsort 函数的比较函数参数是两个 void 类型的指针，是为了提高灵活性和通用性。这样的设计允许您在不同的排序场景中使用同一个 qsort 函数，无论排序的数据类型是什么。
  • 当编写一个通用的排序函数时，我们无法预先知道要排序的数据类型是什么。因此，将比较函数的参数声明为 void 类型的指针，使得 qsort 函数可以接受任何类型的数据。

由此，我们可以得到qsort函数的使用模板如下：

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

// 定义一个的数据类型（示例：整数类型）
typedef int MyType;

// 比较函数
int compareMyType(const void *a, const void *b) {
    return (*(MyType *)a - *(MyType *)b);//实现升序
    //return (*(MyType *)b - *(MyType *)a);//实现降序
}

int main() {
    int numElements = ...; // 数组中元素的数量
    MyType arr[numElements]; // 声明并初始化一个数组

    // 使用 qsort 对数组进行排序
    qsort(arr, numElements, sizeof(MyType), compareMyType);

    // 打印排序后的数组
    for (int i = 0; i < numElements; i++) {
        printf("%d ", arr[i]); // 打印数组元素
    }

    return 0;
}

三、qsort函数实例

注意：以下统一以升序为例

📌排序int类型数组

代码展示：

#include<stdio.h>
#include<stdlib.h>
//实现一个比较整型的函数
int compare_int(const void* a, const void* b)
{
	return *(int*)a - *(int*)b;//强制转换为int类型并解引用
}

//使用qsort对数组进行排序，升序
int main()
{

	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	//排序
	qsort(arr,sz,sizeof(int),compare_int);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

📌排序char类型数组

代码展示：

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

int compare_char(const void* a, const void* b)
{
	return *(char*)a - *(char*)b; //强制转换为char类型并解引用
}

int main()
{
	char arr[] = { 'f', 'e','d','b','a','c' };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%c ", arr[i]);
	}
	//排序
	qsort(arr, sz, sizeof(arr[0]), compare_char);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%c ", arr[i]);
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

📌排序浮点型数组

代码展示：

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

int compare_float(const void* a, const void* b)
{
	float num1 = *(float*)a;
	float num2 = *(float*)b;

	if (num1 < num2) return -1;
	if (num1 > num2) return 1;
	return 0;
}

int main()
{
	float arr[] = { 5.2 , 2.5 , 3.14 , 1.5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%f ", arr[i]);
	}
	//排序
	qsort(arr, sz, sizeof(arr[0]), compare_float);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%f ", arr[i]);
	}
	printf("\n");
	return 0;
}

注意：

  • 由于浮点数的精度和范围有限，返回差值可能导致精度丢失和不稳定的结果，特别是在极端情况下。因此，在处理浮点数时，使用差值可能会引发一些问题。
  • 为了确保排序的稳定性和正确性，最好的做法是显式地使用 if 语句来比较元素的值，并返回 -1、0 或 1，以确保在各种情况下都能获得正确的比较结果。

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

📌排序结构体类型数组

代码展示：

1. 【按姓名来排序】 

//按姓名来排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Student
{
	char name[20];
	int age;
}stu;

int compare_name(const void* a, const void* b)
{
	return strcmp( ((stu*)a)->name, ((stu*)b)->name );//比较字符大小使用strcmp函数
	//strcmp函数返回值与compare_name函数一致
}

int main()
{
	stu s[3] = { {"张三",20},{"李四",18},{"王五",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	//排序
	qsort(s, sz, sizeof(s[0]), compare_name);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

2. 【按年龄来排序】

代码展示：

//按年龄来排序
#include <stdio.h>
#include <stdlib.h>
typedef struct Student
{
	char name[20];
	int age;
}stu;

int compare_age(const void* a, const void* b)
{
	return (((stu*)a)->age - ((stu*)b)->age);
}

int main()
{
	stu s[3] = { {"张三",20},{"李四",18},{"王五",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	//排序
	qsort(s, sz, sizeof(s[0]), compare_age);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

四、模拟实现qsort函数

这里我是基于冒泡函数的思路来实现qsort函数的（实际上qsort函数的排序思路是快速排序） 冒泡排序的设计在本篇文末

🧩冒泡排序

#include<stdio.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 - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
int main()
{
    int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("冒泡排序前：\n");
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    //冒泡排序
    bubble_sort(arr, sz);
    printf("\n冒泡排序后：\n");
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

  1. 这里我们发现bubble_sort函数中用来接收待排序数组首元素地址的指针arr已经被写死了，是int*类型，这就表它只能对整型数组进行排序。
  2. 其次函数内部对数组元素的比较和交换只适用于int类型的数据。

现在将利用冒泡排序来实现qsort函数，让它能排序任意类型的数据，该怎么做呢？

  • 首先我们知道qsort函数的创作者，他并不知道我们将来需要排序什么类型的数组，但是呢？他却通过qsort函数实现了各种类型数组的排序，这是怎么做到的呢？这就得益于这个函数的4个参数了。
  • 因此，只要我们给qsort函数提供 待排序数组首元素的地址，数组中元素的个数，数组中每个元素所占内存空间的字节大小，以及一个 比较函数 就能实现对这个数组的排序。所以我们也可以通过这些参数来用冒泡排序的思想实现对任意类型数组的排序。

🧩bubble_sort函数（模拟实现的qsort函数）

值得注意的是，这里说的利用冒泡排序来实现qsort函数，仅仅是实现了qsort函数可以对任意类型的数组进行排序这一特点，并不是说实现了qsort函数的底层原理，qsort的底层其实是通过快速排序来实现的。

//利用冒泡排序实现qsort
void Swap(char* e1, char* e2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *e1;
		*e1 = *e2;
		*e2 = tmp;
		e1++;
		e2++;
	}
}
//注意：这里的compar函数需要根据待排序的类型来书写
void bubble_sort(void* arr, int sz, size_t width, int(*compar)(const void* e1, const void* e2))
//第一个参数 - 用来接收待排序数组的首元素地址，因为待排序的数组元素类型不确定，所以形参数组用void*来接收
//第二个参数 - 用来接收数组元素个数
//第三个参数 - 用来接收数组中每个元素的大小，单位是字节
//第四个参数 - 用来接收一个比较函数，根据待排序数组元素的类型来传递对应类型的比较函数
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是排序好的
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (compar((char*)arr + j * width, (char*)arr + (j + 1) * width) > 0)
				//因为我们并不知道数组元素的类型，所以需要将元素转化为最小的char*类型，
				//即把arr强转为char*类型，arr就可以正常使用，且char*与width配合能访问到任意类型任意位置处的数组元素
				//char类型指针+1只会跳过一个字节，+ j*width表示跳过j个元素
			{
				//交换
				//由于这里的数组名已经被强转为char类型的指针
				//所以要交换数组中的元素，就只能一个字节一个字节进行交换
				Swap((char*)arr + j * width, (char*)arr + (j + 1) * width, width);
				//前两个参数是待交换元素的地址，第三个参数是待交换元素的所占字节的大小
				flag = 0;//如果数组元素进行交换了，说明数组还没有排好序
			}	
		}
		if (flag == 1)//如果没有再交换数组元素，就说明数组已经排好序
		{
			break;
		}
	}
}

🚩Swap函数剖析

Swap 函数用于交换两个元素的内容，它接受三个参数，这三个参数的作用如下：

void Swap(void* e1, void* e2, size_t width);

  1. void* e1: 指向第一个待交换元素的指针。由于数组的元素类型是未知的，所以使用 void* 类型来表示元素的指针。在函数内部，你需要将其转换为正确的类型，以便进行元素交换。

  2. void* e2: 指向第二个待交换元素的指针。同样，你需要在函数内部将其转换为正确的类型，以便进行交换操作。

  3. size_t width: 表示每个元素所占的字节数。由于元素类型未知，但在 bubble_sort 函数中有提供，所以通过这个参数确保在进行元素交换时能够正确地按字节进行操作。

  • 在 Swap 函数内部，通过使用 width 参数，以字节为单位逐个交换两个元素的内容。这种设计使得 Swap 函数在不知道元素实际类型的情况下，仍能够正确地交换元素内容。
  • 虽然在实际代码中，可能会使用更高级的语言特性来进行元素交换（例如 C++ 中的模板函数或 C 中的宏），但是在这个示例中，通过使用 void* 指针和 字节级的操作，实现了一个通用的元素交换函数。

🧩利用bubble_sort函数排序整型数组

代码展示：

#include<stdio.h>
//利用bubble_sort函数排序整型数组
void Swap(char* e1, char* e2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *e1;
		*e1 = *e2;
		*e2 = tmp;
		e1++;
		e2++;
	}
}

void bubble_sort(void* arr, int sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是排序好的
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (compar((char*)arr + j * width, (char*)arr + (j + 1) * width) > 0)//实现升序
			{
				Swap((char*)arr + j * width, (char*)arr + (j + 1) * width, width);
				flag = 0;//如果数组元素进行交换了，说明数组还没有排好序
			}
		}
		if (flag == 1)//如果没有再交换数组元素，就说明数组已经排好序
		{
			break;
		}
	}
}
//比较函数
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
//主函数
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：\n");
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	//排序
	bubble_sort(arr, sz, sizeof(int), cmp_int);
	printf("\n排序后：\n");
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

🧩利用bubble_sort函数排序结构体数组

1. 【按姓名来排序】

代码展示：

//按姓名来排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//利用bubble_sort函数排序结构体数组
void Swap(char* e1, char* e2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *e1;
		*e1 = *e2;
		*e2 = tmp;
		e1++;
		e2++;
	}
}

void bubble_sort(void* arr, int sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是排序好的
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (compar((char*)arr + j * width, (char*)arr + (j + 1) * width) > 0)//实现升序
			{
				Swap((char*)arr + j * width, (char*)arr + (j + 1) * width, width);
				flag = 0;//如果数组元素进行交换了，说明数组还没有排好序
			}
		}
		if (flag == 1)//如果没有再交换数组元素，就说明数组已经排好序
		{
			break;
		}
	}
}
//声明一个结构体，并重命名为stu
typedef struct student
{
	char name[20];
	int age;
}stu;
//比较函数
int compare_name(const void* a, const void* b)
{
	return strcmp( ((stu*)a)->name, ((stu*)b)->name );//strcmp函数返回值与compare_name函数一致
}

int main()
{
	stu s[3] = { {"张三",20},{"李四",18},{"王五",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	//排序
	bubble_sort(s, sz, sizeof(s[0]), compare_name);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

2. 【按年龄来排序】

代码展示：

//按年龄来排序
#include <stdio.h>
#include <stdlib.h>
//利用bubble_sort函数排序结构体数组
void Swap(char* e1, char* e2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *e1;
		*e1 = *e2;
		*e2 = tmp;
		e1++;
		e2++;
	}
}

void bubble_sort(void* arr, int sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是排序好的
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (compar((char*)arr + j * width, (char*)arr + (j + 1) * width) > 0)//实现升序
			{
				Swap((char*)arr + j * width, (char*)arr + (j + 1) * width, width);
				flag = 0;//如果数组元素进行交换了，说明数组还没有排好序
			}
		}
		if (flag == 1)//如果没有再交换数组元素，就说明数组已经排好序
		{
			break;
		}
	}
}
//声明一个结构体，并重命名为stu
typedef struct student
{
	char name[20];
	int age;
}stu;
//比较函数
int compare_age(const void* a, const void* b)
{
	return (((stu*)a)->age - ((stu*)b)->age);
}

int main()
{
	stu s[3] = { {"张三",20},{"李四",18},{"王五",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	printf("排序前：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	//排序
	bubble_sort(s, sz, sizeof(s[0]), compare_age);
	//打印
	printf("\n排序后：");
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d", s[i].name, s[i].age);
		if (i < sz - 1)
			printf(" | ");
	}
	printf("\n");
	return 0;
}

运行结果：
深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享

总结

回调函数和 qsort 是 C 语言编程中重要的概念，能够提供强大的灵活性和功能。通过理解回调函数的概念，我们可以将特定行为作为参数传递给其他函数，实现代码的模块化和解耦合。qsort 则为数组排序提供了便利，允许我们自定义比较逻辑以满足不同的需求。

通过以上的介绍和模拟实现，希望初学者们能够更好地理解回调函数和 qsort 的核心概念，为日后的编程实践打下坚实的基础。无论是构建灵活的程序结构还是优化代码性能，这些概念都将成为你编程工具箱中不可或缺的工具。

🔥今天的分享就到这里， 如果觉得博主的文章还不错的话， 请👍三连支持一下博主哦🤞

深入理解回调函数qsort：从入门到模拟实现,C语言进阶之路,c语言,开发语言,学习,经验分享文章来源地址https://www.toymoban.com/news/detail-682938.html

到了这里，关于深入理解回调函数qsort：从入门到模拟实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C语言库函数之 qsort 讲解、使用及模拟实现

    C语言库函数之 qsort 讲解、使用及模拟实现

    我们在学习排序的时候，第一个接触到的应该都是冒泡排序，我们先来复习一下冒泡排序的代码，来作为一个铺垫和引入。 代码如下： 很简单的一种排序方法，但我们可以发现一个问题，那就是冒泡排序不够通用，它只能用于整型数组的排序，如果我要排序float类型，或者排

    2024年02月12日
    浏览(38)
  • C语言-指针进阶-qsort函数的学习与模拟实现（9.3）

    C语言-指针进阶-qsort函数的学习与模拟实现（9.3）

    目录 思维导图： 回调函数 qsort函数介绍 模拟实现qsort 写在最后： 什么是回调函数？ 回调函数是一个通过函数指针调用的函数。 将一个函数指针作为参数传递给一个函数，当这个指针被用来调用所指向函数时， 我们就将此称为回调函数。 在举例之前，我们先学习一个C语言

    2024年02月15日
    浏览(54)
  • 【C语言】指针的进阶（二）—— 回调函数的讲解以及qsort函数的使用方式

    【C语言】指针的进阶（二）—— 回调函数的讲解以及qsort函数的使用方式

    目录 1、函数指针数组 1.1、函数指针数组是什么？  1.2、函数指针数组的用途：转移表 2、扩展：指向函数指针的数组的指针 3、回调函数 3.1、回调函数介绍  3.2、回调函数的案例：qsort函数 3.2.1、回顾冒泡排序  3.2.1、什么是qsort函数？ 函数指针数组 是什么？首先主语是 数

    2024年02月07日
    浏览(43)

  • 深入理解 Promise、async、回调函数和 AJAX

    简介：本篇博客将介绍 Promise、async、回调函数和 AJAX，这些是在 JavaScript 中处理异步编程和数据交换的关键技术。我们将通过代码示例和解释来详细说明它们的基本用法和优势。 下面是一个简单的示例，展示 Promise 的基本用法： 在创建 Promise 对象时，传递的参数是一个执行

    2024年02月10日
    浏览(44)
  • 冒泡排序模拟实现qsort()函数

    冒泡排序模拟实现qsort()函数

    要模拟qsort()函数，我们首先要知道qsort()函数的特点： 使用快速排序的方法。 适用于任何数据类型的排序。 但由于部分学者还没有学习快速排序算法，所以本篇博客采用冒泡排序来模拟功能类似于qsort（）的函数bubble_sort。 C库对qsort()函数解释： 我们得到的关于qsort()函数参

    2024年02月16日
    浏览(53)
  • qsort函数的应用以及模拟实现

    qsort函数的应用以及模拟实现

    🎈个人主页:🎈 :✨✨✨初阶牛✨✨✨ 🐻推荐专栏: 🍔🍟🌯 c语言进阶 🔑个人信条: 🌵知行合一 🍉本篇简介::介绍库函数qsort函数的模拟实现和应用 金句分享: ✨追光的人，终会光芒万丈.✨ 库函数查询网站(建议使用 旧版本 查询) 头文件: stdlib.h 功能介绍: 使用函数 确定顺

    2024年02月02日
    浏览(35)
  • 【C】回调函数和qsort详解

    【C】回调函数和qsort详解

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

    2024年02月13日
    浏览(36)
  • 模拟实现qsort函数（采用冒泡排序的方式）

    模拟实现qsort函数（采用冒泡排序的方式）

    前言： 之前我在C语言：指针详解【进阶】后篇中提到了 qsort函数 , qsort函数 作为一个库函数，在我们日常的代码编写中可能会用到，在上面提到的文章中我们也进行使用了这个函数，大家也了解了一些这个函数的使用方法，但我们作为学习者，我们不仅要会用，还要知道这

    2024年02月05日
    浏览(42)

  • c语言中回调函数的理解和使用

    返回总目录 回调函数是通过函数指针实现的。可以将调用者和被调用者进行解耦，通过一个函数指针可以关联不同的函数实现，实现前提是函数指针和函数实现的参数类型一致，用户通过把需要调用函数的指针作为参数传递给一个函数进行实现，可以实现个功能模块之间的解

    2024年02月15日
    浏览(29)
  • 函数探秘：深入理解C语言函数，实现高效模块化编程

    函数探秘：深入理解C语言函数，实现高效模块化编程

    ✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C语言学习 贝蒂的主页：Betty‘s blog 在数学中我们就知道了函数这个概念，而C语言同样引入了函数这个概念，那C语言的函数到底是什么样的呢？ 在C语言中， 函数也叫子程序，它是一段可以

    2024年03月09日
    浏览(66)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包