problema al intentar utilizar la función C qsort

Question

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

float values[] = { 4, 1, 10, 9, 2, 5, -1, -9, -2,10000,-0.05,-3,-1.1 }; 

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

int main() 
{ 

    int i; 

    qsort (values, 13, sizeof(float), compare); 

    for (i = 0; i < 13; i++) 
    { 
     printf ("%f ",values[ i ]); 
    } 
    putchar('\n'); 

    return 0; 
} 

El resultado es:

-9,000000 -3,000000 -2,000000 -1,000000 -1,100000 -0,050000 1,000000 2,000000 4,000000 5,000000 9,000000 10,000000 10000,000000

Está mal porque el orden de -1 y -1.1 se cambia. Creo que está sucediendo porque mi función "comparar".

¿Cómo puedo solucionar esto?

Gracias

Answer 1

redondeando la diferencia en el número entero que pierden la precisión.

EDIT:

Modificar la función de comparación de

return (*(float*)a >= *(float*)b) ? 1 : -1;

Editar para AndreyT: No creo que la devolución sólo se 1 o -1 causará un bucle infinito o orden incorrecto (lo hará solo intercambia valores iguales que no lo requirieron).

Tener un caso explícito para regresar 0 tendrá un costo adicional compatation flotador, y que rara vez son iguales. Por lo tanto, la comparación de equalidad podría omitirse si la tasa de colisión en los datos de entrada es pequeña.

Answer 2

Su función de comparación se ha roto. Se dice, por ejemplo, que -1.0 es igual (equivalente) para -1.1, ya (int) ((-1.0) - (-1.1)) es cero. En otras palabras, tú mismo dijiste qsort que el orden relativo de -1.0 y -1.1 no importa. ¿Por qué te sorprende que en el ordenamiento resultante no se clasifiquen estos valores?

En general, se debe evitar la comparación de los valores numéricos restando uno del otro. Simplemente no funciona. Para los tipos de coma flotante puede producir resultados imprecisos por varias razones diferentes, una de las cuales acabas de observar. Para tipos enteros, podría desbordarse.

La expresión genérica para comparar dos valores numéricos a y b para qsort se ve como (a > b) - (a < b). Recordarlo y usarlo. En su caso sería

int compare (const void * a, const void * b) 
{ 
    float fa = *(const float*) a; 
    float fb = *(const float*) b; 
    return (fa > fb) - (fa < fb); 
} 

en código C podría tener sentido perfecto para definir una macro

#define COMPARE(a, b) (((a) > (b)) - ((a) < (b))) 

y usarlo en lugar de detallar las comparaciones de manera explícita.