Question

我正在尝试使用qsort对结构数组进行排序。我的结构看起来像这样：

typedef struct {
    double score;
    int player_num;
} player_t;

我为这样的六个玩家创建了一系列结构：

player_t *players = malloc(6 * sizeof(player_t));

我插入的数据来自这两个数组：

int player_numbers[] = {1, 2, 3, 4, 5, 6};
double scores[] = {0.765, 0.454, 0.454, 0.345, 0.643, 0.532};

到目前为止，我正在尝试按分数对这组结构进行排序，如果分数中存在关联，那么必须对玩家数量进行排序。我到目前为止得到这个输出，从排序分数：

Player 1: Score: 0.765
Player 5: Score: 0.643
Player 6: Score: 0.532
Player 3: Score: 0.454
Player 2: Score: 0.454
Player 4: Score: 0.345

当我真正想要的是这个：

Player 1: Score: 0.765
Player 5: Score: 0.643
Player 6: Score: 0.532
Player 2: Score: 0.454
Player 3: Score: 0.454
Player 4: Score: 0.345

由于Player 2和Player 3交换位置，因为它们具有相同的分数，因此他们各自的球员数字被排序。阵列的其余部分保持不变。

到目前为止，我已经从得分本身对这个结构数组进行了排序，从而产生了第一个输出。我的代码如下所示：

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

#define SIZE 6

int scorecmp(const void *a, const void *b);

typedef struct {
    double score;
    int player_num;
} player_t;

int
main(int argc, char *argv[]) {
    int i;

    int player_numbers[] = {1, 2, 3, 4, 5, 6};
    double scores[] = {0.765, 0.454, 0.454, 0.345, 0.643, 0.532};

    player_t *players = malloc(SIZE * sizeof(player_t));

    for (i = 0; i < SIZE; i++) {
        players[i].score = scores[i];
        players[i].player_num = player_numbers[i];
    }

    qsort(players, SIZE, sizeof(*players), scorecmp);

    for (i = 0; i < SIZE; i++) {
        printf("Player %d: Score: %.3f\n", players[i].player_num, players[i].score);
    }

    free(players);

    return 0;
}

int
scorecmp(const void *x, const void *y) {
    if ((*(double*)x > *(double*)y)) {
        return -1;
    }
    if ((*(double*)x < *(double*)y)) {
        return +1;
    }
    return 0;
}

有没有什么方法可以对绑定的scores进行二次排序，而不是使用player_num，并产生第二个所需的输出？

任何帮助都将不胜感激。

Answer 1

您排序的方式不正确。比较函数接收指向结构的指针，而不是指向结构成员的指针。

按分数排序的正确方法是在qsort函数中使用此比较函数：

int ComparePlayerScore( const void* ap , const void* bp )
{
    const player_t* const a = ap;
    const player_t* const b = bp;

    if( a->score < b->score )
    {
        return -1;
    }
    else if( a->score > b->score )
    {
        return 1;
    }

    return 0;
}

如果您想确保具有相同分数的玩家按字母顺序排序，您需要再次检查排序功能。首先检查玩家是否具有相同的分数，然后按其玩家编号排序。

使用朴素的¹方式比较浮点，函数将是：

if( a->score == b->score )
{
    return CompareInt( a->player_num , b->player_num )
}
else if( a->score < b->score )
{
    return -1;
}
else
{
    return 1;
}

其中CompareInt是另一个功能：

int CompareInt( const int a , const int b )
{
    if( a < b )
    {
        return -1;
    }
    else if( a > b )
    {
        return 1;
    }

    return 0;
}

¹使用简单的比较运算符来比较浮点可能会有问题，请参阅：How should I do floating point comparison?

对绑定结构元素进行排序

1 个答案: