Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

partial_sort

 

Organiza un número especificado de elementos más pequeños de un intervalo en nondescending petición o según un criterio de ordenación especificado por un predicado binario.

template<class RandomAccessIterator>
   void partial_sort(
      RandomAccessIterator first, 
      RandomAccessIterator sortEnd,
      RandomAccessIterator last
   );
template<class RandomAccessIterator, class BinaryPredicate>
   void partial_sort(
      RandomAccessIterator first, 
      RandomAccessIterator sortEnd,
      RandomAccessIterator last
      BinaryPredicate comp
   );

first

Un iterador de acceso aleatorio que dirige la posición del primer elemento del intervalo que se ordenen.

sortEnd

Un iterador de acceso aleatorio que dirige la posición una más allá del último elemento en el subrango que se ordenen.

last

Un iterador de acceso aleatorio que dirige la posición una más allá del último elemento en el intervalo que se ordenen parcialmente.

comp

Objeto definido por el usuario de la función de predicado que define el criterio de comparación que se completará por los elementos sucesivos del orden. Un predicado binario acepta dos argumentos y devuelve true cuando se cumple y false cuando no se cumple.

El intervalo hace referencia debe ser válido; todos los punteros deben ser dereferenceable y dentro de la secuencia la posición última es accesible de primera por el aumento.

Los elementos son equivalentes, pero son iguales no necesariamente, si hay alguno es menor que otro. El algoritmo de ordenación no es estable y no garantiza que el orden relativo de elementos equivalentes se conservará. El algoritmo stable_sort conserva esta clasificación original.

La complejidad parcial media de ordenación es O((last-first) registrar (sortEnd-first)).

Ejemplo

// alg_partial_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // For greater<int>( )
#include <iostream>

// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 )
{
   return elem1 > elem2;
}

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   for ( i = 0 ; i <= 5 ; i++ )
   {
      v1.push_back( 2 * i );
   }

   int ii;
   for ( ii = 0 ; ii <= 5 ; ii++ )
   {
      v1.push_back( 2 * ii +1 );
   }

   cout << "Original vector:\n v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   partial_sort(v1.begin( ), v1.begin( ) + 6, v1.end( ) );
   cout << "Partially sorted vector:\n v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To partially sort in descending order, specify binary predicate
   partial_sort(v1.begin( ), v1.begin( ) + 4, v1.end( ), greater<int>( ) );
   cout << "Partially resorted (greater) vector:\n v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // A user-defined (UD) binary predicate can also be used
   partial_sort(v1.begin( ), v1.begin( ) + 8, v1.end( ), 
 UDgreater );
   cout << "Partially resorted (UDgreater) vector:\n v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}
          Vector original:
 v1 = (0 2 4 6 8 10 1 3 5 7 9 11)
Vector parcialmente ordenado:
 v1 = (0 1 2 3 4 5 10 8 6 7 9 11)
(Mayor) vector parcialmente recurrido:
 v1 = (11 10 9 8 0 1 2 3 4 5 6 7)
Vector parcialmente recurrido (de UDgreater):
 v1 = (11 10 9 8 7 6 5 4 0 1 2 3)

Requisitos

Encabezado: <algorithm>

Espacio de nombres: std

Mostrar: