1. Uso básico de qsort
| Rutina | Encabezado obligatorio | Compatibilidad |
|---|---|---|
| qsort | <stdlib.h> y <search.h> | ANSI, ganar 95, ganar NT |
uso:
void qsort (void * base, size_t num, size_t width, int (__cdecl * compare) (const void * elem1, const void * elem2));
Cuatro parámetros:
1.void * base: la dirección de la matriz a ordenar, es decir, el nombre de la matriz
2.size_t num: la cantidad de elementos a ordenar en la matriz
3.size_t width: la cantidad de bytes ocupados por cada elemento
4.int (__cdecl * compare) (const void * elem1, const void * elem2): puntero de función personalizada, utilizado para determinar el orden de clasificación (los usuarios deben definir una función de comparación), el método de clasificación predeterminado es ascendente
valor de retorno:
| Valor devuelto | Descripción |
|---|---|
| <0 | elem1 menos que elem2 |
| = 0 | elem1 equivalente a elem2 |
| > 0 | elem1 mayor que elem2 |
1. Un problema de clasificación simple para ordenar la matriz int
, aquí se implementa con la función qsort
#include<stdio.h>
#include<stdlib.h>
int cmp(const void* p1, const void* p2)//形参格式不能改
{
return(（*(int*)p2)-(*(int*)p1)); //将数组元素降序排列
// return((*(int*)p1) - (*(int*)p2); 将数组元素升序排列
}
int main()
{
int a[40], n, i;
scanf("%d", &n);
for (i = 0; i < n; i++)
{
scanf("%d", &a[i]);
}
qsort(a, n, sizeof(a[0]), cmp);
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
}
2. Ordenar la cadena de
caracteres
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
int cmp(const void* p1, const void* p2)
{
return((*(char*)p1) - (*(char*)p2));
}
bool b(char* s, char* t)
{
int ls = strlen(s);
int lt = strlen(t);
if (ls != lt)
{
return false;
}
qsort(s, ls, sizeof(s[0]), cmp);
qsort(t, lt, sizeof(t[0]), cmp);
if (strcmp(s, t) == 0)
{
return true;
}
}
int main()
{
char s[40], t[40];
gets(s);
gets(t);
if (b(s, t))
{
printf("true");
}
else
{
printf("false");
}
}
3. Ordenar la matriz de caracteres.
Similar al tipo de matriz int, se puede convertir a char * durante la conversión de tipos
Cuatro. Ordena la matriz doble
#include<stdio.h>
#include<stdlib.h>
int cmp(const void* p1, const void* p2)
{
double* a = (double*)p1;
double* b = (double*)p2;
return *a > * b ? 1 : -1;
}
int main()
{
double a[40];
qsort(a, 40, sizeof(a[0]), cmp);
}
El operador ternario debe usarse para coma flotante o tipo doble, porque si usa la resta como tipo entero, si son dos números cercanos, puede devolver un número decimal pequeño (mayor que -1, menor que 1), y el retorno el valor de cmp es de tipo int, por lo que el decimal se devolverá a 0, el sistema lo considera igual y pierde la relación de tamaño original