根据另一个指针对指针进行排序

Question

我不知道我问的对不对，但我的意思是：

我有这个纯 C 代码：

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

int cmpfunc (const void * a, const void * b) {
   return (*(int*)b - *(int*)a);
}

int main (int argc, char const *avrg[]) {
   int i;
   int *ani, *tira;

   srand(time(NULL));
   tira = malloc(10*sizeof(int));
   ani = malloc(10*sizeof(int));

   for (i=0; i<10; i++) {
      *(tira+i) = (rand()%10);
      *(ani+i) = i + 1;
   }

   qsort(tira, 10, sizeof(int), cmpfunc);
   
   free(tira);
   free(ani);

   return 0;
}

如您所见，我正在使用 qsort() 从大到小对“tira”进行排序，而“ani”则没有。

我要做的是使用“tira”的值对“ani”进行排序，例如：

提拉 = (2,7,6,2,...) ani = (1,2,3,4,...)

排序后

提拉 = (7,6,2,2,...) ani = (2,3,1,4,...)

我找到了一些带有数组的解决方案，但我不允许使用它们（它必须是指针）并且我无法将这些解决方案转换为指针。

谁能指出'wink wink'我正确的方向？ （抱歉开了个玩笑XD）

Answer 1

您需要编写自己的排序函数来完成这项工作。 qsort() 仅限于对内存中连续的对象进行排序，并且由于每个逻辑对象都拆分为 ani 的一个元素和 tira 的一个元素，它们是不连续的。

我只想写一个插入排序或者一个选择排序，将两个数组都作为输入。它根据tira 的内容执行元素比较，但是每当它执行复制或交换时，它都适用于tira 的元素和ani 的相应元素。同样的方法也可以应用于大多数其他排序例程，但插入和选择排序特别容易编写。

Answer 2

通常不能对两个不同的数组进行排序。

但是，如果您创建一个辅助结构来记住有关tira 和ani 的相应元素的信息，这是可能的。

但是，它可能有点麻烦并且会占用一些额外的内存。还有其他定义结构的方法（例如索引值、指针等）

无论如何，这里有一些代码可以做到这一点：

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

#define ARRMAX      10

struct idx {
    int tira;                           // tira value
    int ani;                            // ani value
};

void
print(const int *arr,const char *reason)
{
    int i;

    printf("%s:\n",reason);
    for (i = 0;  i < ARRMAX;  ++i)
        printf(" %d",arr[i]);
    printf("\n");
}

int
cmpfunc(const void *vpa, const void *vpb)
{
    const struct idx *ap = vpa;
    const struct idx *bp = vpb;

    return (bp->tira - ap->tira);
}

void
dotest(int randflg,int *tira,int *ani)
{
    int i;
    struct idx *idx;

    printf("\n");

    for (i = 0; i < ARRMAX; i++) {
        tira[i] = 0;
        ani[i] = 0;
    }

    do {
        if (! randflg) {
            tira[0] = 2;
            tira[1] = 7;
            tira[2] = 6;
            tira[3] = 2;

            ani[0] = 1;
            ani[1] = 2;
            ani[2] = 3;
            ani[3] = 4;
            break;
        }

        for (i = 0; i < ARRMAX; i++) {
            tira[i] = (rand() % 10);
            ani[i] = i + 1;
        }
    } while (0);

    print(tira,"tira unsorted");
    print(ani,"ani unsorted");

    struct idx *idxlist = malloc(ARRMAX * sizeof(struct idx));

    for (i = 0;  i < ARRMAX;  ++i) {
        idx = &idxlist[i];

        // get tira value
        idx->tira = tira[i];

        // get ani value
        idx->ani = ani[i];
    }

    qsort(idxlist, ARRMAX, sizeof(struct idx), cmpfunc);

    for (i = 0;  i < ARRMAX;  ++i) {
        idx = &idxlist[i];
        tira[i] = idx->tira;
        ani[i] = idx->ani;
    }

    print(tira,"tira sorted");
    print(ani,"ani sorted");

    free(idxlist);
}

int
main(int argc, char const *avrg[])
{
    int i;
    int *ani, *tira;

    srand(time(NULL));

    tira = malloc(ARRMAX * sizeof(int));
    ani = malloc(ARRMAX * sizeof(int));

    dotest(0,tira,ani);
    dotest(1,tira,ani);

    free(tira);
    free(ani);

    return 0;
}

---

这是程序输出：

 tira unsorted:
 2 7 6 2 0 0 0 0 0 0
ani unsorted:
 1 2 3 4 0 0 0 0 0 0
tira sorted:
 7 6 2 2 0 0 0 0 0 0
ani sorted:
 2 3 1 4 0 0 0 0 0 0

tira unsorted:
 7 1 1 5 4 3 4 8 6 4
ani unsorted:
 1 2 3 4 5 6 7 8 9 10
tira sorted:
 8 7 6 5 4 4 4 3 1 1
ani sorted:
 8 1 9 4 5 7 10 6 2 3