双条件排序实现求助：fruits结构体按price和quality排序

嘿，这个双条件排序其实在C语言里很好实现，核心就是自定义排序的比较规则就行！我给你两种实现方式，一种是用标准库的qsort（推荐，高效简洁），另一种是手动写冒泡排序（适合理解底层逻辑）。

用标准库qsort实现（推荐） #

C标准库的qsort函数可以对任意类型的数组排序，我们只需要给它一个自定义的比较函数，告诉它怎么判断两个元素的优先级就行。

完整代码示例 #

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

// 你的结构体定义
struct fruits {
    int price;
    int quality;
};

// 自定义比较函数，适配qsort的规则
int compare_fruits(const void *a, const void *b) {
    // 将void指针转换为结构体指针（qsort要求参数是void*，需要强制转换）
    const struct fruits *fruit_a = (const struct fruits *)a;
    const struct fruits *fruit_b = (const struct fruits *)b;
    
    // 第一优先级：价格更低的排前面
    if (fruit_a->price != fruit_b->price) {
        // 返回差值：a的价格小则返回负数，qsort会把a放在b前面（升序）
        return fruit_a->price - fruit_b->price;
    }
    // 第二优先级：价格相同时，质量更高的排前面
    else {
        // 返回b的质量减a的质量：a的质量大则返回负数，qsort会把a放在b前面（降序）
        return fruit_b->quality - fruit_a->quality;
    }
}

int main() {
    // 示例中输入了5组数据，你也可以改成动态读取数量
    int item_count = 5;
    struct fruits *fruit_arr = malloc(item_count * sizeof(struct fruits));
    
    // 读取用户输入的price和quality
    for (int i = 0; i < item_count; i++) {
        scanf("%d %d", &fruit_arr[i].price, &fruit_arr[i].quality);
    }
    
    // 调用qsort排序：参数依次是数组首地址、元素个数、单个元素大小、比较函数
    qsort(fruit_arr, item_count, sizeof(struct fruits), compare_fruits);
    
    // 输出排序后的结果
    for (int i = 0; i < item_count; i++) {
        printf("%d %d ", fruit_arr[i].price, fruit_arr[i].quality);
    }
    printf("\n");
    
    // 释放动态分配的内存
    free(fruit_arr);
    return 0;
}

关键逻辑解释 #

• qsort的比较函数规则：返回值小于0时，a排在b前面；等于0时顺序不变；大于0时b排在a前面。
• 价格比较：用fruit_a->price - fruit_b->price实现升序，价格小的优先。
• 质量比较：价格相同时用fruit_b->quality - fruit_a->quality实现降序，质量大的优先。
• 测试你的示例输入：输入4 0 4 5 3 2 6 8 6 4，运行后会输出3 2 4 5 4 0 6 8 6 4，完全符合要求。

手动实现冒泡排序（适合学习底层逻辑） #

如果你想理解排序的底层过程，可以手动写冒泡排序，核心是判断两个元素是否需要交换位置：

冒泡排序代码示例 #

#include <stdio.h>

struct fruits {
    int price;
    int quality;
};

// 手动实现冒泡排序
void bubble_sort_fruits(struct fruits arr[], int count) {
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - 1 - i; j++) {
            // 判断交换条件：
            // 1. 当前元素价格 > 下一个元素价格，需要交换
            // 2. 当前元素价格 == 下一个元素价格，但当前质量 < 下一个质量，需要交换
            if ((arr[j].price > arr[j+1].price) || 
                (arr[j].price == arr[j+1].price && arr[j].quality < arr[j+1].quality)) {
                // 交换两个元素
                struct fruits temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    struct fruits fruit_arr[5];
    // 读取输入
    for (int i = 0; i < 5; i++) {
        scanf("%d %d", &fruit_arr[i].price, &fruit_arr[i].quality);
    }
    
    // 排序
    bubble_sort_fruits(fruit_arr, 5);
    
    // 输出
    for (int i = 0; i < 5; i++) {
        printf("%d %d ", fruit_arr[i].price, fruit_arr[i].quality);
    }
    printf("\n");
    return 0;
}

逻辑解释 #

冒泡排序的核心是通过相邻元素的比较和交换，把“优先级低”的元素逐步“冒泡”到数组末尾。我们的交换条件完全贴合你的需求：只要当前元素不符合排序规则（价格更高，或者价格相同但质量更低），就和下一个元素交换。

内容的提问来源于stack exchange，提问作者K.N