1. Uso básico de qsort
| Rotina | Cabeçalho Obrigatório | Compatibilidade |
|---|---|---|
| qsort | <stdlib.h> e <search.h> | ANSI, Win 95, Win NT |
uso:
void qsort (void * base, size_t num, size_t largura, int (__cdecl * compare) (const void * elem1, const void * elem2));
Quatro parâmetros:
1.void * base: o endereço da matriz a ser classificada, ou seja, o nome da matriz
2.size_t num: o número de elementos a serem classificados na matriz
3.size_t largura: o número de bytes ocupados por cada elemento
4.int (__cdecl * compare) (const void * elem1, const void * elem2): ponteiro de função personalizado, usado para determinar a ordem de classificação (os usuários precisam definir uma função de comparação), o método de classificação padrão é crescente
valor de retorno:
| Valor de retorno | Descrição |
|---|---|
| <0 | elem1 menor que elem2 |
| = 0 | elem1 equivalente a elem2 |
| > 0 | elem1 maior que elem2 |
1. Um problema de classificação simples para classificar o array int
, aqui é implementado com a função 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. Classifique a sequência 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. Classificando a matriz char.
Semelhante ao tipo de matriz int, pode ser convertido em char * durante a conversão do tipo
Quatro. Classifique a matriz dupla
#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);
}
O operador ternário deve ser usado para ponto flutuante ou tipo duplo, porque se você usar subtração como tipo inteiro, se forem dois números próximos, ele pode retornar um pequeno número decimal (maior que -1, menor que 1), e o retorno o valor de cmp é do tipo int, então o decimal será retornado a 0, o sistema o considera igual e perde a relação de tamanho original