qsort函数详解及模拟实现

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;
}

代码运行结果：