universitario - personas que trabajan en una biblioteca

Función de la biblioteca C para hacer la clasificación

Question

¿Hay alguna función de biblioteca disponible en la biblioteca estándar de C para ordenar?

Answer 1

Aunque no está exactamente en la biblioteca estándar, https://github.com/swenson/sort tiene solo dos archivos de encabezado que puede incluir para obtener acceso a una amplia gama de rutas de clasificación increíblemente rápidas, como las siguientes:

#define SORT_NAME int64 #define SORT_TYPE int64_t #define SORT_CMP(x, y) ((x) - (y)) #include "sort.h" /* You now have access to int64_quick_sort, int64_tim_sort, etc., e.g., */ int64_quick_sort(arr, 128); /* Assumes you have some int *arr or int arr[128]; */

Esto debería ser al menos dos veces más rápido que el qsort biblioteca estándar, ya que no usa punteros de función, y tiene muchas otras opciones de algoritmo de clasificación para elegir.

Está en C89, por lo que debería funcionar básicamente en cada compilador de C.

Answer 2

De seguro: qsort() es una implementación de un tipo (no necesariamente quicksort como su nombre podría sugerir).

Pruebe man qsort o lea en http://linux.die.net/man/3/qsort

Answer 3

Hay varias funciones de clasificación C disponibles en stdlib.h . Puede hacer man 3 qsort en una máquina Unix para obtener una lista de ellos, pero incluyen:

• heapsort
• ordenación rápida
• mergesort

Answer 4

La biblioteca estándar C / C ++ <stdlib.h> contiene la función qsort .

Esta no es la mejor implementación de ordenamiento rápido del mundo, pero es lo suficientemente rápida y MUY FÁCIL de usar ... la sintaxis formal de qsort es:

qsort(<arrayname>,<size>,sizeof(<elementsize>),compare_function);

Lo único que necesita implementar es la función compare_, que toma dos argumentos de tipo "const void", que se pueden convertir a la estructura de datos apropiada, y luego devuelve uno de estos tres valores:

• negativo, si a debe estar antes b
• 0, si a es igual a b
• positivo, si a debe ser después de b

1. Comparando una lista de enteros :

simplemente arroja a y b a enteros si x < y , xy es negativo, x == y , xy = 0 , x > y , xy es positivo xy es una forma de acceso directo para hacerlo :) reverse *x - *y to *y - *x para clasificar en orden decreciente / inverso

int compare_function(const void *a,const void *b) {
int *x = (int *) a;
int *y = (int *) b;
return *x - *y;
}

2. Comparando una lista de cadenas :

Para comparar cadenas, necesitas la función strcmp dentro de <string.h> lib. strcmp regresará por defecto -ve, 0, ve apropiadamente ... para ordenar en orden inverso, simplemente invierta el signo devuelto por strcmp

#include <string.h>
int compare_function(const void *a,const void *b) {
return (strcmp((char *)a,(char *)b));
}

3. Comparando números de coma flotante :

int compare_function(const void *a,const void *b) {
double *x = (double *) a;
double *y = (double *) b;
// return *x - *y; // this is WRONG...
if (*x < *y) return -1;
else if (*x > *y) return 1; return 0;
}

4. Comparar registros basados ​​en una clave :

A veces necesita ordenar un material más complejo, como grabar. Esta es la forma más sencilla de hacerlo usando la biblioteca qsort .

typedef struct {
int key;
double value;
} the_record;
int compare_function(const void *a,const void *b) {
the_record *x = (the_record *) a;
the_record *y = (the_record *) b;
return x->key - y->key;
}

Answer 5

Use qsort () en stdlib.

@paxdiablo La función qsort () cumple con ISO / IEC 9899: 1990 (`` ISO C90 '''').

Answer 6

intente qsort en stdlib.h.

Answer 7

qsort() es la función que estás buscando. Usted lo llama con un puntero a su matriz de datos, la cantidad de elementos en esa matriz, el tamaño de cada elemento y una función de comparación.

Hace su magia y su matriz se ordena en el lugar. Un ejemplo a continuación:

#include <stdio.h>
#include <stdlib.h>
int comp (const void * elem1, const void * elem2)
{
int f = *((int*)elem1);
int s = *((int*)elem2);
if (f > s) return 1;
if (f < s) return -1;
return 0;
}
int main(int argc, char* argv[])
{
int x[] = {4,5,2,3,1,0,9,8,6,7};
qsort (x, sizeof(x)/sizeof(*x), sizeof(*x), comp);
for (int i = 0 ; i < 10 ; i++)
printf ("%d ", x[i]);
return 0;
}