qsort函数的模拟实现！！！不会还有新手没看过吧？！
1. 先看原版冒泡排序
如果不了解什么是冒泡排序或者冒泡排序的原理，可以看看博主的另一篇博客哦！
链接放这里了：别划走！真的不看看全是干货的初级C语言练习题吗？一滴水都没有哦还有解析_小江同学～12345的博客-CSDN博客
#include
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++)//eg.i=0,排第一趟，排10-1-0=9趟；i=1，排第二趟，排10-1-1=8趟
{
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,5,8,2,10,3,1,4,7,6 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);//10
//对arr进行排序，排成升序
//arr是数组，对数组arr传参，实际上只传数组arr首元素的地址 &arr[0]
bubble_sort(arr, sz);//冒泡排序函数
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
} 2. qsort的简单介绍
qsort是一个库函数，可以直接使用，是用来排序的，可以排任意类型的数据的顺序；默认排序成升序。而在排序过程中必定会涉及到比较大小。
以下是qsort的定义：
2.1 浅分析qsort
void qsort(void* base,//base指向待排序的第一个元素
size_t num,//待排序的元素个数
size_t size,//待排序的每个元素大小，单位是字节
int(*compar)(const void*,const void*)
//compar是一个函数指针，指向的函数能够比较2个元素的大小，
//compare指针指向的函数的参数是：要比较2个元素的地址
//分3种情况
//1.前>后 返回一个>0的数
//2.前<后 返回一个<0的数
//3.前==后 返回一个=0的数
);要比较什么类型的元素，就传什么类型到比较函数，从而达到qsort可以比较任意类型的元素
具体看如下：
2.2 浅析void*
void*是一种指针类型，是无具体类型的指针，是通用指针类型。
void*类型的指针变量，可以接收任意数据类型的地址，但是只能存放地址，不能解引用，也不能进行+1，-1等一系列操作。
void*方便别人使用，因为你不知道别人使用什么类型的指针
#include
int main()
{
int a=20;
int * p=&a;
char * pc=&a;//int *---->char *//err，会报错
void * pv=&a;//int *---->void *//运行成功
//pv+1;//err
//* pv;//err
return 0;
} 
3. 模拟实现需要的改变
原来的冒泡排序只能接收整型，只能比较整型大小，交换的方式也只适用于整型。
咱就是说，一整个都被“整型”困住了！！！
而qsort能实现任意数据类型的排序，所以我们要改造这3个地方！
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;
}
}
}
}1.改造参数 ——>让这个函数能够接受任意类型的数据
2.改造比较方法——>让函数能够在排序时，比较不同类型的数据
3.改造交换的代码 ——>让函数实现任意数据类型的交换
3.1 初步实现
模拟实现qsort（采用冒泡排序方式），排序整型数据
#include
void print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void test1()
{
int arr[] = { 3,7,8,9,4,2,5,6,1,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);//实现冒泡排序
//利用bubble_sort模拟实现qsort
print(arr, sz);//打印数组元素
}
int main()
{
test1();
return 0;
} 3.2 bubble_sort的初步实现
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(void* e1, void* e2))//类比于qsort函数
{
//确定趟数
int i = 0;
for (i = 0; i < sz - 1; i++)
{
//确定每趟排序次数
int j = 0;//比大小
for (j = 0; j < sz - 1 - i; j++)
{
if ( )//限制条件：前>后
{
//交换
}
}
}
}那么，我们要怎么实现限制条件呢？
3.2.1 限制条件的实现
原来的冒泡排序中的if语句是这样的：
if(arr[j]>arr[j+1])这是因为排序的类型是整型，可是我们现在范围要扩大了。
3.2.1.1 如何获得相邻元素地址
如下图，有这样一组数组，现在，我想得到下标为2和3的元素的地址：
我们可以通过指针来找到相应的元素下标地址
但是，我们怎么得到呢？
这时候，width就派上用场了！！！
数组在内存中是连续存放的！
（首元素地址+n*width）就是对应地址了！！！（n：第（n-1）个元素对应的下标n；width：该数据类型的大小）
由于不知道void*是什么类型，我们需要强制类型转换成我们需要的类型
以下是小江列举的一些类型：
由此可见，在不知道数据类型的情况下，char类型是最合适的，因为大小是1个字节
由此，可以得到：
3.2.1.2 if语句的代码实现
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(void* e1, void* e2))//类比于qsort函数
{
//确定趟数
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();
}
}
}
}我们交换顺序的话，也需要函数实现
3.2.2 交换函数的初步实现
3.2.2.1 如何交换相邻元素地址
这里，我们依旧以交换下标为2和3的元素的地址为例：
3.2.2.2 swap函数的代码实现
void swap(char* e1, char* e2,int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = * e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(void* e1, void* e2))//类比于qsort函数
{
//确定趟数
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);
}
}
}
}3.3 cmp_int函数的代码实现
int cmp_int(void* e1, void* e2)
{
return *(int*)e1 - *(int*)e2;
//知道e1和e2的类型，自己实现排序比较，强制类型转换成相应类型，然后解引用
}4.总代码实现
#include
int cmp_int(void* e1, void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void swap(char* e1, char* e2,int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = * e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(void* e1, void* e2))//类比于qsort函数
{
//确定趟数
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);
}
}
}
}
void print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void test1()
{
int arr[] = { 3,7,8,9,4,2,5,6,1,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);//实现冒泡排序
print(arr, sz);//打印
}
int main()
{
test1();
return 0;
} 
运行结果示意图
5.拓展：结构体类型数据排序
这里，小江为了方便就用age作为排序依据了，感兴趣的朋友可以自己尝试一下用name作为依据排序
#include
struct Stu
{
char name[20];
int age;
};
int cmp_age(void* e1, void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void swap(char* e1, char* e2,int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = * e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(void* e1, void* e2))//类比于qsort函数
{
//确定趟数
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);
}
}
}
}
void test2()
{
struct Stu a[] = { {"xiaohong",23},{"xiaozhang",45},{"fugui",38} };
int sz = sizeof(a) / sizeof(a[0]);
bubble_sort(a, sz, sizeof(a[0]), cmp_age);
}
int main()
{
test2();
return 0;
} PS：小江目前是个新手小白，水平也不高。欢迎大家在评论区讨论哦！有问题也可以讨论的！
如果对你有帮助的话，记得点赞+收藏⭐️+关注➕