稳定标准库 qsort？

Question

我假设 stdlib 中的旧 qsort 函数不稳定，因为手册页没有提及任何相关内容。 这就是我正在谈论的函数：

   #include <stdlib.h>
   void qsort(void *base, size_t nmemb, size_t size,
              int(*compar)(const void *, const void *));  

我假设如果我将比较函数更改为也包括我正在比较的地址，它将是稳定的。 那是对的吗？

例如：

int compareFoos( const void* pA, const void *pB ) {
    Foo *pFooA = (Foo*) pA;
    Foo *pFooB = (Foo*) pB;

    if( pFooA->id < pFooB->id ) {
        return -1;
    } else if( pFooA->id > pFooB->id ) {
        return 1;
    } else if( pA < pB ) {
        return -1;            
    } else if( pB > pA ) {
       return 1;
    } else {
       return 0;
    }
}   

Answer 1

不，不幸的是你不能依赖这一点。 假设您有一个数组（每条记录中有两个字段用于检查，但只有第一个字段用于排序）：

B,1
B,2
A,3

不稳定排序可能会将 B,1 与 A,3 进行比较code> 并交换它们，给出：

A,3
B,2
B,1

如果下一步是将 B,2 与 B,1 进行比较，则密钥将是相同的，并且，因为 B ,2 的地址小于 B,1，不会发生交换。 对于稳定的排序，您应该得到以下结果：

A,3
B,1
B,2

唯一的方法是附加指针的起始地址（而不是其当前地址）并排序使用该键以及其他键。 这样，原始地址就成为排序键的次​​要部分，因此无论两个 B 在哪里，B,1 最终都会排在 B,2 之前。 行在排序过程中进行。

Answer 2

规范的解决方案是创建（即分配内存并填充）指向原始数组元素的指针数组，并使用额外的间接级别进行 qsort 这个新数组并回退到比较当指针所指向的事物相等时，指针值。 这种方法具有潜在的副作用，即您根本不修改原始数组 - 但如果您希望原始数组最终排序，则必须对其进行排列以匹配之后指针数组中的顺序qsort 返回。

Answer 3

这不起作用，因为在排序过程中，排序会发生变化，并且两个元素将不会有一致的输出。 为了使老式的 qsort 稳定，我所做的就是在我的结构中添加初始索引，并在将其传递给 qsort 之前初始化该值。

typedef struct __bundle {
    data_t some_data;
    int sort_score;
    size_t init_idx;
} bundle_t;

/*
 .
 .
 .
 .
*/

int bundle_cmp(void *ptr1, void *ptr2) {
    bundle_t *b1, *b2;
    b1 = (budnel_t *) ptr1;
    b2 = (budnel_t *) ptr2;
    if (b1->sort_score < b2->sort_score) {
        return -1;
    }
    if (b1->sort_score > b2->sort_score) {
        return 1;
    }
    if (b1->init_idx < b2->init_idx) {
        return -1;
    }
    if (b1->init_idx > b2->init_idx) {
        return 1;
    }
    return 0;
}

void sort_bundle_arr(bundle_t *b, size_t sz) {
    size_t i;
    for (i = 0; i < sz; i++) {
        b[i]->init_idx = i;
    }
    qsort(b, sz, sizeof(bundle_t), bundle_cmp);
}