按其中的属性值对结构进行排序

Question

我正在尝试根据其中的双属性值对结构进行排序，有点像这样

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

double arr[] = {1.023, 1.22, 1.56, 2, 5, 3.331};

int cmp(const void *x, const void *y)
{
  double xx = *(double*)x, yy = *(double*)y;
  if (xx < yy) return -1;
  if (xx > yy) return  1;
  return 0;
}

int main() {
    qsort(arr, sizeof(arr)/sizeof(arr[0]), sizeof(arr[0]), cmp);
}

我的问题是当我尝试对名为 ann 的结构列表进行排序时，如下所示

typedef struct ann {
    int inputs;                 /* Number of input neurones      */
    int hidden_layers;          /* Number of hidden layers       */
    int hidden;                 /* Number of hidden neurones     */
    int outputs;                /* Number of output neurons.     */
    int weights;                /* Total nof weigths(chromosomes)*/
    int neurons;                /* Total Number of neurones      */
    double *weight;             /* The weights(genotype)         */
    double *output;             /* Output                        */
    double fitness;              /* Total fitness of the network    */
    double *delta;
    actfun activation_hidden;   /* Hidden layer activation func  */
    actfun activation_output;   /* Output layer activation func  */
} ann;

qsort 不会改变顺序

这是我的实际代码

ann **population = malloc ( population_size * sizeof(ann*));

    for( i = 0; i < population_size; i++ ){
        population[i] = create( trainset->num_inputs, 1 , hidden, trainset->num_outputs);
    }

qsort( population, population_size, sizeof(ann), compareAnn);

int compareAnn(const void* a, const void* b)
{
  const ann* pa = (const ann*)a;
  const ann* pb = (const ann*)b;
  return pa->fitness - pb->fitness;
}

这里还有 create() 函数

ann *create   ( int inputs, int hidden_layers, int hidden, int outputs ) {

    const int hidden_weights = hidden_layers ? (inputs+1) * hidden + (hidden_layers-1) * (hidden+1) * hidden : 0;
    const int output_weights = (hidden_layers ? (hidden+1) : (inputs+1)) * outputs;
    const int total_weights = (hidden_weights + output_weights);

    const int total_neurons = (inputs + hidden * hidden_layers + outputs);

    /* Allocate extra size for weights, outputs, and deltas. */
    const int size = sizeof(ann) + sizeof(double) * (total_weights + total_neurons + (total_neurons - inputs));
    ann *ret = malloc(size);
    if (!ret) return 0;

    ret->inputs = inputs;
    ret->hidden_layers = hidden_layers;
    ret->hidden = hidden;
    ret->outputs = outputs;

    ret->weights = total_weights;
    ret->neurons = total_neurons;

    /* Set pointers. */
    ret->weight = (double*)((char*)ret + sizeof(ann));
    ret->output = ret->weight + ret->weights;
    ret->delta = ret->output + ret->neurons;

    return ret;
}

我知道这可能是微不足道的，但我尝试了很多方法，但我似乎无法弄清楚，我已经花了很多时间试图修复它，任何帮助都会很棒，提前感谢大家。

Answer 1

变量population 的类型为ann **。分配数组的每个元素都有ann *的类型。所以函数qsort应该像这样调用

qsort( population, population_size, sizeof( ann * ), compareAnn );

在比较函数中你应该写

int compareAnn(const void* a, const void* b)
{
  const ann* pa = *( const ann ** )a;
  const ann* pb = *( const ann ** )b;
  return ( pb->fitness < pa->fitness ) - ( pa->fitness - pb->fitness );
}

注意return语句。否则将 return 语句中的双精度差转换为 int 类型可能会产生意想不到的结果。

return pa->fitness - pb->fitness;

还有这个内存分配

const int size = sizeof(ann) + sizeof(double) * (total_weights + total_neurons + (total_neurons - inputs));
ann *ret = malloc(size);

没有意义。要么分配大小等于sizeof( ann ) 的内存，要么使用包含结构 ann 的另一个结构。

这是一个演示程序。

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

struct A
{
    double x;
};

int cmp( const void *a, const void *b )
{
    const struct A *left  = *( const struct A ** )a;
    const struct A *right = *( const struct A ** )b;

    return ( right->x < left->x ) - (  left->x < right->x );
}

int main(void) 
{
    size_t n = 10;
    struct A **a = malloc( n * sizeof( struct A * ) );

    for ( size_t i = 0; i < n; i++ )
    {
        a[i] = malloc( sizeof( struct A ) );
        a[i]->x = ( double )( n - i ) / n;
    }

    for ( size_t i = 0; i < n; i++ ) printf( "%.1f ", a[i]->x );
    putchar( '\n' );

    qsort( a, n, sizeof( struct A * ), cmp );

    for ( size_t i = 0; i < n; i++ ) printf( "%.1f ", a[i]->x );
    putchar( '\n' );

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

    return 0;
}

它的输出是

1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0