C语言：模拟qsort实现通用冒泡排序

首先了解两个概念：
1.函数指针：即指向函数的指针，用于存放函数的地址。
2.回调函数：一个通过调用函数指针的函数。如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用来低啊用所指向的函数时，我们就说这是回调函数。要注意，回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外一方调用的，用于对该事件或条件进行响应。

我们在sqort函数中要使用到这两个概念。

要模拟实现sqort函数，首先我们要先会使用sqort函数，那么sqort函数是什么呢？我们看MSDN里面是怎么解释的:

MSDN里面解释sqort是一个用于排序通用类型的函数。它没有返回值，一共有四个参数，第一个是数组首元素的地址，第二个是数组的元素个数，第三个是数组一个元素的字节，最后一个是一个指向函数的指针。这里最重要的就是这个指向函数的指针，我们在使用时要自己编写这个函数，因为你要让程序知道你要排序什么类型的数据。下面是我们使用sqort的具体代码，这里我们一共排序了三种类型，分别是整形数据，字符串数据和结构体数据：

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

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

//arr打印函数
void print_arr(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

//str打印函数
void print_str(char* str[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%s ", str[i]);
    }
    printf("\n");
}

//结构体打印函数
void print_s(struct Stu s[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("age:%d,name:%s\n", s[i].age, s[i].name);
    }
    printf("\n");
}


//int_cmp函数指针
int int_cmp(void* e1, void* e2)
{
    assert(e1 && e2);
    return *(char*)e1 - *(char*)e2;
}

//str_cmp函数指针
int str_cmp(void* e1, void* e2)
{
    assert(e1 && e2);
    return strcmp(*(char**)e1, *(char**)e2);
}

//结构体年龄函数指针
int stuage_cmp(void* e1, void* e2)
{
    assert(e1 && e2);
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//结构体姓名函数指针
int stuname_cmp(void* e1, void* e2)
{
    assert(e1 && e2);
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e1)->name);
}

int main()
{
    int arr[10] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    char* str[] = { "abcdef", "bcdefc", "efcvf", "aaccd" };
    struct Stu s[3] = { { 10, "zhangsan" }, { 20, "lisi" }, { 30, "wangwu" } };

    int sz1 = sizeof(arr) / sizeof(arr[0]);
    int sz2 = sizeof(str) / sizeof(str[0]);
    int sz3 = sizeof(s) / sizeof(s[0]);

    qsort(arr, sz1, sizeof(arr[0]), int_cmp);
    print_arr(arr, sz1);

    qsort(str, sz2, sizeof(str[0]), str_cmp);
    print_str(str, sz2);

    /*结构体年龄比较*/
    printf("按年龄排序:\n");
    qsort(s, sz3, sizeof(s[0]), stuage_cmp);
    print_s(s, sz3);

    /*结构体姓名比较*/
    printf("按年龄排序:\n");
    qsort(s, sz3, sizeof(s[0]), stuname_cmp);
    print_s(s, sz3);

    system("pause");
    return 0;
}

运行结果如下图：

学会了使用sqort函数之后，那么我们现在来看看怎么模拟它来实现一个冒泡排序，其实很简单，其他地方都不变，只需要将sqort的算法换位冒泡排序的算法即可。这里还是要注意函数指针的使用。

下面是具体实现代码：

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

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

//arr打印函数
void arr_print(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

//str打印函数
void str_print(char* str[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%s ", str[i]);
    }
    printf("\n");
}

/*结构体打印函数*/

void stu_print(struct Stu s[], int sz)
{
    int i = 0;
    for (i = 0; i<sz; i++)
    {
        printf("name = %s,age = %d\n", s[i].name,s[i].age);
    }
    printf("\n");
}


/*整数比较函数指针*/
int int_cmp(const void* e1, const void* e2)
{
    assert(e1 && e2);
    return *(char*)e1 - *(char*)e2;
}

/*字符串比较函数指针*/
int str_cmp(const void*e1, const void*e2)
{
    assert(e1 && e2);
    return strcmp(*(char**)e1, *(char**)e2);
}

/*结构体姓名比较函数*/
int cmp_stuname(const void* e1, const void* e2)
{
    assert(e1 && e2);
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

/*结构体年龄比较函数*/
int cmp_stuage(const void* e1, const void* e2)
{
    assert(e1 && e2);
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

void swap(char* p1, char* p2, int size)
{
    assert(p1 && p2);
    int i = 0;
    for (i = 0; i < size; i++)//必须将一个元素的所有字节循环比较完，才算将这个元素比较完了
    {
        char tmp = *p1;
        *p1 = *p2;
        *p2 = tmp;
        p1++;
        p2++;
    }
}
void bubble_sort(void* arr[], int sz, int size, int(*cmp)(const void* e1, const void* e2))
{
    int i = 0;
    int j = 0;
    for (i = 0; i < sz-1; i++)
    {
        for (j = 0; j < sz - i - 1; j++)
        {
            if (cmp((char*)arr + j*size, (char*)arr + (j + 1)*size)>0)
            {
                swap((char*)arr + j*size, (char*)arr + (j + 1)*size, size);
            }
        }
    }
}
int main()
{
    int arr[10] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    char* str[5] = { "zzz", "ddd", "aaa", "eee", "bbb" };
    struct Stu s[3] = { { "zhangsan", 20 }, { "lisi", 15 }, { "wangwu", 5 } };

    int sz1 = sizeof(arr) / sizeof(arr[0]);
    int sz2 = sizeof(str) / sizeof(str[0]);
    int sz3 = sizeof(s) / sizeof(s[0]);

    bubble_sort(arr, sz1, sizeof(arr[0]), int_cmp);
    arr_print(arr, sz1);

    bubble_sort(str, sz2, sizeof(str[0]), str_cmp);
    str_print(str, sz2);

    printf("结构体按姓名排序:\n");
    bubble_sort(s, sz3, sizeof(s[0]), cmp_stuname);
    stu_print(s, sz3);

    printf("结构体按年龄排序:\n");
    bubble_sort(s, sz3, sizeof(s[0]), cmp_stuage);
    stu_print(s, sz3);


    system("pause");
    return 0;
}

运行结果如下图：