Question

所以，实际上我需要的是在排序之后保留旧数组的索引。例如，如果我输入[2,4,1,5,7,9,6]，则输出为[2,0,1,3,6,4,5]。我已经使用qsort，如果没有重复的元素，它会很好用。

如果存在重复元素，有时会将第一个重复元素放在最后。例如，如果输入为[5,4,6,5,2,1,3]，我想要输出的是[5,4,6,1,0,3,2]。因此，5的索引0放在5之前，索引为3。但是，使用qsort有时会输出[5,4,6,1,3,0,2]。

你可以帮我解决这个问题吗？或者我应该创建自己的排序功能？你能帮我创建吗？

这是我的代码：

#include <stdlib.h>

int* sortidx(double *X,int n)
{
    int *idx,i,j;

    int cmp(const void *a,const void *b)
    {
        return X[*(int*)a]>=X[*(int*)b]?1:-1;
    }

    idx=(int*)calloc(n,sizeof(int));

    for(i=0;i<n;i++)
    {
        idx[i]=i;
    }

    qsort(idx,n,sizeof(int),cmp);

    return idx;
}

Answer 1

如果一个元素的值更大或者值相等且索引更大，则希望将一个元素视为大于另一个元素。（这是稳定排序算法背后的想法。）

在这种情况下，您知道要比较的元素的索引，因此您可以轻松地将其添加到比较标准中：

int cmp(const void *a, const void *b)
{
    return X[*(int*)a] > X[*(int*)b] ||
           (X[*(int*)a] == X[*(int*)b] && *(int*)a > *(int*)b)
           ?1:-1;
}

或者，可能更可读和更迂腐正确（因为未记录a和b保证不同）：

int cmp(const void *a, const void *b)
{
    int idxa = *(const int*)a, idxb = *(const int*)b;
    if (X[idxa] > X[idxb]) return 1;
    if (X[idxa] < X[idxb]) return -1;
    return idxa - idxb;
}

使用引用参数X的嵌套函数是gcc扩展，可能无法与其他编译器一起使用。标准C库的Gnu实现还包含函数qsort_r，它可用于将X传递给比较例程，但更便携的编写函数的方法是使用数组指针而不是索引数组：

int idxcmp(const void *a,const void *b)
{
    double *ap = *(double *const*)a, *bp = *(double *const*)b;
    if (*ap > *bp) return 1;
    if (*ap < *bp) return -1;
    return ap - bp; 
}

double** sortidx(double *X, size_t n)
{
    double **idx = calloc(n, sizeof(double*));
    for (size_t i=0; i<n; ++i) idx[i] = X + i;
    qsort(idx, n, sizeof(idx[0]), idxcmp);
    return idx;
}

（如果你真的想要返回索引，可以在返回之前将指针转换为索引。）

Answer 2

您寻求的是stable sorting algorithm。您可以在C中stabilize qsort，但需要额外的工作。在C ++ std::stable_sort存在。

如果您需要坚持使用C，那么您应该实现自己的稳定排序。这是list稳定排序算法：

B
Block sort
Bubble sort
Bucket sort
C
Cascade merge sort
Cocktail shaker sort
Counting sort
Cubesort
G
Gnome sort
I
Insertion sort
L
Library sort
M
Merge sort
O
Odd–even sort
Oscillating merge sort
P
Pigeonhole sort
Proxmap sort
R
Radix sort
T
Timsort

如何排序数组但保留重复元素在C中的位置？

2 个答案: