C语言qsort函数实战：通用排序原理与自定义回调详解

理解 qsort 的核心机制

qsort 全称为 Quicksort（快速排序），但需要注意的是，虽然名字如此，具体的排序算法实现依赖于操作系统的标准库版本，通常经过高度优化以兼顾速度与稳定性。它的最大优势在于“通用性”：只要提供正确的内存访问方式和比较规则，它就能对任何数组进行排序。

函数原型与参数详解

在 stdlib.h 头文件中，该函数的声明如下：

void qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));

各参数的具体作用与注意事项：

• base：指向待排序数组起始位置的指针。由于是 void *，它可以接收任何类型的数组首地址。
• num：待排序元素的总个数。计算方式通常为 sizeof(array) / sizeof(array[0])。
• size：单个元素的大小（字节数）。必须准确指定，否则排序器无法正确定位下一个元素。
• compar：这是一个函数指针，指向用户自定义的比较函数。该函数决定了排序的顺序（升序/降序）。

比较函数的返回值规则

比较函数 compar 接收两个常量指针 p1 和 p2，分别指向待比较的两个元素。返回值的约定如下：

实战：常见场景下的 qsort 使用

第1步：整型数组的简单排序

对于基本数据类型，比较函数只需要将指针强制转换为对应类型，然后进行比较即可。为了简化代码，我们通常利用数值相减的结果来代替 if-else 判断。

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

// 比较两个整数，返回差值实现升序
int cmp_int(const void* p1, const void* p2) {
    return (*(int*)p1 - *(int*)p2);
}

void print(int arr[], int sz) {
    for (int i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = { 2, 1, 3, 7, 5, 9, 6, 8, 0, 4 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    
    // 调用 qsort
    qsort(arr, sz, sizeof(arr[0]), cmp_int);
    
    print(arr, sz);
    return 0;
}

执行上述代码，控制台输出排序后的结果：

若需改为降序，只需交换减法顺序：return (*(int*)p2 - *(int*)p1); 或者在比较逻辑中反转返回值。

第2步：结构体数据的灵活排序

在实际工程中，经常需要根据结构体的某个成员字段进行排序。关键在于先解包指针，再访问成员。

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

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

// 按姓名字符串比较
int cmp_name(const void* p1, const void* p2) {
    return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);
}

// 按年龄比较示例
int cmp_age(const void* p1, const void* p2) {
    return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}

void test() {
    struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
    int sz = sizeof(s) / sizeof(s[0]);
    
    // 按名字排序
    qsort(s, sz, sizeof(s[0]), cmp_name);
    
    // 打印结果
    for (int i = 0; i < sz; i++) {
        printf("%s %d\n", s[i].name, s[i].age);
    }
}

int main() {
    test();
    return 0;
}

运行程序后，结构体将严格按照姓名的字典序进行排列：

进阶：模拟实现 qsort 的内部逻辑

理解 qsort 的工作原理，有助于在处理极其复杂的内存布局时进行自定义定制。这里我们通过“冒泡排序”的思想，模拟一个支持泛型的排序函数，展示如何通过字节级操作交换任意类型的数据。

#include <stdio.h>

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

// 核心：字节级交换函数
void Swap(char* buf1, char* buf2, int width) {
    for (int i = 0; i < width; i++) {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}

// 模拟 qsort 接口
void bubble_sort(void* base, int sz, int width, int (*cmp)(const void*, const void*)) {
    for (int i = 0; i < sz - 1; i++) {
        for (int j = 0; j < sz - 1 - i; j++) {
            // 计算当前相邻两个元素的字节地址
            char* elem1 = (char*)base + j * width;
            char* elem2 = (char*)base + (j + 1) * width;
            
            // 调用比较函数
            if (cmp(elem1, elem2) > 0) {
                Swap(elem1, elem2, width);
            }
        }
    }
}

// 比较函数复用
int cmp_int(const void* e1, const void* e2) {
    return (*(int*)e1 - *(int*)e2);
}

void test() {
    int arr[] = { 2, 1, 3, 7, 5, 9, 6, 8, 0, 4 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print(arr, sz);
}

int main() {
    test();
    return 0;
}

关键逻辑解析

1. 类型擦除与重新解释：函数参数使用 void* 接收数组，内部强制转换为 char*。因为 C 语言保证 char 占用 1 字节，这样可以逐字节移动指针，从而适配任何大小的结构体或数组。
2. 地址计算j * width 精确地跳过了前面已处理的数据块，定位到第 j 个元素的起始地址。
3. 解耦比较与交换：将具体的“怎么比”交给 cmp 回调，将“怎么换”交给通用的 Swap 字节拷贝函数。这种设计模式正是 qsort 能够兼容所有类型的根本原因。

以上就是C语言qsort函数使用方法的详细内容，更多关于C语言通用排序与回调机制的资料请关注本站其它相关文章！