// <cstdlib> 
void qsort (void* base, size_t num, size_t size,
            int (*compare)(const void*,const void*));

快速Quick)排序。

如果您使用 C++ 编程,推荐参考 std::sortstd::stable_sortstd::partial_sort

  • base

    指向被排序数组中第一个对象的指针,且被转换成 void*

    num

    数组中元素的个数。

    size

    数组中各个元素的字节大小。

    compare

    函数指针,其指向的函数用于比较两个元素。

    该函数会被 qsort 重复调用以两两比较数组中的各个元素。它须遵守以下原型:

    int compare(const void* p1, const void* p2);

    该函数返回一个整数,代表如下含义:

    当返回值 < 0 时,表示 p1 指向的元素在 p2 指向的元素前面。

    当返回值为 0 时,表示 p1 指向的元素与 p2 指向的元素等价。

    当返回值 > 0 时,表示 p1 指向的元素在 p2 指向的元素后面。

  • 无。

  • 例 1

    #include <iostream>
    #include <cstdlib>
    
    int MyIntCompare(const void* m, const void* n) {
        return (*(int*)m - *(int*)n);
    }
    
    void QSort_1() {
        int foo[] = { 8, 23, -5, 7, 29, 0, 7, 7, -7, 1, -1 };
        int count = sizeof(foo) / sizeof(foo[0]);
        std::qsort(
            foo,
            count,
            sizeof(foo[0]),
            MyIntCompare);
        for (int i = 0; i < count; i++){
            std::cout << foo[i] << " ";
        }
        std::cout << std::endl;
    }
    int main()
    {
        QSort_1();
        return 0;
    }

    -7 -5 -1 0 1 7 7 7 8 23 29 

    例 2

    排序结构体数组

    #include <iostream>
    #include <cstdlib>
    
    struct Node{
        int x;
        int y;
    };
    int MyNodeCompare(const void* a, const void* b) {
        Node* m = (Node*)a;
        Node* n = (Node*)b;
        if (m->x == n->x)
            return m->y - n->y;
        return m->x - n->x;
    }
    
    void QSort_2() {
        Node foo[] = { { 3, 7 }, { 1, 9 }, { 1, 3 }, { 6, 3 }, { 7, 2 }, { 6, 2 } };
        int count = sizeof(foo) / sizeof(foo[0]);
        std::qsort(
            foo,
            count,
            sizeof(foo[0]),
            MyNodeCompare);
        for (int i = 0; i < count; i++){
            std::cout << foo[i].x << " " << foo[i].y << std::endl;
        }
    }
    int main()
    {
        QSort_2();
        return 0;
    }

    1 3
    1 9
    3 7
    6 2
    6 3
    7 2