qsort函数及模拟实现
qsort函数的认识
qsort函数需要包含头文件 <stdlib.h> ,它能为任意类型序列排序。
格式
//qsort函数
void qsort(void* base, size_t num, size_t size,
int (*compar)(const void*, const void*));
//compar函数,不是库函数,需要使用者实现
int compar (const void* p1, const void* p2);
参数说明
qsort
-
void: 无返回值
-
void * base 需要排序的序列的起始地址,
-
size_t num: 序列的元素个数
-
size_t size: 每个元素所占的内存大小
-
int ( * compar)(const void * , const void * ): 函数指针,指向一个返回类型是int,参数为两个要比较的元素的地址,compar指向的函数实现两个元素的比较,我们需要创造这个函数,将它的地址传给qsort函数。
compar(函数名可以自定义)
p1、p2是指针变量,指向要比较的两个元素的地址
定义compar函数时,形参一定要和qsort函数形参里的函数指针指向的函数形参类型相等。
使用者实现compar函数,需要满足:
当p1指向的对象大于p2指向的对象时,return 一个大于0的数
当p1指向的对象等于p2指向的对象时,return 0
当p1指向的对象小于p2指向的对象时,return 一个小于0的数
使用qsort举例
//假设我们需要调用qsort函数对一个整型序列排序
int cmp_int(const void* p1, const void* p2)
{
if((*(int*)p1) > (*(int*)p2))
return 1;
else if((*(int*)p1) > (*(int*)p2))
return 0;
else
return -1;
}
//优化后的cmp_int
//int cmp_int(const void* p1, const void* p2)
//{
// return (*(int*)p1) - (*(int*)p2);
//}
void Print(int arr[], int len)
{
int i = 0;
for(i = 0; i < len; i++)
{
printf("%d ",arr[i]);
}
printf("\n");
}
#include <stdio.h>
#include <stdlib.h>
int main()
{
int arr[10] = {9,8,7,6,5,4,3,2,1,0};//arr数组名代表这一整型数组的首元素地址
int sz = sizeof(arr) / sizeof(arr[0]);//计算数组元素个数,存在sz中
qsort(arr, sz, sizeof(arr[0]), cmp_int);
Print(arr,sz);
return 0;
}
//假设我们需要调用qsort函数对结构数据排序
struct stu
{
char name[10];
int age;
};
//按照名字排
int cmp_struct_name(const void* p1, const void* p2)
{
return strcmp(((struct stu*)p1)->name, ((struct stu*)p1)->name);
}
//按照年龄排
int cmp_struct_age(const void* p1, const void* p2)
{
return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}
#include <stdio.h>
#include <stdio.h>
#include <string.h>
int main()
{
struct stu arr[3] = {{"zhangsan",20},{"lisi",43},{"wangermazi",18}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_str_name);
//qsort(arr, sz, sizeof(arr[0]), cmp_str_age);
return 0;
}
qsort函数的模拟实现(冒泡排序思想)
这是整型数据的冒泡排序,现在我们要将它改造成一个函数,模拟qsort函数,能够对所有数据类型排序。
//整型数据冒泡排序
void bubSort(int arr[], int len)
{
int flag = 1;
while(len-- && flag)
{
flag = 0;
for(int i = 0; i < len; i++)
{
if(arr[i+1] < arr[i])//需要修改,结构体、字符串类型不能使用<这样的关系操作符比较
{
flag = 1;
int temp = arr[i+1];
arr[i+1] = arr[i];
arr[i] = temp;
}
}
}
}
形式参数需要修改,我们模仿qsort函数的参数,参数含义与qsort函数参数一致,len的含义与以下修改后的num一样,表示序列元素个数。
void bub_qSort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*) );
冒泡排序的循环趟数这部分代码不需要改变,不论什么类型的数据都需要“跑趟”。我们把不需要修改的呈现如下:
void bub_qSort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*) );
{
int flag = 1;
while(num-- && flag)
{
flag = 0;
for(int i = 0; i < num; i++)
{
}
}
}
如果我们需要对结构体或字符串数据排序,那么就不能使用>这样的关系操作符来比较,所以相邻两个元素比较的部分需要修改。
这里就是qsort函数对于回调函数compar的使用。
compar函数返回类型int型,三种情况,所以if判断compar函数返回值大于0,就执行if后面的语句。
compar函数的参数是指向两个相邻元素的指针,所以我们需要将地址传给compar。已知序列的起始地址base,就是第一个元素的地址,那么我们怎么拿到相邻的第二个元素的地址呢?
这要看我们要排序的数据的类型,以int类型的数据为例,第一个元素的地址为base,占4个字节大小,所以要拿到第二个元素的地址,我们需要跳过4个字节的空间来寻找到它。4个字节是int类型所占空间大小,size个字节是要排序数据的类型所占的空间大小,我们将base这一指针强制转换成char*类型,这样对base进行整数相加减的步长就是1个字节,所以(char *)base + size,就是第二个元素的地址,同理第三个元素的地址是(char *)base + 2 *(size),每次相邻元素比较后,无论是否交换,我们需要继续比较下一组相邻元素,因此地址要不断变化,我们利用for循环的循环变量i,将地址改写为(char *)base + i * size 和(char *)base + (i+1)size,当i = 0时代入,要比较的两个元素的地址分别是(char *)base 和(char *)base + size;当i = 1时代入,地址为(char *)base + size 和(char *)base + 2 * size。至此,我们解决了我们的bub_Sort函数内部调用compar函数传入的实参。
完成代码的这一部分。
void bub_qSort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*) );
{
int flag = 1;
while(num-- && flag)
{
flag = 0;
for(int i = 0; i < num; i++)
{
if(compar((char*)base+i*size,(char*)base+(i+1)*size) > 0)
{
flag = 1;
}
}
}
}
接下来就是当if判断表达式为真后进行的交换操作了,这一步也需要修改。
修改前,我们定义了一个int类型的变量来实现交换,现在我们不确定定义一个什么类型的变量来实现交换。
不过,我们有数据类型的大小size,基于这一条件,我们再深一步想想这里交换就是把这两个元素地址起size大小的内存空间存储的内容进行交换。我们实现一个函数Swap来对元素进行交换,将两个元素的地址传给Swap函数,再把size传给Swap函数,我们将数据占用的内存分为size个一个字节的空间,一个一个字节地交换,用循环实现,循环交换size次。
void Swap(char* p1, char* p2, size_t size)
{
int i = 0;
for(i = 0; i < size; i++)
{
char temp = *p1;
*p1 = *p2;
*p2 = temp;
p1++;
p2++;
}
}
void bub_qSort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*) );
{
int flag = 1;
while(num-- && flag)
{
flag = 0;
for(int i = 0; i < num; i++)
{
if(compar((char*)base+i*size, (char*)base+(i+1)*size) > 0)
{
flag = 1;
Swap((char*)base+i*size, (char*)base+(i+1)*size, size);
}
}
}
}
代码至此完成。
我们测试一下,用整型数据。
#include <stdio.h>
void Print_arr(int arr[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
}
void Swap(char* p1, char* p2, size_t size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char temp = *p1;
*p1 = *p2;
*p2 = temp;
p1++;
p2++;
}
}
void bub_qSort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
{
int flag = 1;
while (num-- && flag)
{
flag = 0;
for (int i = 0; i < num; i++)
{
if (compar((char*)base + i * size, (char*)base + (i + 1) * size) > 0)
{
flag = 1;
Swap((char*)base + i * size, (char*)base + (i + 1) * size, size);
}
}
}
}
int cmp_int(const void* p1, const void* p2)
{
if ((*(int*)p1) > (*(int*)p2))
return 1;
else if ((*(int*)p1) > (*(int*)p2))
return 0;
else
return -1;
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };//arr数组名代表这一整型数组的首元素地址
int sz = sizeof(arr) / sizeof(arr[0]);//计算数组元素个数,存在sz中
bub_qSort(arr, sz, sizeof(arr[0]), cmp_int);
Print_arr(arr, sz);
return 0;
}
代码运行结果: