Sé diligente y anima los años a no esperar a nadie.
Desarrollo de juegos C/C++
Hola, Mina-san, soy Junxi_. Las actualizaciones anteriores siempre han sido de contenido relativamente básico y simple. Con la mejora del propio nivel del blogger, hoy les traeré algo diferente. De lo que vamos a hablar hoy es del uso de la función de biblioteca qsort. No hay muchas tonterías, ¡comencemos directamente
!
función qsort e implementación analógica de qsort
1. Introducción básica de la función qsort
Ordenamiento de burbuja
Es posible que muchas personas hayan oído hablar de la función qsort por primera vez, pero en realidad es una especie de clasificación de burbuja, pero nuestra clasificación de burbuja anterior solo puede clasificar números enteros, mientras que la función qsort puede clasificar otros tipos de datos.
- ¿Qué es el tipo de burbuja?
- Compare los elementos de una matriz desordenada de izquierda a derecha. Si el elemento de la izquierda es más grande que el elemento de la derecha, intercambie las posiciones de los dos elementos y continúe comparando con el siguiente elemento de la derecha hasta que la matriz desordenada se organice en una matriz con elementos de menor a mayor (es decir, una matriz ascendente). Por lo tanto, la clasificación de burbujas también se denomina método de clasificación ascendente.
- He escrito un blog relacionado antes y presenté este contenido en detalle, por lo que no lo repetiré aquí. Si está interesado, consulte el enlace a continuación: [C Language Elementary] Lo llevará a jugar con matrices en lenguaje C y gradualmente se dará cuenta de la clasificación de burbujas, el backgammon, el barrido de
minas - Este no es el contenido clave aquí, pero está relacionado con el siguiente contenido, ¡así que simplemente publicaré el código!
void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()
{
int i;
int arr[] = {
3,1,7,5,8,9,0,2,4,6 };
int sz = sizeof(arr) / sizeof(arr[0]);//直接把元素个数传进去
bubble_sort(arr, sz);
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
- resultado de la operación
Función Two.qsort
为了系统的熟悉并了解qsort函数，这里我们先看看c plus plus中对这个函数的定义
- Podemos ver a partir de la definición de esta función que se deben pasar cuatro parámetros cuando se llama a esta función
- void * base
pasa en la dirección de la matriz que necesita ser ordenada.El tipo de matriz que pasamos aquí es incierto, y el tipo void se usa uniformemente aquí. - size_t num
pasa el tamaño de la matriz.Si desea ordenar una matriz, debe saber qué tan grande es la matriz. - size_t size
El tamaño en bytes ocupado por un elemento en la matriz entrante. Dado que los diferentes tipos de datos ocupan diferentes tipos, debe informar el tamaño del elemento en la matriz qsort cuando lo use - int ( * comparar )(const void * , const void )
Podemos ver que este es un puntero de función, y los dos parámetros que este puntero de función necesita pasar son ambos tipos vacíos. Esto es más complicado y lo expandiremos más adelante. - Además, como función de biblioteca, el uso de la función qsort debe hacer referencia al archivo de encabezado, y el archivo de encabezado de qsort es
#include<stdlib.h>
1. Los datos enteros se ordenan usando qsort
- Ahora que tenemos el conocimiento de la clasificación de burbujas, comencemos con el uso más simple de qsort para datos enteros, para que sea fácil de entender para todos.
- No hay mucho que decir, veamos primero el código.
//整型
int compar(const void*p1, const void*p2)
{
return (*(int*)p1 - *(int*)p2);
}
int main()
{
int arr[10] = {
1,4,6,8,3,8,9,2,0,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
//test_1();
qsort(arr, sz, sizeof(int),compar);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
- resultado
- Ha cumplido muy bien con nuestro requerimiento, vamos a explicarlo ahora
- En primer lugar, veamos la función principal. Definimos una matriz de enteros y pusimos 10 datos de enteros fuera de orden. Luego calculamos el tamaño de la matriz y la guardamos en sz. Como ordenamos los datos de enteros, podemos calcular el tamaño de los bytes ocupados por un dato por sizeof (int)
- Ahora hablemos del último parámetro en detalle.
int compar(const void*p1, const void*p2)
{
return (*(int*)p1 - *(int*)p2);
}
上面qsort定义中是一个函数指针，我们现在这里直接定义一个函数并把该函数的地址传入即可，如上代码- ¿Cuál es el uso de esta función? Dejemos de lado el todo y enfoquémonos solo en esta función, y descubrimos queConvierte los dos punteros de tipo vacío entrantes en tipo int y resta los datos a los que apuntan los dos punteros mediante la desreferenciación, entonces los resultados en este momento no son más que tres situaciones
- p1>p2, devuelve un número mayor que 0
- p1=p2, devuelve 0
- p1<p2, devuelve un número menor que 0
- Este es el paso de comparar el tamaño de dos elementos en nuestro tipo de burbuja anterior. Cuando usamos qsort, no necesitamos implementar el intercambio, solo necesitamos decirle qué elemento es más grande y qué elemento es más pequeño. Es decir, en qsort
- Si se devuelve un número mayor que 0, se intercambian las posiciones de los dos
- Devuelve un número menor o igual a 0, sin cambios
注意：这里的p1指向前一个数，而p2指向后一个数，这样通过不断比较交换就可以实现我们的升序排序了 - Demuestra lo que dije arriba
- Entonces, si la lógica anterior es correcta, si queremos lograr un orden descendente, ¿solo necesitamos cambiar p1-p2 a p2-p1?
int compar(const void*p1, const void*p2)
{
return (*(int*)p2 - *(int*)p1);
}
- pajarito así
2. La estructura personalizada se ordena usando qsort
-
Otros tipos de datos son exactamente iguales a los números enteros. Ahora hablemos sobre cómo ordenar datos de estructura a través de qsort
-
Tenga en cuenta que si hay varios tipos de datos en la estructura, dado que nuestro qsort ordena los datos en la matriz, los datos que se pasan deben ser del mismo tipo cuando se usan
. -
el código se muestra a continuación:
-
La primera introducción es ordenar por edad en la estructura.
//测试qsort排序结构体数据
struct Stu
{
char name[20];
int age;
};
int cmp_stu_by_age(const void* p1, const void* p2)
{
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
void test2()
{
struct Stu arr[] = {
{
"zhangsan", 20}, {
"lisi", 50},{
"wangwu", 15} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int main()
{
test2();
return 0;
}
- Podemos ver a través del monitoreo que nuestra matriz de estructura ahora está ordenada en orden ascendente de edad
- Primero definimos una estructura con dos elementos en ella: nombre y edad
- Luego definimos una matriz de estructura e inicializamos tres elementos en ella.
struct Stu arr[] = {
{
"zhangsan", 20}, {
"lisi", 50},{
"wangwu", 15} };
- Después de eso, aún calculamos el tamaño de la matriz y calculamos los bytes ocupados por cada elemento de la matriz calculando el tamaño del primer elemento.
- Finalmente, podemos ver que está ordenando por el segundo elemento de la estructura, es decir, la edad.
int cmp_stu_by_age(const void* p1, const void* p2)
{
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
Aquí comparamos el tamaño convirtiendo p1 y p2 en el tipo de puntero de estructura y apuntando al elemento de edad en la estructura a través del operador "->".
- ordenado por tamaño
- Otros son iguales a los anteriores, esta vez comparamos el tamaño y ordenamos por nombre
- el código se muestra a continuación:
int cmp_stu_by_name(const void* p1, const void* p2)
{
return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void test3()
{
struct Stu arr[] = {
{
"zhangsan", 20}, {
"lisi", 50},{
"wangwu", 15} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test3();
return 0;
}
- Todavía miramos los resultados a través de la depuración.
- El primer elemento se ha convertido en lisi, podemos ver que es wangwu después de la edad, y zhangsan se puede ver que se ha ordenado
- Aquí presentamos brevemente las reglas para comparar el tamaño de las cadenas.
Reglas de tamaño de comparación de cadenas
- Para comparar el tamaño de dos cadenas de caracteres, en realidad se compara el tamaño del valor del código ASCLL del carácter en la posición correspondiente. Si el valor ASCLL en la misma posición es el mismo, compare la siguiente posición hasta que haya una diferencia.
比如上面这段代码的比较，在首元素上分别是'l','w','z'，其中‘l’ASCLL码值最小，排在首位，'w'ASCLL码值居中，'z'ASCLL码值最大，排在最后，这就是出现上面结果的原因。
Resumir
-
Este es el final del contenido de hoy, en el que presentamos el uso de la función qsort. Debido a limitaciones de espacio, la implementación de la simulación de la función qsort se explicará en el próximo blog. Durante este período, si todavía está confundido acerca de la función qsort, es posible que desee usarla usted mismo.
-
Bueno, si tiene alguna pregunta, por favor pregúnteme en el área de comentarios o mensaje privado, ¡hasta la próxima!
No es fácil crear un nuevo blogger. Si cree que el contenido del artículo es útil para usted, puede hacer clic en este nuevo blogger antes de irse. ¡Tu apoyo es mi motivación para actualizar! ! !
**(¡Ke Li te pide que apoyes al bloguero tres veces seguidas! Haz clic en el comentario a continuación para darle me gusta y recolectar para ayudar a Ke Li)**
