在C中排序数组时不丢失原始索引

我正在处理一个函数，该函数可以获取一个数组并对其进行排序，而不会丢失原始索引，例如：

    originalArray[5] = {9, 2, 3, 4, 15};
    // code
    // ..

结果:

sortedArr[5] = {2, 3, 4, 9, 15};
index[5] = {1, 2, 3, 0, 4};

注意如何

/*
index[0] == 1 because sortedArr[0] == originalArr[1]
index[3] == 0 because sortedArr[3] == originalArr[0]
index[4] == 4 because sortedArr[4] == originalArr[4]
*/

所以重点是保存数字的索引，这样我就可以在另一个函数中使用它们。在这个例子中，我制作了两个数组（排序数组和原始数组），它应该是我制作的同一个数组，只是为了解释我的观点。时间复杂度应限制为O（n*log（n））。n表示数组的大小（最大值为100）

建议（老师为我们推荐）使用签名功能

void rem_sort(int array[], int index[], int size)

。 编辑：所以每个人都在问我到目前为止我尝试了什么，如果这有助于你帮助我，很抱歉我没有首先提到它，不管怎样，这是我到目前为止尝试的，首先我尝试对数组进行排序，我成功了，但我丢失了原始数组的索引，这不是我的观点，所以我想如果我创建一个新的“temp”数组，并将我的原始数组复制到它并以这种方式排序我不会影响我的原始数组，但我无法获得正确的索引（如此复杂），我曾想过使用指针，但我不知道该如何做，所以我卡住了

---

我感谢你的帮助

试试这个，它简单易懂

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

struct array_struct
{
    int value;
    int index;
};

int
compare_array_elements(const void *const x, const void *const y)
{
    const struct array_struct *sx;
    const struct array_struct *sy;

    sx = x;
    sy = y;

    return sx->value - sy->value;
}

int
main(void)
{
    struct array_struct array[5] = {{9, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}};
    size_t size;
    size_t count;

    size = sizeof(array[0]);
    count = sizeof(array) / size;

    qsort(array, count, size, compare_array_elements);
    for (int i = 0 ; i < count ; ++i)
        fprintf(stdout, "(%d, %d, %d)\n", i, array[i].value, array[i].index);
    return 0;
}

#包括
#包括
结构数组
{
int值；
整数指数；
};
int
比较数组元素（常量无效*常量x，常量无效*常量y）
{
常量结构数组_struct*sx；
常量结构数组_struct*sy；
sx=x；
sy=y；
返回sx->value-sy->value；
}
int
主（空）
{
结构数组{u结构数组[5]={{9,0}，{2,1}，{3,2}，{4,3}，{5,4}；
大小；
大小/数量；
size=sizeof（数组[0]）；
计数=sizeof（数组）/大小；
qsort（数组、计数、大小、比较数组元素）；
对于（int i=0；i<>代码> < P>因为这是C而不是C++，所以你需要创建自己的排序程序，因为我认为QSORTE（）可以是O（n ^ 2）最坏的情况。
因为您将使用自己的排序程序，所以您可以同时对数组和索引进行排序，将它们视为成对的元素

如果可以调用现有的O（n log（n））排序函数，则可以创建一个索引数组0到长度-1，并根据数组对索引数组进行排序，然后根据排序后的索引将数组复制到临时数组，然后将临时数组复制回原始数组

void rem_sort(int array[], int index[], int size){
    /* temp array */
    int * tmpa = malloc(size * sizeof(array[0]));
    int i;
    /* generate indices to array */
    for(i = 0; i < size; i++)
        index[i] = i;
    /* sort index according to array in O(n log(n)) time */
    sort(array, index, size);
    /* tmpa[] = sorted array[] */
    for(i = 0; i < size; i++)
        tmpa[i] = array[index[i]];
    /* copy tmpa to array */
    for(i = 0; i < size; i++)
        array[i] = tmpa[i];
    free(tmpa);
    return;
}

void rem_排序（int数组[]，int索引[]，int大小）{
/*临时阵列*/
int*tmpa=malloc（大小*sizeof（数组[0]）；
int i；
/*生成数组的索引*/
对于（i=0；i
请展示您的研究成果。请先阅读第页。使用包含数据和原始索引的
struct
数组。排序时，原始索引仍然是已知的。使用数字0..n初始化
索引
数组，在此数组上使用
mergesort
或
qsort
打开排序函数，通过
索引
数组进行间接比较，最后将排序后的值存储到
sortedar
中。好的，到目前为止，您做了什么？
mergesort
具有
N.log（N）
复杂性，但需要N个额外空间。