C中qsort（）的比较函数-yiteyi-C++库

标准C库提供 qsort（）可用于对数组进行排序的。顾名思义，该函数使用快速排序算法对给定数组进行排序。以下是qsort（）的原型

null

void qsort ( void * base, size_t num, size_t size,

int (*comparator)( const void *, const void *));

qsort（）的关键是comparator函数 比较器 。comparator函数接受两个参数，并包含确定排序输出中它们的相对顺序的逻辑。其思想是提供灵活性，以便qsort（）可用于任何类型（包括用户定义的类型），并可用于获得任何所需的顺序（增加、减少或任何其他）。

comparator函数将两个指针作为参数（两个类型都转换为const void*），并通过返回（以稳定且可传递的方式）定义元素的顺序

int comparator(const void* p1, const void* p2);
Return value meaning
<0 The element pointed by p1 goes before the element pointed by p2
0  The element pointed by p1 is equivalent to the element pointed by p2
>0 The element pointed by p1 goes after the element pointed by p2

Source: http://www.cplusplus.com/reference/cstdlib/qsort/

例如，假设有一个学生数组，其中following是学生的类型。

                     struct                               Student                   
                     {                   
                                         int                               age, marks;                   
                                         char                               name[20];                   
                     };                   

假设我们需要根据分数按升序对学生进行排序。比较器功能如下所示：

                     int                               comparator(                               const                               void                               *p,                               const                               void                               *q)                   
                     {                   
                                         int                               l = ((                               struct                               Student *)p)->marks;                   
                                         int                               r = ((                               struct                               Student *)q)->marks;                   
                                         return                               (l - r);                   
                     }                   

有关qsort（）的更多示例用法，请参阅以下帖子。给定一系列单词，将所有的字谜打印在一起箱子堆放问题最近点对

下面是一个有趣的问题，可以通过 qsort（） 和比较器功能。 给定一个整数数组，对其进行排序，使奇数先出现，偶数后出现。奇数应按降序排列，偶数应按升序排列。

简单的方法是首先修改输入数组，使奇数和偶数分开，然后分别对这两部分（奇数和偶数）应用某种排序算法。

然而，存在一种有趣的方法，对快速排序的比较器函数进行了一些修改。其思想是编写一个比较器函数，将两个地址p和q作为参数。设l和r为p和q所指的数字。该函数使用以下逻辑： 1）如果两者（l和r）都是奇数，则将二者中的较大者放在第一位。 2）如果两者（l和r）都是偶数，则将两者中的较小者放在第一位。 3）如果其中一个是偶数，另一个是奇数，请先输入奇数。

下面是上述方法的C实现。

                     #include <stdio.h>                   
                     #include <stdlib.h>                   
                             
                     // This function is used in qsort to decide the relative order                   
                     // of elements at addresses p and q.                   
                     int                               comparator(                               const                               void                               *p,                               const                               void                               *q)                   
                     {                   
                                         // Get the values at given addresses                   
                                         int                               l = *(                               const                               int                               *)p;                   
                                         int                               r = *(                               const                               int                               *)q;                   
                             
                                         // both odd, put the greater of two first.                   
                                         if                               ((l&1) && (r&1))                   
                                         return                               (r-l);                   
                             
                                         // both even, put the smaller of two first                   
                                         if                               ( !(l&1) && !(r&1) )                   
                                         return                               (l-r);                   
                             
                                         // l is even, put r first                   
                                         if                               (!(l&1))                   
                                         return                               1;                   
                             
                                         // l is odd, put l first                   
                                         return                               -1;                   
                     }                   
                             
                     // A utility function to print an array                   
                     void                               printArr(                               int                               arr[],                               int                               n)                   
                     {                   
                                         int                               i;                   
                                         for                               (i = 0; i < n; ++i)                   
                                         printf                               (                               "%d "                               , arr[i]);                   
                     }                   
                             
                     // Driver program to test above function                   
                     int                               main()                   
                     {                   
                                         int                               arr[] = {1, 6, 5, 2, 3, 9, 4, 7, 8};                   
                             
                                         int                               size =                               sizeof                               (arr) /                               sizeof                               (arr[0]);                   
                                         qsort                               ((                               void                               *)arr, size,                               sizeof                               (arr[0]), comparator);                   
                             
                                         printf                               (                               "Output array is"                               );                   
                                         printArr(arr, size);                   
                             
                                         return                               0;                   
                     }                   

输出：

Output array is
9 7 5 3 1 2 4 6 8

练习： 给定一个整数数组，以交替方式对其排序。交替方式意味着偶数索引处的元素被单独排序，奇数索引处的元素被单独排序。

本文由阿希什·巴恩瓦尔。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请发表评论。

文章版权归作者所有，未经允许请勿转载。

THE END