C语言学习（12）-- 进阶指针 - qsort函数

qsort函数

首先，在我们学习qsort函数之前，先来回顾先前学习过的冒泡算法。冒泡算法的实现解决了很多排序问题，但实际上针对的仅仅只是整型类型的数组元素排序。那如果数组元素类型是浮点型，或者结构体类型呢？单纯使用冒泡算法就不能实现了。于是引入了库函数qsort函数。

qsort - quick sort - 快速排序

void qsort(void* base,

                 size_t num,

                 size_t width,

                 int(*compare)(const void* elem1,const void* elem2));

• base - 目标数组的起始位置
• num - 数组元素个数
• width - 一个元素有几个字节
• compare - 比较函数 - 根据不同的场景选择不同的比较方法 - 返回值如下图所示
• elem1 和 elem2 - 是需要比较的两个元素的地址

其中针对于void* 类型的指针还需要格外注意。

• void* 类型的指针 不能进行解引用操作；例如以下的操作，会造成非法间接寻址
• void* 类型的指针 可以接收任意类型的地址
• void* 类型的指针 不能进行+-整数的操作 因为不知道步长大小

如果要使用qsort函数，其中主要注意的就是compare比较函数。比较函数根据不同的场景进行具体的设定。拿比较两个整型元素的函数cmp_int来说，传入参数是两个比较元素的地址，这个元素的类型是任意的，返回值为整型，这主要是根据compare的函数定义来看。在官网中该函数的返回值，只要是e1>e2就返回正值，e1<e2就返回负值，e1=e2就返回0.

例如：写比较两个整型元素的比较函数。

首先想到的就是用存放在e1中的内容和存放在e2中的内容作比较，即想到分别对e1和e2进行解引用。但这样实际是行不通的，在该函数中，该参数的类型是void* 类型指针，是不可以进行解引用的。于是想到强行将void*类型指针转换为int*类型的指针，就可以进行解引用处理。根据返回值的定义，直接两者相减，即可得到正确排序答案。

比较两个浮点型元素同上。对于要比较一个结构体中内容，思路同上，只是需要注意的是需要转换成为结构体指针再进行比较。以及字符串的比较要用到strcmp()

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Stu
{
    char name[20];
    int age;
};

int cmp_int(const void* e1,const void* e2)
{
    //比较两个整型元素
    return *(int*)e1 - *(int*)e2;    
}
int cmp_float(const void* e1,const void* e2)
{
    //比较两个浮点型元素
    return *(float*)e1 - *(float*)e2;    
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age ;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
    return strcmp(((struct Stu*)e1)->name,((struct Stu*)e2)->name);
}
void test1()
{
    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]), cmp_int);
    int i = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%d ",arr[i]);
    }
}
void test2()
{
    float f[] = {9.0, 8.0, 7.0, 6.0, 5.0};
    int sz = sizeof(f)/sizeof(f[0]);
    qsort(f, sz, sizeof(f[0]), cmp_float);
    int i = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%f ",f[i]);
    }
}
void test3()
{
    struct Stu s[3] = {{"zhangsan",20},{"lisi",30},{"wangwu",10}};
    int sz = sizeof(s)/sizeof(s[0]);
    qsort(s,sz,sizeof(s[0]),cmp_stu_by_age);
    int i = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%d ",s[i].age);
    }
    qsort(s,sz,sizeof(s[0]),cmp_stu_by_name);
    int j = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%s ",s[i].name);
    }
}

int main()
{
    test1();
    printf("\n");
    test2();
    printf("\n");
    test3();

return 0;
}
    

bubble_sort函数

对于整型数组进行排序，在不考虑优化的通常情况下，使用的是如下我们都所熟知的方法。

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 temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j+1] = temp;
        }
        }
    }
}

那么对于结构体类型数组、浮点型类型数组......来说，如何能使得bubble_sort函数变得更加通用呢？首先定义bubble_sort（）的参数，要先传入想要排序的数组，但是对于数组类型可以是任意的，于是该数据类型使用void* 更为妥当。

struct Stu
{
    char name[20];
    int age;
};
void test4()
{
    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]),cmp_int);
    int i = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%d ",arr[i]);
    }
}
void test5()
{
    struct Stu s[3] = {{"zhangsan",20},{"lisi",30},{"wangwu",10}};
    int sz = sizeof(s)/sizeof(s[0]);
    bubble_sort(s,sz,sizeof(s[0]),cmp_stu_by_age);
    int i = 0;
    for ( i = 0; i < sz; i++)
    {
        printf("%d ",s[i].age);
    }
}

根据冒泡排序的原理来讲，大逻辑就是一轮一轮比较相邻两个元素的大小，直到数组长度结束。那么比较算法就需要好好考虑如何实现。按照qsort中的逻辑来说，就是前一个元素与后一个元素比较大小。此处cmp函数作为比较函数，通过回调cmp函数就可以解决，那么传入比较的元素地址就成为了一个新问题。

如何在cmp函数中找到元素地址呢？

1. cmp(base,base+1) × -  void* 类型不能+-操作 - 不明步长
2. cmp(base,(int*)base+1) × - 强制转换成整型再+1，会直接移动四个字节，中间的元素就很有可能参与不到比较。
3. cmp(base,(char*)base + width) √ - 强制转换成字符类型，因为字符类型的步长为1。通过增加数组元素类型的字节大小从而定位到下一个元素地址。

两个比较元素的地址找到了，进一步的就是第一个和第二个比较，第二个和第三个比较，以此类推，cmp((char*)base+j*width,(char*)base + (j+1) * width就可以实现轮换一对一对的相邻元素。

void bubble_sort(void* base, int sz, int width, int(*cmp)(void* e1, void* e2))
{
    int i = 0;
    //趟数
    for ( i = 0; i < sz - 1; i++)
    {
        //每一趟比较的对数
        int j = 0;
        for ( j = 0; j < sz - i -1; 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 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++;
    }
}