如何使用qsort对依赖于另一个数组的数组进行排序？

Question

例：

degree =  [2,3,3,2,2,2]

vertex =  [1,2,3,4,5,6]

顶点1的度数为2，顶点2的度数为3，依此类推...

我需要这个解决方案的vertex = [2,3,4,5,6,1] 。 我想使用度的值更改顶点。 （最后4个数字（具有相同度数的顺序无关紧要）。

我有更多的代码，但是我认为这很不错。

谢谢！

typedef struct {
    u32 Orden;
    u32 Grado;
} ParGradoOrden;

int comGrado (const void * a, const void * b) {
    const u32 x = ((ParGradoOrden *) a)->Grado;
    const u32 y = ((ParGradoOrden *) b)->Grado;
    const u32 xx = ((ParGradoOrden *) a)->Orden;
    const u32 yy = ((ParGradoOrden *) b)->Orden;

    if (x < y)
        return 1;
    else if (x > y)
        return -1;

    if (xx < yy)
        return -1;
    else if (xx > yy)
        return 1;

    return 0;
}

qsort(G->vertices, n, sizeof(ParGradoOrden), comGrado);

Grafostv* ConstruccionDelGrafo()
{
    Grafostv* G = (Grafostv*)malloc(sizeof(Grafostv));
    u32 n = 0; //number of vertexs
    u32 m = 0; //number of edges
    u32 v = 0; //vertex name
    u32 w = 0; // vertex name
    int c = 0; //auxiliar char needed for fgetc function
    char prev = 'a';
    char edge[50] = {0};

    G->m = m;
    G->n = n;
    G->orden = (u32*)malloc(sizeof(u32) * n);
    G->grados = (u32*)malloc(sizeof(u32) * n);
    G->vertices = (u32*)malloc(sizeof(u32*) * n);

    for (u32 i = 0; i < 2*m; ++i)
        G->vecinos[i] = (u32*)malloc(sizeof(u32)*2);

    for (u32 i = 0; i < 2*m; i += 2)
    { 
        if(scanf(" %c %u %u",&prev, &v, &w) != 3 || prev != 'e')
        {
            free(G->color);
            free(G->orden);
            free(G->grados);
            return NULL;
        }
            G->vecinos[i][0] = v;
            G->vecinos[i][1] = w;
            G->vecinos[i+1][0] = w;
            G->vecinos[i+1][1] = v;
    } 
    qsort(G->vecinos, 2*m, 2*sizeof(u32), compare);
    G->vertices[0] = G->vecinos[0][0];
    copiarAVertice(G->vertices,G->vecinos,G->grados, G->indEnVecinos, 2*m);
    memset(G->visitados,0,n*sizeof(u32));
    memcpy(G->orden,G->vertices,n*sizeof(u32)); 
    G->max = Greedy(G);
    printf("terminé Greedy\n");
    return G;
}

Answer 1

我认为您打算让degree数组保留其当前顺序。 如果要与顶点数组进行共同排序，则需要编写自己的排序例程。 qsort不会做这项工作。

当然，如果你没有共同排序degree ，那么就必须从值一个明确的一对一映射vertex元素的索引 degree的元素，否则没有办法确定什么去什么程度排序开始后的顶点。 对于您的示例，情况似乎是这样，顶点值比其相应的degree元素的索引大一。

排序的vertex来讲阵列degree ，而无需修改degree ，呈现给比较功能qsort必须能够访问degree通过一个文件范围的变量。 如果degree本身未在文件范围内声明，则可以添加一个文件作用域指针变量并将其设置为指向degree 。 当然，这具有不能同时执行多个排序运行的限制。

设置完成后，比较功能将使用顶点编号来访问数组中的顶点度，并根据这些结果对它们进行比较。 看起来像这样：

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

typedef unsigned int u32;

u32 *vert_degree;

int compare_vertices(const void *v1, const void *v2) {
    u32 degree1 = vert_degree[*(const u32 *)v1 - 1];
    u32 degree2 = vert_degree[*(const u32 *)v2 - 1];
    if (degree1 > degree2) {
        return -1;
    } else if (degree1 < degree2) {
        return 1;
    } else {
        return 0;
    }
}

int main(void) {
    u32 degree[] = {2,3,3,2,2,2};
    u32 vertex[] = {1,2,3,4,5,6};

    vert_degree = degree;
    qsort(vertex, 6, sizeof(vertex[0]), compare_vertices);

    printf("%d", vertex[0]);
    for (int i = 1; i < 6; i++) {
        printf(", %d", vertex[i]);
    }
    putchar('\n');
    return 0;
}

输出：

2，3，1，4，5，6

如果您碰巧是在基于glibc的系统（即Linux）上，则还可以选择使用qsort_r ，它接受诸如degree数组之类的辅助数据，并将其传递给比较函数（因此必须接受一个附加参数）。 这样可以避免依赖全局变量，但是它特定于glibc。