指针的进阶-4 回调函数 库函数qsort，快速排序的实现，模仿qsort排序.

//回调函数

/*
    回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，
    当这个指针被用来调用其所指的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方式
    直接调用，而是再特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应
*/

//演示qsort函数的使用

//整形冒泡排序，n个数需要排序n-1次
/*
        第一次排序  第一次需要排序（n-1）次
        10    9    8    7    6    5    4    3    2    1
        9    10    8    7    6    5    4    3    2    1
        9    8    10    7    6    5    4    3    2    1
        .......
        9    8    7    6    5    4    3    2    1    10

        第二次排序  第二次需要排序（n-2）次
        8    9    7    6    5    4    3    2    1    10
        8    7    9    6    5    4    3    2    1    10
        .........
        8    7    6    5    4    3    2    1    9    10

        第（n-1）次排序，也就是第九次排序  
        第（n-1）次需要排序1次    
        也就是第几次排序，和需要排序几次的和为n（n为需要排序的个数）
        2    1    3    4    5    6    7    8    9    10
        1    2    3    4    5    6    7    8    9    10
*/

int main()
{
    int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    int j = 0;
    int t = 0;
    int flag = 0;
    //i代表冒泡排序的次数
    for (i = 0; i < sz - 1; i++)
    {
        
        //j代表每次冒泡排序比较的次数
        for (j = 0; j < sz - 1 - i; j++)
        {
            flag = 1;//假设数组的状态时有序的 ，比如 1 2 3 4 5 6 7 8 9 10，就不用继续排序了
            if (arr[j] > arr[j + 1])
            {
                t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t;
                flag = 0;//交换过说明数组不是有序的，flag置0
            }
        }
        if (flag == 1)
        {
            break;
        }
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

//库函数qsort，快速排序的实现

/*
    //qsort可以对任何类型的数据进行排序
    void qsort(void *base, //所要排序的首地址，开始的位置
               size_t num,//排序元素的个数
               size_t width,//每个元素的大小
               int (__cdecl *compare )(const void *elem1, const void *elem2 ) //比较不同类型数据的大小
               );
*/

//void*类型的指针-->无具体类型的指针，可以接受任意类型的地址
//但是其不能解引用操作，也不能进行算数操作

//qsort 回调函数的应用

int cmp_int(const void* e1, const void* e2)
{
    return *(int*)(e1) - *(int*)(e2);//1在前从小到大，1在后从大到小
}
void test1()
{
    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);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}
struct  Stu
{
    char name[20];
    int age;
};
int cmp_by_name(const void* e1, const void* e2)
{
    //strcmp的返回值1大，返回>
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test2()
{
    struct Stu s[] = {"zhangsan",10,"lisi",15 ,"wangwu",20 };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_by_name);
    qsort(s, sz, sizeof(s[0]), cmp_by_age);
}
int main()
{
    test1();
    test2();
    return 0;
}

模仿qsort函数的参数编写冒泡排序

void Swap(char* buf1, char* buf2, int width)
{
    int i = 0;
    char t = 0;
    for (i = 0; i < width; i++)
    {
        t = *(buf1 + i);
        *(buf1 + i) = *(buf2 + i);
        *(buf2 + i) = t;
    }
}

void bubble_sort(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{
    int i = 0;
    int j = 0;
    int flag = 0;
    //i代表冒泡排序的次数
    for (i = 0; i < sz - 1; i++)
    {

        //j代表每次冒泡排序比较的次数
        for (j = 0; j < sz - 1 - i; j++)
        {
            // 核心：以字节为单位依次比较
            flag = 1;//假设数组的状态时有序的 ，比如 1 2 3 4 5 6 7 8 9 10，就不用继续排序了
            if ((cmp((char*)base+j*width,(char*)base+(j+1)*width))>0)
            {
                //所调用的函数要放在上面
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
                flag = 0;//交换过说明数组不是有序的，flag置0
            }
        }
        if (flag == 1)
        {
            break;
        }
    }
}
//void bubble_sort(void* base, int sz, int width, 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++)
//        {
//            //利用最小单位地址（char*）和偏移量来确定地址
//            if ( cmp(  ((char*)base + (j * width)), ((char*)base + ((j + 1) * width)) ) > 0)
//            {
//                //交换
//                //Swap,交换两个元素的内容
//                //前两个元素为交换元素的地址，第三个元素为交换数据的宽度（大小）
//                Swap((char*)base + j * width , (char*)base + (j + 1) * width, width);
//            }
//        }
//    }
//}
int cmp_int(const void* e1, const void* e2)
{
    return (*(int*)e1) - (*(int*)e2);
}
int main()
{
    int a = 1;
    int b = 2;
    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]);
    }
    printf("\n");
    //printf("%d\n", cmp_int(&arr[0], &arr[2]));
    //Swap(&a, &b, sizeof(a));
    //printf("%d %d\n", a, b);
    return 0;
}