初步认识qsort函数以及利用冒泡排序进行初步模拟
作者：互联网
首先初步认识一下
qsort 是一个库函数，包含在头文件stdlib.h中
作用：基于快速排序算法实现的一个排序函数
接下来认识这个函数所需要的参数有四个。接下来分别进行分析。
首先我们发现数据起始位置的指针用的是void*来接受，为啥呢？？？
因为我们不知道我们将来比较的数据类型为什么，有可能是int* 或者char* 又或者是结构体指针，所以我们在这放置了一个void*来接受，void*可理解为通用类型指针，可能就有人问了，既然有这个万金油的指针类型，那我们还要其他指针类型干什么？？下面给出了原因。
我们发现我们自己需要定义一个比较函数，参数类型为两个指针变量，返回类型为int 。
但是为什么这里的指针类型需要定义为void* 类型呢？？？
这里就需要我们明白指针类型的意义。
指针类型其实决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
void* 可以接受任意类型的指针，但是确定也比较明显，就是在对指针解引用操作的时候，计算机不知道它有多大的权限（可以向后访问几个字节）。
由于我们并不知道我们所要比较的元素是哪种类型的，就采用空类型来接受。而在比较的时候，我们需要将其强制转化成比较的类型，方可进行比较。具体请看下面代码展示。
对这个函数有一个初步了解之后，我们开始尝试使用这个函数。
int cmp_int(const void* e1, const void* e2)
{
if (*(int*)e1 > *(int*)e2)
return 1;
else if (*(int*)e1 < *(int*)e2)
return -1;
else
return 0;
//return *(int*)e1 - *(int*)e2;
//这种方式其实更好，利用前者减去后者，差返回就好。
//这样刚好满足这个函数的定义
//e1>e2 返回 大于0 <==> e1-e2>0
//e1<e2 返回 小于0 <==> e1-e2<0
//e1=e2 返回 0 <==> e1-e2=0
}
void my_print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(arr+i));
}
}
int main()
{
int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
my_print(arr, sz);
return 0;
}在这个过程中，我们需要比较的是int类型的元素，故将额e1和e2强制类型转换成int* 。
然后我们用qsort函数排序一下结构体。
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test3()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int main()
{
test3();
return 0;
}经过排序后的结果如下图：
我们发现年龄有原来的无序变为升序。
可以得出一个结论：利用qsort函数可以将一个无序的元素变为升序。那这里有人好奇了，那怎样才能变为降序呢？？？
其实我们只需要改变逻辑即可！原来我们创建了一个比较函数，其逻辑为
我们颠倒逻辑改为 
这样原来是升序，逻辑转换一下，就变为将序了。
经过前面的解析，已经初步明白了qsort函数的使用，我们发现qsort可以排列各种类型的数据，
那我们可以使用冒泡排序进行一个模拟，使我们的冒泡排序也可以万能呢？
首先观察一下我们原有的冒泡排序
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;
}
}
}
}
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
print_arr(arr,sz);
return 0;
}发现要使冒泡排序可以排序任何元素，要进行一些改动。
经过初步的分析，我们发现我们的冒泡排序还缺少某些参数。例如每个元素的宽度，如若知道这个整体的起始地址，再知道每个元素的宽度和元素的个数。
我们注意到，一旦冒泡排序的元素个数确定了，冒泡排序的趟数也就确定了。
其次，我们发现不同元素之间的比较方式不同，所以我们应该将比较方式提取出来，不同的数据类型采用不同的比较方式。所以就个人自行定义比较方式。
所以我们 的冒泡排序的整体大致为
void bubble_sort(void* base, int num, int width, int (*cmp)(const void*e1, const void*e2))
//base为数据的起始地址
//num为元素的个数
//width为每个元素的大小(字节)
//cpm为比较函数由于我们无法提前得知比较类型的数据，故我们的比较函数的指针类型也应该为void*,以便存放各种类型的指针。
开始模拟
先写出整体的大致思路，然后进行修改。
//冒泡排序
void my_qsort(void* base, int num, int width, int(*com_int)(const void* e1, const void* e2))
{
int i = 0;
int j = 0;
for (i = 0; i < num - 1; i++)
{
for (j = 0; j < num - 1 - i; j++)
{
/*
*if(>0)
*swap
*
*这里就是需要我们进行改变的。
*
*/
}
}
}
int main()
{
int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
int sz = sizeof(arr) / sizeof(arr[0]);
my_qsort(arr, sz, sizeof(arr[0]), com_int);
//打印数组
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}我们思考如何应该如何让判断当前两个元素的大小？？？
先写出我们的一个比较函数
首先观察我们原来的比较函数，如若前者大于后者，则进行交换。
类比与这个，我们可以写出
//比较函数
int com_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
如果cmp-int（，）大于0，则前面的数据大于后面的数据，则进行交换。
如果cmp-int（，）小于或者等于0，则前面的数据小于后面的数据，则不进行交换。
if(cmp(,)>0)
{
//交换;
}我们发现这个比较函数需要那两个待比较元素的首地址，可是我们该如何拿到这两个元素的首地址呢？？？？
我们需要计算出待比较元素的地址
如何计算呢？？
我们以整形数组为例进行演示：
那么如何寻找相邻的待比较元素的地址呢？？
再看一下这张图，我们来分析一下。其实这个过程中，相邻元素的下表一个是就 j ，一个是 j+1 。
故
//arr[j] <==>(char*)base + width*j
//arr[j+1] <==>(char*)base + width*(j+1)所以判断函数可以写成
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
/*
*
* 此处是交换函数；
*
*/
}现在我们来编写交换函数swap
首先交换函数需要传输 待交换元素的地址 ， 如果传输 待交换元素的值 ，无法达到交换的效果。但是需要注意的是我们传输过去的是一个元素的首地址（char*），但是我们不知道一个元素有几个字节(就是一个元素的宽度)？我们知道，交换元素意味着元素的整体都进行交换，而不能只交换部分。故我们也应该将宽度（大小）传过去。
if (com_int((char*)a + j * width, (char*)a + (j + 1) * width)>0)
{
swap((char*)a + j * width, (char*)a + (j + 1) * width, width);
}以整形举例，方便大家理解这个交换过程。
由于 swap的参数类型为cahr* 类型，一次只能交换一个字节，故需要交换width(即元素的宽度或者大小)次 。故函数可以写为：
void swap(char* p1,char*p2,int width)
{
for (int n = 0; n < width; n++)
{
char tmp = *(p1 + n);
*(p1 + n) = *(p2 + n);
*(p2 + n) = tmp;
}
}
通过单个字节的交换，实现元素的交换。
最终实现了利用冒泡排序实现qsort万能排序的功能。整体代码在下
//比较函数
int com_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void swap(char* p1,char*p2,int width)
{
for (int n = 0; n < width; n++)
{
char tmp = *(p1 + n);
*(p1 + n) = *(p2 + n);
*(p2 + n) = tmp;
}
}
void my_qsort(void* base, int num, int width, int(*com_int)(const void* e1, const void* e2))
{
int i = 0;
int j = 0;
for (i = 0; i < num - 1; i++)
{
for (j = 0; j < num - 1 - i; j++)
{
if (com_int((char*)a + j * width, (char*)a + (j + 1) * width)>0)
{
swap((char*)a + j * width, (char*)a + (j + 1) * width, width);
}
}
}
}
int main()
{
int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
int sz = sizeof(arr) / sizeof(arr[0]);
my_qsort(arr, sz, sizeof(arr[0]), com_int);
//打印数组
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}标签：sz,arr,int,void,qsort,冒泡排序,初步,width,char 来源： https://blog.csdn.net/m0_63711643/article/details/123595642