Ordenación Qsort
Función Qsort
Utilice esta función para ordenar cualquier tipo de datos.
Ordenamiento de burbuja
Dado arr como se muestra en la figura, los 10 elementos deben ordenarse de pequeño a grande. La
idea de clasificación se compara antes y después. Si el frente es menor que el reverso, el orden se cumple, de lo contrario, el orden de cambio.
A partir de esta figura, se puede ver que la clave del juicio radica en dos puntos.
- El objeto de comparación son elementos adyacentes.
- Si la orden es la primera pequeña y luego la grande, de lo contrario reemplácela para
realizar el juicio.
if (arr[i] > arr[i + 1])
{
int tmp = arr[i];
arr[i ] = arr[i+1];
arr[i + 1] = tmp;
}
Después de la declaración if, puede intercambiar antes y después
. ¿Cuántas veces necesita intercambiar? ¿Cuántos elementos hay que intercambiar?
Lo que se debe intercambiar debe ser la matriz completa. ¿Cuántas veces intercambiamos? Por supuesto, no necesitamos intercambiar los intercambios anteriores. Por lo tanto, el número de intercambios es menos el número de elementos que se han intercambiado. La
esencia de clasificación de burbujas: la esencia del orden de clasificación de burbujas Es decir, el más grande se cambia al último, y cada vez que el pedido se envía al último, no es necesario cambiar el último. El último elemento es una oportunidad menos para uno correspondiente.
int main()
{
int arr[] = {
1,22,67,89,45,67,34,56,78,2 };
int i = 0;
for (i = 0; i < 10 - 1; i++)
{
for (int j = 0; j < 10 - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
for (i = 0; i < 10 ;i++)
{
printf("%d ", arr[i]);
}
return 0;
}
La clasificación de burbujas busca comparar y, de hecho, desplaza el número grande hacia atrás.
Usos de Qsort
Ejemplo para ordenar una matriz de enteros
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
int _Int(const void* p, const void* r)
{
return (*(int*)p - *(int*)r);
}
int _Char(const void* p, const void* r)
{
return (*(char*)p -*(char*)r);
}
int main()
{
int arr[] = {
1,3,4,5,32,1,2,22,345,987 };
char arr2[] = "afedpo";
qsort(arr2, (sizeof(arr2) / sizeof(arr2[0])),
sizeof(arr2[0]),
&_Char);
for (int i = 0; i < 6; i++)
{
printf("%c", arr2[i]);
}
return 0;
}
Implementación de simulación Qsort
La implementación de la simulación Qsort utiliza el método de clasificación de burbujas
. La esencia de la clasificación de burbujas es comparar los elementos adyacentes izquierdo y derecho y cambiar los más grandes a la parte posterior
. El núcleo de la clasificación de burbujas es la escritura de sentencias de juicio if (). El juicio de
matrices de plástico es
` if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
`
Use Qsort para usar nuestra propia función para pasar parámetros para completar
El juicio clave es
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width))
{
}
El tamaño del paso de char es 1 más el número de j elementos que deben omitirse * el tamaño de cada elemento simplemente salta a
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int _Int(const void* p, const void* r)
{
return *(char*)p - *(char*)r;
}
void _swap(char* buf1,char *buf2,int size)
{
int i = 0;
for (i=0;i<size;i++)
{
char a = *(buf1+i);
*(buf1 + i) = *(buf2 + i);
*(buf2 + i) = a;
}
}
void My_qsot(void* base,
size_t num,
size_t width,
int(*com)(const void*p, const void*r))
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < num; i++)
{
for (j = 0; j < num - i - 1; j++)
{
if (com((char*)base + j * width,
(char*)base + (j + 1) * width)>0)
{
_swap((char*)base + j * width,
(char*)base + (j + 1) * width, width);
}
}
}
}
int main()
{
int arr[] = {
2,3,1,4,6,9,81,12,11,10 };
size_t sz = sizeof(arr) / sizeof(arr[0]);
My_qsot(arr,sz,sizeof(arr[0]),&_Int);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
- Al copiar, copie byte a byte. La unidad más pequeña en bytes.