Question

我使用https://phoxis.org/2012/07/12/get-sorted-index-orderting-of-an-array/中的一个例子，他从一个数组中返回排序索引，即

3,4,2,6,8返回4,3,1,0,2（R中每个索引+1）。这相当于R order函数

我已将他/她的代码翻译为返回已排序索引数组的函数。代码给出了正确的答案。

keeping track of the original indices of an array after sorting in C有类似的回应，但正如@BLUEPIXY所警告的那样，他的解决方案并非在所有情况下都有效。我需要一些适用于所有情况的东西，包括领带。

但是，原作者使用全局指针，导致内存泄漏，free()没有修复它。如果没有全局指针，我不知道如何做到这一点。

如何修复此内存泄漏，或者至少返回C中始终有效的已排序索引？

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

/* holds the address of the array of which the sorted index
 * order needs to be found
 */
int * base_arr = NULL;
/* Note how the compare function compares the values of the
 * array to be sorted. The passed value to this function
 * by `qsort' are actually the `idx' array elements.
 */
static int compar_increase (const void * a, const void * b) {
    int aa = *((int * ) a), bb = *((int *) b);
    if (base_arr[aa] < base_arr[bb]) {
        return 1;
    } else if (base_arr[aa] == base_arr[bb]) {
        return 0;
    } else {
//  if (base_arr[aa] > base_arr[bb])
        return -1;
     }
}

int * order_int (const int * ARRAY, const size_t SIZE) {
    int * idx = malloc(SIZE * sizeof(int));
    base_arr = malloc(sizeof(int) * SIZE);
    for (size_t i = 0; i < SIZE; i++) {
        base_arr[i] = ARRAY[i];
        idx[i] = i;
    }
    qsort(idx, SIZE, sizeof(int), compar_increase);
    free(base_arr); base_arr = NULL;
    return idx;
}


int main () {
    const int a[] = {3,4,2,6,8};
    int * b = malloc(sizeof(int) * sizeof(a) / sizeof (*a));
    b = order_int(a, sizeof(a) / sizeof(*a));
    for (size_t i = 0; i < sizeof(a)/sizeof(*a); i++) {
        printf("b[%lu] = %d\n", i, b[i]+1);
    }
    free(b); b = NULL;
    return 0;
}

Answer 1

不使用全局变量的直接方法可以采用以下方式

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

int cmp_ptr(const void *a, const void *b)
{
    const int **left  = (const int **)a;
    const int **right = (const int **)b;

    return (**left < **right) - (**right < **left);
}

size_t * order_int(const int *a, size_t n)
{
    const int **pointers = malloc(n * sizeof(const int *));

    for (size_t i = 0; i < n; i++) pointers[i] = a + i;

    qsort(pointers, n, sizeof(const int *), cmp_ptr);

    size_t *indices = malloc(n * sizeof(size_t));

    for (size_t i = 0; i < n; i++) indices[i] = pointers[i] - a;

    free(pointers);

    return indices;
}

int main( void )
{
    const int a[] = { 3,4,2,6,8 };
    const size_t N = sizeof(a) / sizeof(*a);
    size_t *indices = order_int(a, N);

    for (size_t i = 0; i < N; i++) printf("%d ", a[indices[i]]);
    putchar('\n');

    free(indices);

    return 0;
}

程序输出

8 6 4 3 2

至于内存泄漏，那是因为覆盖指向冗余分配内存的指针值。

int * b = malloc(sizeof(int) * sizeof(a) / sizeof (*a));
b = order_int(a, sizeof(a) / sizeof(*a));

内存分配没有意义。

Answer 2

我看到的问题是在main函数中 - 你正在分配指针b一些内存 -

   int * b = malloc(sizeof(int) * sizeof(a) / sizeof (*a));

下一行调用order_int（...），返回指向已分配内存的指针 -

  b = order_int(a, sizeof(a) / sizeof(*a));

查看order_int函数 -

int * order_int (const int * ARRAY, const size_t SIZE) {
    int * idx = malloc(SIZE * sizeof(int));
    base_arr = malloc(sizeof(int) * SIZE);
    for (size_t i = 0; i < SIZE; i++) {
        base_arr[i] = ARRAY[i];
        idx[i] = i;
    }
    qsort(idx, SIZE, sizeof(int), compar_increase);
    free(base_arr); base_arr = NULL;
    return idx;
}

..您看到 idx 已被分配了正确的内存。

我建议从 b 中删除malloc - 见下文。

  int * b = NULL;

在C中排序数组，返回排序索引

2 个答案: