c语言模拟实现qsort

要想模拟首先qsort函数 首先我们应该知道这个函数的功能是什么 接下来我为大家引入一个列子 我们想要实现一组有序数的升序 可以通过冒泡排序法 思想是  两两相邻元素进行比较 代码如下 

通过冒泡排序法 

#define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
void bubble_int(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[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_int(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}
	return 0;
}

 结果如下

 利用qsort函数实现对整型排列

qsort的功能

首先说一下qsort函数的形式 void qsort(void* base,size_t num,size_t width,  int (*cmp)(const void* e1, const void* e2）其中 e1-e1是升序  反之就是降序

void qsort(void* base, //待排序的数组的起始地址
//          size_t num,    //元素个数
//          size_t width,  //一个元素的大小
//          int (*cmp)(const void* e1, const void* e2)/);

接下来我们改动上方代码 利用qsort函数实现对一组有序整型数组升序 代码展示

#include<stdio.h>
#include <stdlib.h> //sqort
int com_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;//对两个元素进行比较  e1-e2 升序  e2-e1降序
}
void test1()//使用qsort对数组进行排序，升序
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);//计算字符串长度
	qsort(arr, sz, sizeof(arr[0]), com_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}

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

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

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

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

回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应.  然而，递归函数 是一种函数直接或间接调用自身的函数。它常用于解决具有重复结构的问题，比如计算阶乘、斐波那契数列、遍历树结构等。

递归函数有两个重要部分：

1. 递归终止条件：防止递归无限执行。
2. 递归调用：函数调用自身，逐步缩小问题的规模。

利用qsort 实现对结构体的排序 代码如下

#include <stdlib.h> //sqort
#include<stdio.h>
#include <string.h>  //字符串长度
//使用qsort排序结构体
struct stu//定义结构体
{
	char name[20];
	int age;
};
int com_stu_by_age(const void* e1, const void* e2)//通过年龄进行比较
{
	return ((struct stu*)e1)->age  -  ((struct stu*)e2)->age;//e2强制类型转换(struct stu*) 指向  age
}
int com_stu_by_name(const void* e1, const void* e2)
{
	return   strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
//比较名字 利用//strcmp 进行对字符串的比较  从而实现对名字的比较
}
void test2()
{
	struct stu s[3] = { {"zhangsan",20},{"lisi",50},{"wangwu",33} };
	int sz = sizeof(s) / sizeof(s[0]);
	//qsort(s, sz, sizeof(s[0]), com_stu_by_age);
	qsort(s, sz, sizeof(s[0]), com_stu_by_name);

   struct stu* p = s;//将结构体数组地址递给一个新定义的结构体指针，然后再用循环的方式将其打印
 for (p = s; p < &s[3]; p++)
  {
      printf("%s,%d\n", (*p).name, (*p).age);
}
}
int main()
{
test2();
return 0;
}

在vs2019编译器中通过调试 监视我们发现   对于名字的升序如下

 

 运行结果如下

模拟实现qsort 

 如何模拟实现qsort?  由于使用上方的代码使用的目标比较单一 模拟实现qsort函数  我们首先要创建自己的函数  bubbl_sort(); 具体实现方法  代码如下

#include<stdio.h>
//改造冒泡排序函数，这个函数可以排序任意指定的数组

void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void* e1, const void* e2))
{
	//对于第一个参数而言 不确定未来传过来的是什么类型的数组 为了能接受任意参数的地址  所以使用void*   
	// 由于不知道元素类型 所以根据width 判断什么类型 到底多大 由于width 
	// sz返回的一定是整数 所以使用size_t  表示无符号的整数 unsigedint
		//趟数  cmp 指针
	//由于不知道比较的参数是什么 所以返回类型为void*
	//趟数
	size_t i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j=0;j < sz - 1 - i; j++)
		{
			//利用指针比较  利用两两比较的方式 利用偏移量 计算2个元素的地址 
			// 先把base 指针强制类型转换(char*)  j * width 跳过的元素 (char*)base + j * width也就是下标为j元素的地址
			//把这两个元素的地址传给e1 e1
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);	//	}
			}
		}
	}
}
void Swap(char* buf1, char* buf2, int width)//交换两个元素的地址
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
//使用我们自己写的bubble_sort函数排序整型
void test3()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);//计算字符串长度
	bubble_sort(arr, sz, sizeof(arr[0]), com_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}
void test4()
{
	struct stu s[3] = { {"zhangsan",20},{"lisi",50},{"wangwu",33} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), com_stu_by_age);
	//bubble_sort(s, sz, sizeof(s[0]), com_stu_by_name);
	struct stu* p = s;//将结构体数组地址递给一个新定义的结构体指针，然后再用循环的方式将其打印
	for (p = s; p < &s[3]; p++)
	{
		printf("%s,%d\n", (*p).name, (*p).age);
	}

}
int main()
{

	test3();
	test4();
	return 0;
}

运行结果如下 

沉鱼落雁，闭月羞花。