¿Cómo utilizar la función de clasificación?
Ordenar es una operación que se utiliza con frecuencia cuando se tratan problemas de ACM. Si escribes tu propia clasificación de burbujas O(n^2) cada vez, no solo el programa expirará fácilmente, sino que también perderás un valioso tiempo de juego y lo más probable es que lo escribas mal. Hay una función de clasificación en STL que se puede usar directamente para ordenar matrices, con una complejidad de n*log2(n). Para utilizar esta función, debe incluir el archivo de encabezado.
Esta función puede aceptar dos o tres parámetros. El primer parámetro es la primera dirección del rango que se va a ordenar y el segundo parámetro es la dirección junto a la dirección final del rango. Es decir, el intervalo a ordenar es [a,b). En pocas palabras, hay una matriz int a [100], para ordenar los elementos de a [0] a a [99], simplemente escriba sort (a, a + 100), la clasificación predeterminada es ascendente.
Tome mi problema de "estrategia AC" como ejemplo. Necesitas ordenar los elementos 0 a len-1 de la matriz t, escribe sort(t,t+len);
p>.Ordenar el vector v es similar, escriba sort(v.begin(),v.end());
Los tipos de datos ordenados son los mismos.
Los tipos de datos para ordenar no se limitan a números enteros, siempre y cuando se defina la operación menor que (como una cadena).
Si no existe una operación menor que, o deseas cambiar el orden de clasificación, debes utilizar el tercer parámetro, la función de comparación. La función de comparación es una función personalizada con un valor de retorno bool, que especifica la relación "menor que". Si desea ordenar los números enteros en la matriz en orden descendente, primero puede definir una función de comparación cmp
bool cmp(int a, int b)
{
return a>b;
}
Escribe sort(a,a+100,cmp) al ordenar;
Supongamos que define un nodo de estructura
p>estructura nodo{
int a;
int b;
doble c;
}
Hay un nodo de matriz arr[100] de tipo nodo y desea ordenarlo: primero por el valor de a en orden ascendente y luego por el valor de b en orden ascendente. Si los valores de a son los mismos, ordene por los valores de b en orden descendente; si los valores de b siguen siendo los mismos, ordene por los valores de c en orden descendente.
Puedes escribir una función de comparación como esta:
Aquí está el fragmento de código:
bool cmp(nodo x,nodo y)
{
if(x.a!=y.a) devuelve x.a
if(x.b!=y.b) devuelve x.b>y.b;
devuelve devuelve x.c>y.c;
} ordenar al escribir sort(arr,a+100,cmp);
qsort(s[0],n,sizeof(s[0]),cmp);
int cmp (const void *a,const void *b)
{
return *(int *)a-*(int *)b;
}
I. Ordenar matrices de tipo int
int num[100];
Ejemplo:
int cmp ( const vacío * a , const vacío *b )
{
return *(int *)a - *(int *)b
}
qsort(num,100,sizeof(num[0]),cmp);
Dos: Ordenar matrices de tipo char (igual que int)
char word[ 100];
Muestra:
int cmp( const void *a, const void *b)
{
return *( char *) a - *(int *)b;
}
qsort(palabra,100,tamañode(palabra[0]),cmp); > Tres: Ordenar matrices de tipo doble (atención especial)
double in[100]
int cmp( const void *a, const void *b)
{
return *(doble *)a > *(doble *)b ?1 : -1
}
qsort(in,100; ,sizeof (in[0]),cmp);
4. Clasificación de estructuras de primer nivel
struct In
{
double data;
int other;
}s[100]
// Ordena la estructura según el valor de los datos de pequeño a grande, aproximadamente dentro de la estructura Los datos clave de clasificación pueden ser de muchos tipos. Consulte el ejemplo anterior para escribir
int cmp( const void *a, const void *b)
{ <. /p>
return ((In *)a)->datos - ((In *)b)->datos
}
qsort(s,100, sizeof(s[0 ]),cmp);
V. estructuras de pares
struct In
{
int x; /p>
int y;
}s[100];
// Ordenar por x de mayor a menor, cuando x son iguales, ordenar por y de mayor a pequeño
int cmp( const void *a, const void *b)
{ <
/p>
estructura En *c = (En *)a;
estructura En *d = (En *)b
if(c->x != d->x) devolver c->x - d->x;
de lo contrario devolver d->y - c->y
}
qsort(s,100,sizeof(s[0]),cmp);
Seis.Clasificación de cadenas
Sort(s,100); .Clasificación de cadenas
struct In
{
int data
char str[100]; }s[100];
// Ordena las cadenas en la estructura según el orden del diccionario de str
int cmp ( const void *a, const void *b) < / p>
{
return strcmp( ((In *)a)->str , ((In *)b)->str
}
qsort(s,100,sizeof(s[0]),cmp);
VII Calcular la forma geométrica del casco convexo cmp
int cmp(const void. *a, const void *b) //Preste atención a la función cmp, tome todos los puntos excepto 1 punto y ordénelos por ángulo de rotación
{
struct point *c=( punto *) a;
struct punto *d = (punto *)b;
if( calc(*c,*d,p[1]) < 0) return 1 ;
p>else if( !
else if( ! calc(*c,*d,p[1]) && dis(c->x,c->y ,p[1] .x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) // si está en línea recta , pon el lejano primero
return 1;
else return -1
}
}