C ++: clasificar y qsort

Título de cepillo con el pedido bastante común, y así resume: ¿qué clase qsort, aquí sugerimos que utilice especie, qsort necesidad de escribir usando una función de comparación que se compara, y sort默认为升序排序por lo que en la mayoría de los casos, sería más conveniente para una especie .

Una, más o menos

función de clasificación, y la misma función de complejidad especie qsort n*log2(n). sort () definido en el archivo de cabecera <algorithm>en. La función de clasificación es una función de la biblioteca de plantillas estándar, el inicio y el final de la dirección se sabe que tipo, cualquier recipiente puede ser utilizado para la comparación (iteradores azar deben cumplir con) cualquier elemento, cualquier condición, la velocidad de ejecución es generalmente más rápido que qsort. Nota: El valor predeterminado es de forma ascendente.

especie que especificar cuándo se debe utilizar:

#include<algorithm>
using namespace std;或 std::sort() ；

(1) ascendente (por defecto)

La función de clasificación puede pasar dos o tres parámetros parámetros. El primer parámetro es el primer rango de direcciones para ser ordenadas, el segundo argumento es la dirección de la siguiente dirección de la sección final. En otras palabras, el tipo de intervalos son [a,b). En pocas palabras, hay un int array a [100], para a partir de una [0] a una [99] Ordenar los elementos, la escritura tipo (a, a + 100) en la línea, orden predeterminado es ascendente. Ordenar número entero tipo de datos no está limitado siempre que define el tipo de operación puede ser menor que, como cadena de clase de cadena. Si no lo es menos que el tipo de datos definido de operación, o para cambiar el orden de clasificación, es necesario utilizar un tercer parámetro - la función de comparación. La función de comparación es una función de su propia definición, el valor de retorno es bool tipo, que especifica qué tipo de relación es "menos".
Ejemplos:

#include<iostream> 
#include<algorithm> 
using namespace std; 
int main()
{ 
int a[20]; 
for(int i=0;i<20;++i) 
cin>>a[i]; 
sort(a,a+20); //范围，很明显这里是a+20 注意，这是必要的，如果是a+19 
for(i=0;i<20;i++) //最后一个值a[19]就不会参与排序。 
cout<<a[i]<<endl; 
return 0; 
}

Ordenar qsort es una versión mejorada, si se puede utilizar tanto como sea posible con la especie tipo, utilizando relativamente simple, a diferencia cmp función qsort tuvo que escribir su propia, siempre que las funciones de la biblioteca pueden indicar el uso de la utilización de sólo dos parámetros (si es ordinaria uso) la cabeza y cola punteros;

(2) Descendente

Después de ordenar el valor por defecto es ascendente, descendente, si quiere, puede usar su propia función de la serie CMP ( 返回值为bool)

bool compare(int a,int b) 
{ 
return a>b; 
//降序排列
//如果改为return a<b，则为升序

} 
sort(*a,*b,cmp);

Ejemplos:

#include<iostream>
#include<algorithm>
using namespace std;
bool cmp (const int a, const int b)
{
    return a > b;
}
int main()
{
    int data[5];
    for(int i = 0; i < 5; i++)
        cin >> data[i];
    sort(data, data + 5, cmp);
    return 0;
}

Ejemplo:
Supongamos propia definición de un nodo de estructura:
nodo struct {
int a;
int B;
Doble C;
};
tener un tipo de nodo de la arr nodo array [100], que le gustaría ordenar: un valor de prensa en orden ascendente, Si un mismo valor, entonces el valor de b en orden descendente, si b es también la misma haga clic en C en orden descendente. comparación de un tipo puede escribir la función:
El siguiente es el fragmento de código:

bool cmp(node x,node y)
{
     if(x.a!=y.a)  return x.a
     if(x.b!=y.b)  return x.b>y.b;
     return  return x.c>y.c;
} 

sort(arr,a+100,cmp); 

(3) una combinación de litros descendente flexibles

Para un parámetro de función de comparación se utiliza para indicar orden ascendente o descendente.

//为了描述方便，我先定义一个枚举类型EnumComp用来表示升序和降序。
enum Enumcomp{ASC,DESC};


//然后开始用一个类来描述这个函数对象。它会根据它的参数来决定是采用“<”还是“>”。
class compare
{
      private:
            Enumcomp comp;
      public:
            compare(Enumcomp c):comp(c) {};
      bool operator () (int num1,int num2) 
         {
            switch(comp)
              {
                 case ASC:
                        return num1<num2;
                 case DESC:
                        return num1>num2;
              }
          }
};


//接下来使用 sort(begin,end,compare(ASC)实现升序，
//sort(begin,end,compare(DESC)实现降序。

//主函数为：
int main()
{
     int a[20]={2,4,1,23,5,76,0,43,24,65},i;
     for(i=0;i<20;i++)
         cout<<a[i]<<endl;
     sort(a,a+20,compare(DESC));
     for(i=0;i<20;i++)
         cout<<a[i]<<endl;
     return 0;
}

(4) Clasificación de contenedores STL (vector, deque, string)

cabecera:#include <functional>

