inplace_merge

Articolo
03/26/2013

Combina elementi da due intervalli ordinati consecutivi in un unico intervallo ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

template<class BidirectionalIterator>
   void inplace_merge(
      BidirectionalIterator _First, 
      BidirectionalIterator _Middle,
      BidirectionalIterator _Last
   );
template<class BidirectionalIterator, class Predicate>
   void inplace_merge(
      BidirectionalIterator _First, 
      BidirectionalIterator _Middle,
      BidirectionalIterator _Last,
      Predicate _Comp
   );

Parametri

_First
Un iteratore bidirezionale destinato alla posizione del primo elemento in prima di due intervalli ordinati consecutivi da combinare e ordinare in un unico intervallo.
_Middle
Un iteratore bidirezionale destinato alla posizione del primo elemento nel secondo di due intervalli ordinati consecutivi da combinare e ordinare in un unico intervallo.
_Last
Un iteratore bidirezionale destinato alla posizione una dopo l'ultimo elemento di seconda di due intervalli ordinati consecutivi da combinare e ordinare in un unico intervallo.
_Comp
Oggetto definito dall'utente di funzione predicativa in cui viene definito il concetto cui l'elemento è maggiore di.Il predicato binario accetta due argomenti e deve restituire true quando il primo elemento è minore del secondo elemento e false in caso contrario.

Note

Gli intervalli ordinati consecutivi fatto riferimento siano validi, tutti i puntatori devono essere dereferenceable e, in ogni sequenza, l'ultima posizione sia raggiungibile da prima dall'aumento.

Gli intervalli ordinati consecutivi devono entrambi essere disposti in una precondizione all'applicazione dell'algoritmo inplace_merge nello stesso ordine di è essere utilizzato dall'algoritmo per ordinare gli intervalli combinati.L'operazione diventa stabile quando l'ordine degli elementi all'interno di ogni intervallo viene mantenuto.Quando sono presenti elementi equivalenti in entrambi gli intervalli di origine, l'elemento è il primo intervallo precede l'elemento da come nell'intervallo combinato.

La complessità dipende dalla memoria disponibile come l'algoritmo alloca memoria a un buffer temporaneo.Se la memoria sufficiente è disponibile, il caso migliore consiste lineare con (_Last – _First) – confronti 1; se nessuna memoria ausiliaria disponibile, il caso peggiore è log N (N), dove N = (_Last – _First).

Esempio

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

// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
   if ( elem1 < 0 ) 
      elem1 = - elem1;
   if ( elem2 < 0 ) 
      elem2 = - elem2;
   return elem1 < elem2;
}

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

   // Constructing vector v1 with default less-than ordering
   int i;
   for ( i = 0 ; i <= 5 ; i++ )
   {
      v1.push_back( i );
   }

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

   cout << "Original vector v1 with subranges sorted by the\n "
        <<  "binary predicate less than is  v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
   
   // Constructing vector v2 with ranges sorted by greater
   vector <int> v2 ( v1 );
   vector <int>::iterator break2;
   break2 = find ( v2.begin ( ) , v2.end ( ) , -5 );
   sort ( v2.begin ( ) , break2 , greater<int> ( ) );
   sort ( break2 , v2.end ( ) , greater<int> ( ) );
   cout << "Original vector v2 with subranges sorted by the\n "
        << "binary predicate greater is v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // Constructing vector v3 with ranges sorted by mod_lesser
   vector <int> v3 ( v1 );
   vector <int>::iterator break3;
   break3 = find ( v3.begin ( ) , v3.end ( ) , -5 );
   sort ( v3.begin ( ) , break3 , mod_lesser );
   sort ( break3 , v3.end ( ) , mod_lesser );
   cout << "Original vector v3 with subranges sorted by the\n "
        << "binary predicate mod_lesser is v3 = ( " ;
   for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")" << endl;

   vector <int>::iterator break1;
   break1 = find (v1.begin ( ) , v1.end ( ) , -5 );
   inplace_merge ( v1.begin( ), break1, v1.end( ) );
   cout << "Merged inplace with default order,\n vector v1mod = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To merge inplace in descending order, specify binary 
   // predicate greater<int>( )
   inplace_merge ( v2.begin( ), break2 , v2.end( ) , greater<int>( ) );
   cout << "Merged inplace with binary predicate greater specified,\n "
        << "vector v2mod = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // Applying a user defined (UD) binary predicate mod_lesser
   inplace_merge ( v3.begin( ), break3, v3.end( ), mod_lesser );
   cout << "Merged inplace with binary predicate mod_lesser specified,\n "
        << "vector v3mod = ( " ; ;
   for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")" << endl;
}