如何用单个通用函数对含相同指定成员的不同C结构体链表按seconds成员排序？

当然可以做到！C虽然没有像C++那样的原生泛型，但我们可以用一些底层技巧来实现通用的链表排序函数，完美适配你这两个结构体的场景。下面给你两种实用的方案，你可以根据自己的代码结构选择：

方案一：利用成员偏移量（灵活适配任意结构体布局） #

这个方法的核心是用offsetof宏（来自<stddef.h>）获取seconds和next成员在各自结构体中的字节偏移量，然后在排序函数里通过偏移量来定位这些成员，实现通用操作。

第一步：保留你的结构体定义 #

先把你原来的结构体定义好（如果seconds是tm结构体，后面的比较逻辑需要调整，我先假设是time_t，后续会说明tm的处理方式）：

#include <time.h>
#include <stddef.h> // 必须包含这个头文件才能用offsetof

struct a 
{
    time_t seconds;
    struct a *next;
    /* 你的其他成员 */
};

struct b
{
    time_t seconds;
    struct b *next;
    /* 你的其他不同成员 */
};

第二步：实现通用排序函数 #

这里用链表常用的冒泡排序做示例（如果链表很长，建议换成归并排序，效率更高）：

void sort_linked_list(void *head, ptrdiff_t seconds_offset, ptrdiff_t next_offset)
{
    if (head == NULL) return;

    int swapped;
    void *last_sorted = NULL;

    do {
        swapped = 0;
        void *current = head;
        void *prev = NULL;

        // 遍历到已排序的末尾
        while (*(void **)((char *)current + next_offset) != last_sorted) {
            void *next_node = *(void **)((char *)current + next_offset);
            // 通过偏移量定位seconds成员
            time_t *curr_sec = (time_t *)((char *)current + seconds_offset);
            time_t *next_sec = (time_t *)((char *)next_node + seconds_offset);

            // 按seconds升序排序，需要降序就改成<
            if (*curr_sec > *next_sec) {
                // 交换两个节点的位置
                if (prev == NULL) {
                    // 交换头节点
                    head = next_node;
                } else {
                    // 调整前驱节点的next指针
                    *(void **)((char *)prev + next_offset) = next_node;
                }
                // 调整节点间的next指针
                *(void **)((char *)current + next_offset) = *(void **)((char *)next_node + next_offset);
                *(void **)((char *)next_node + next_offset) = current;

                swapped = 1;
                // 交换后保持遍历节奏
                void *temp = current;
                current = next_node;
                next_node = temp;
            }

            prev = current;
            current = next_node;
        }
        last_sorted = current;
    } while (swapped);
}

第三步：调用排序函数 #

调用时用offsetof获取对应成员的偏移量即可：

// 排序struct a的链表
struct a *head_a = /* 你的链表头指针 */;
sort_linked_list(head_a, offsetof(struct a, seconds), offsetof(struct a, next));

// 排序struct b的链表
struct b *head_b = /* 你的链表头指针 */;
sort_linked_list(head_b, offsetof(struct b, seconds), offsetof(struct b, next));

如果你的seconds是tm结构体（不是time_t），直接用>比较是不行的，需要写一个自定义的比较函数，然后把比较函数作为参数传给排序函数：

// 自定义tm结构体比较函数
int compare_tm(const struct tm *a, const struct tm *b) {
    // 按年→月→日→时→分→秒的顺序比较
    if (a->tm_year != b->tm_year) return a->tm_year - b->tm_year;
    if (a->tm_mon != b->tm_mon) return a->tm_mon - b->tm_mon;
    if (a->tm_mday != b->tm_mday) return a->tm_mday - b->tm_mday;
    if (a->tm_hour != b->tm_hour) return a->tm_hour - b->tm_hour;
    if (a->tm_min != b->tm_min) return a->tm_min - b->tm_min;
    return a->tm_sec - b->tm_sec;
}

// 修改后的通用排序函数，支持自定义比较
void sort_linked_list(void *head, ptrdiff_t seconds_offset, ptrdiff_t next_offset, 
                      int (*compare)(const void*, const void*))
{
    if (head == NULL || compare == NULL) return;

    int swapped;
    void *last_sorted = NULL;

    do {
        swapped = 0;
        void *current = head;
        void *prev = NULL;

        while (*(void **)((char *)current + next_offset) != last_sorted) {
            void *next_node = *(void **)((char *)current + next_offset);
            void *curr_sec = (char *)current + seconds_offset;
            void *next_sec = (char *)next_node + seconds_offset;

            // 用自定义比较函数判断
            if (compare(curr_sec, next_sec) > 0) {
                // 交换节点逻辑和之前一样
                if (prev == NULL) {
                    head = next_node;
                } else {
                    *(void **)((char *)prev + next_offset) = next_node;
                }
                *(void **)((char *)current + next_offset) = *(void **)((char *)next_node + next_offset);
                *(void **)((char *)next_node + next_offset) = current;

                swapped = 1;
                void *temp = current;
                current = next_node;
                next_node = temp;
            }

            prev = current;
            current = next_node;
        }
        last_sorted = current;
    } while (swapped);
}

// 调用时传入比较函数
sort_linked_list(head_a, offsetof(struct a, seconds), offsetof(struct a, next), 
                 (int (*)(const void*, const void*))compare_tm);

方案二：结构体嵌入（代码更简洁易读） #

如果你可以调整结构体的定义，这个方案会更直观：把seconds和next抽成一个基结构体，让struct a和struct b嵌入这个基结构体。

第一步：定义基结构体和嵌入后的结构体 #

#include <time.h>

// 基结构体，包含排序需要的成员
struct base_node {
    time_t seconds;
    struct base_node *next;
};

// struct a嵌入基结构体
struct a {
    struct base_node base;
    /* 你的其他成员 */
};

// struct b嵌入基结构体
struct b {
    struct base_node base;
    /* 你的其他不同成员 */
};

第二步：实现针对基结构体的排序函数 #

这个函数和普通的链表排序函数完全一样，不需要任何特殊处理：

void sort_base_list(struct base_node *head) {
    if (head == NULL) return;

    int swapped;
    struct base_node *last_sorted = NULL;

    do {
        swapped = 0;
        struct base_node *current = head;
        struct base_node *prev = NULL;

        while (current->next != last_sorted) {
            struct base_node *next_node = current->next;
            if (current->seconds > next_node->seconds) {
                // 交换节点位置
                if (prev == NULL) {
                    head = next_node;
                } else {
                    prev->next = next_node;
                }
                current->next = next_node->next;
                next_node->next = current;

                swapped = 1;
                struct base_node *temp = current;
                current = next_node;
                next_node = temp;
            }
            prev = current;
            current = next_node;
        }
        last_sorted = current;
    } while (swapped);
}

第三步：调用排序函数 #

因为C语言规定结构体的第一个成员的地址和整个结构体的地址相同，所以可以安全地把struct a*或struct b*转成struct base_node*：

struct a *head_a = /* 你的链表头指针 */;
sort_base_list((struct base_node*)head_a);

struct b *head_b = /* 你的链表头指针 */;
sort_base_list((struct base_node*)head_b);

两种方案对比 #

• 偏移量方案：更灵活，不需要修改原有结构体，不管seconds和next在结构体中的位置都能适配，适合不能修改结构体定义的场景。
• 结构体嵌入方案：代码更简洁，可读性更好，维护成本低，但需要调整结构体的定义，适合可以修改结构体的场景。

备注：内容来源于stack exchange，提问作者Christian