menos (menor que)
Mayor (mayor que)
equal_to (igual)
not_equal_to (no iguales)
donde less_equal es (o menos)
greater_equal (o superior)

Ascendente: sort(begin,end,less<data-type>());
Descendente:sort(begin,end,greater<data-type>());

Ejemplos:

#include<iostream>
#include<algorithm>
#include <functional>
int  main()
{
      int a[20]={2,4,1,23,5,76,0,43,24,65},i;
      for(i=0;i<20;i++)
          cout<<a[i]<<endl;
      sort(a,a+20,greater<int>());
      for(i=0;i<20;i++)
          cout<<a[i]<<endl;
      return 0;
}

también se puede lograr usando una disposición inversa iterador inverso, el procedimiento es como sigue:

int main()
{
     string str("cvicses");
     string s(str.rbegin(),str.rend());
     cout << s <<endl;
     return 0;
}

Dos, qsort

cabecera:#include<algorithm>

Función: Uso rutina de ordenación rápida para ordenar es lograr la función de clasificación moviendo el puntero, el resultado después de la clasificación se encuentra todavía en la matriz original.

uso:

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare ) 

int compare (const void *elem1, const void *elem2 ) );

参数意义如下:
base:需要排序的目标数组开始地址 
num:目标数组元素个数 
width:目标数组中每一个元素长度 
compare:函数指针，指向比较函数（这个函数是要自己写的，sort中默认升序）

(1) para ordenar la matriz de tipo int

int num[100]; 
int cmp ( const void *a , const void *b ) 
{ 
return *(int *)a - *(int *)b; 
}

//可见：参数列表是两个空指针，现在他要去指向你的数组元素。
//所以转型为你当前的类型，然后取值。升序排列。

qsort(num,100,sizeof(num[0]),cmp);

(2) Ordenar tipo char array (el mismo tipo int)

 char word[100];
int cmp( const void *a , const void *b )

{
return *(char *)a - *(int *)b;
}

qsort(word,100,sizeof(word[0]),cmp);

(3) Ordenación de una matriz de tipo doble (atención particular)

double in[100];
int cmp( const void *a , const void *b ) 
{ 
return *(double *)a > *(double *)b ? 1 : -1; 
}
//返回值的问题，显然cmp返回的是一个整型，
//所以避免double返回小数而被丢失。  
qsort(in,100,sizeof(in[0]),cmp)；

(4) un tipo de estructura

struct In 
{ 
double data; 
int other; 
}s[100]

//按照data的值从小到大将结构体排序,
//关于结构体内的排序关键数据data的类型可以很多种，
//参考上面的例子写 
int cmp( const void *a ,const void *b) 
{ 
return (*(In *)a).data > (*(In *)b).data ? 1 : -1; 
} 
qsort(s,100,sizeof(s[0]),cmp);

(5) dos tipo de estructura

struct In 
{ 
int x; 
int y; 
}s[100];

//按照x从小到大排序，当x相等时按照y从大到小排序 
int cmp( const void *a , const void *b ) 
{ 
struct In *c = (In *)a; 
struct In *d = (In *)b; 
if(c->x != d->x) return c->x - d->x; 
else return d->y - c->y; 
} 
qsort(s,100,sizeof(s[0]),cmp);

(6) cadenas de clasificación

char str[100][100]; 
int cmp(const void* a,const void* b )

{
return strcmp((char *)a,(char*)b);
}

qsort(str,n,sizeof(str[0]),cmp);

(7) a la estructura ordenar cadenas

struct In 
{ 
int data;
char str[100]; 
}s[100];

//按照结构体中字符串str的字典顺序排序 
int cmp ( const void *a , const void *b ) 
{ 
return strcmp( (*(In *)a)->str , (*(In *)b)->str ); 
} 
qsort(s,100,sizeof(s[0]),cmp);

Tres, clasificar y comparar qsort

(1) La diferencia entre la forma más intuitiva, funcional no es el mismo,

qsort utilización manera:

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare ) 

tipo de uso son:

template <class RandomAccessIterator>

void sort ( RandomAccessIterator first, RandomAccessIterator last )；

template <class RandomAccessIterator, class Compare>

void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );

parámetros de clasificación tiene dos versiones con tres parámetros, dos parámetros por defecto en orden ascendente, el tercer parámetro se puede utilizar para especificar una función de comparación, el ajuste de clasificación.

Escrito (2) comparar la función no es la misma.

función para la redacción qsort comparar:

int compare (const void *elem1, const void *elem2 ) );

ordenar los retornos de función comparar boolun valor;

(3) tipo es una versión mejorada de la qsort std :: función de clasificación qsort mejor que algunas de las características de: tomar nueve muestras de matrices grandes, un algoritmo más completa de partición de tres vías, más detallada adoptar diferentes métodos para la clasificación de un conjunto de diferentes tamaños . Si se puede tratar de clasificar por género, utilizando relativamente simple, a diferencia de la función cmp qsort tuvo que escribir su propia, siempre que las funciones de la biblioteca indican el uso de la misma puede ser utilizada.

Referencia:
Artículo 1
Artículo 2
invasión borrado