如何对嵌套在结构数组C中的结构数组进行排序

Question

我知道有与此类似的帖子，但是我无法理解，所以我也要发表，所以请不要将此重复标记为:)

我有2个嵌套的结构数组，其中外部结构是种族，内部结构是这些种族的船数。 我想对内部结构进行排序，以使船按time_to_complete_race升序排列，一旦完成此操作，我便在数组points = 4 ，第二points = 2和第三points = 1分配了第一条船。 但是，我还没有实现要点建议，因此请忽略此部分。

struct boat_data {
    int ID;
    int time_to_complete_race;
    int points;
} boat_node;
typedef struct race_result {
    char race_date[80];
    int start_time;
    int num_boats_competing;
    struct boat_data boat_data[MAX_BOAT_NUMBER];
} race_node;

这是我用来对内部结构进行排序的代码：

void print_races(int races, race_ptr results[], member_node_ptr member) {

    for(int race = 0; race < races; race++) {
        printf("Race Date: %s\n", results[race].race_date);
        printf("Race Start Time: %d\n", results[race].start_time);
        printf("Number of Skippers: %d\n", results[race].num_boats_competing);
        for(int boats = 0; boats < results[race].num_boats_competing; boats++) {
            find_node_by_id(member, results[race].boat_data[boats].ID);
            printf("\tTime to Complete Race in Seconds: %d\n",
                    results[race].boat_data[boats].time_to_complete_race);
        }
        printf("\n");
    }
}

void print_sorted_races(int races, race_ptr results[], member_node_ptr member) {

    race_ptr sorted_results[races];
    struct boat_data temp;

    int race, swap, boat;

    for (race = 0; race < races; race++) {
        sorted_results[race] = results[race];
    }

    for (race = 0; race < races; race++) {

        for (boat = 0; boat< (sorted_results[race].num_boats_competing -1); boat++) {
            for (swap = race + 1; swap < sorted_results[race].num_boats_competing; swap++) {
                if (sorted_results[race].boat_data[swap].time_to_complete_race >
                    sorted_results[race].boat_data[boat].time_to_complete_race) {
                    temp = sorted_results[race].boat_data[boat];
                    sorted_results[race].boat_data[boat] = sorted_results[race].boat_data[swap];
                    sorted_results[race].boat_data[swap] = temp;
                }
            }
        }
    }
    print_races(races, results, member);
}

Answer 1

通过尝试滚动自己的排序例程而不是使用C库提供的qsort ，使事情变得更加困难，并且容易出错。 使用qsort您所需要做的就是编写一个compare函数，该函数比较boat_data[]数组成员的race_node 。 比较函数原型为：

 int compare (const void *a, const void *b)

所有a和b都指向数组boat_data[]元素的指针。 因此，在compare您只需要将a和b struct boat_node const *pa = a, *pb = b;转换为正确的类型（例如struct boat_node const *pa = a, *pb = b;或者，如果您在第一个结构上完成了typedef ，则只需要boat_node const *pa = a, *pb = b; ）。

然后比较pa->time_to_complete_race和pb->time_to_complete_race返回-1如果pa->time_to_complete_race各种各样的前 pb->time_to_complete_race或1 ，如果pb->time_to_complete_race各种各样之前 pa->time_to_complete_race ，或0 ，如果他们是平等的（ 注：完全strcmp()方式）

然后，您的compare函数为：

int compare (const void *a, const void *b)
{
    boat_node const *pa = a, *pb = b;

    return (pa->time_to_complete_race > pb->time_to_complete_race) -
            (pa->time_to_complete_race < pb->time_to_complete_race);
}

注意：完成typedef ，例如

typedef struct boat_data {
    int ID;
    int time_to_complete_race;
    int points;
} boat_node;

然后对race_node race一个成员boat_data[]数组进行排序， race_node race执行以下操作：

    qsort (race.boat_data, race.num_boats_competing, 
            sizeof *race.boat_data, compare);

（完成！）

新的C程序员经常不愿使用qsort因为他们不知道如何编写比较函数。 在您认识到a和b只是要排序的元素的指针之后 ，您可以轻松地将类型qsort转换为正确的类型，然后进行比较以告诉qsort您希望其如何排序。

在这种情况下，您只需boat_data[]排序boat_data[]的数组time_to_complete_race 。 如果您想return a - b; return (a > b) - (a < b)形式只是避免潜在溢出的简便方法return a - b; 其中，例如， a是大的负整数， b是大的正整数。

完整的例子

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

#define MAX_BOAT_NUMBER 10

typedef struct boat_data {
    int ID;
    int time_to_complete_race;
    int points;
} boat_node;

typedef struct race_result {
    char race_date[80];
    int start_time;
    int num_boats_competing;
    boat_node boat_data[MAX_BOAT_NUMBER];
} race_node;

int compare (const void *a, const void *b)
{
    boat_node const *pa = a, *pb = b;

    return (pa->time_to_complete_race > pb->time_to_complete_race) -
            (pa->time_to_complete_race < pb->time_to_complete_race);
}

int main (void) {

    race_node race = { .race_date = "11/26/19",
                       .start_time = 1400,
                       .num_boats_competing = 3,
                       .boat_data = {{ 1, 23, 0 },
                                     { 2, 21, 0 },
                                     { 3, 22, 0 }} };

    qsort (race.boat_data, race.num_boats_competing, 
            sizeof *race.boat_data, compare);

    for (int i = 0; i < race.num_boats_competing; i++)
        printf ("%2d  %4d  %d\n", race.boat_data[i].ID,
                race.boat_data[i].time_to_complete_race,
                race.boat_data[i].points);
}

使用/输出示例

points成员全部为0 ：

$ ./bin/boat_race
 2    21  0
 3    22  0
 1    23  0

比尝试编写自己的排序要容易得多。 仔细检查一下，如果您还有其他问题，请告诉我。