set_union

Artykuł
03/26/2013

Ważnym wszystkich elementów, które należą do co najmniej jeden z dwóch zakresów źródłowych sortowane do zakresu docelowego pojedynczy, sortowane, gdzie kryterium sortowania może być określona przez predykatu dwuelementowego.

template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_union(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_union(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp
   );

Parametry

_First1
Wejściowy iteratora adresowania położenie pierwszego elementu w pierwszym dwóch zakresów źródłowych sortowane united i posortowane w pojedynczy zakres reprezentujących Unii dwóch zakresów.
_Last1
Wejściowy iterację adresowania położenie jednego ostatni element w przeszłości w pierwszym dwóch zakresów źródłowych sortowane united i posortowane w pojedynczy zakres reprezentujących Unii dwóch zakresów.
_First2
Iterację wprowadzania adresowania położenie pierwszego elementu w drugim z dwóch kolejnych sortowane zakresów źródłowych united i posortowane w pojedynczy zakres reprezentujących Unii dwóch zakresów.
_Last2
Iterację wprowadzania adresowania jednej pozycji ostatnich ostatni element w drugim z dwóch kolejnych sortowane zakresów źródłowych united i posortowane w pojedynczy zakres reprezentujących Unii dwóch zakresów.
**_**Result
Pozycja pierwszego elementu w zakresie przeznaczenia, gdzie mają być scalone w pojedynczy zakres sortowane reprezentujących Unii dwóch zakresów dwóch zakresów adresowania iterację wyjściowego.
_Comp
Obiektu predykatu funkcję zdefiniowaną przez użytkownika, który definiuje znaczeniu, w którym jeden element jest większa niż innym.Predykatu dwuelementowego ma dwa argumenty i powinna zwrócić true , kiedy pierwszy element jest mniejsza niż drugi element i false inaczej.

Wartość zwracana

Adresowanie jedną pozycję w przeszłości ostatni element w zakresie docelowym sortowane reprezentujących Unii dwóch zakresów iterację wyjściowego.

Uwagi

Sortowane zakresów odwołania musi być ważny; wszystkie wskaźniki muszą być dereferenceable i w każdej sekwencji ostatniej pozycji musi być osiągalny od pierwszego przez incrementation.

Zakres docelowy nie powinien zachodzić albo zakresów źródłowych i powinna być wystarczająco duża, zawierać zakresu docelowego.

Zakresów źródłowych sortowane musi być ustawione jako warunek zastosowania seryjna jest algorytm zgodnie z tym samym zamawiania jako stosowaną przez algorytm sortowania Scalonej zakresów.

Operacja jest stabilna względna kolejność elementów w obrębie każdego zakresu jest zachowywany w zakresie docelowym.Zakresów źródłowych nie są modyfikowane przez algorytm seryjna.

Typy wartości Iteratory wejściowe muszą być mniej-niż porównywalne zamawiać tak, że biorąc pod uwagę dwa elementy, można ustalić są równoważne (w tym sensie, że nie jest mniejsza niż drugi) albo jednym jest mniejsza niż inne.Powoduje porządkowanie między elementami nonequivalent.Podczas obu zakresów źródłowych są równoważne elementy, elementy w pierwszym zakresie poprzedzać elementy z drugiego zakresu źródłowego w zakresie docelowym.Jeśli zakresów źródłowych zawiera duplikaty elementu, zakres docelowy zawiera maksymalną liczbę tych elementów, które występują w obu zakresów źródłowych.

Złożoność algorytm jest liniowa z co najwyżej 2 * ((_Last1 — _First1) – (_Last2 — _First2)) – 1 porównań.

set_unionma dwa powiązane formularze:

Informacji na temat zachowania tych funkcji, zobacz Iteratory zaznaczone.

Przykład

// alg_set_union.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> v1a, v1b, v1 ( 12 );
   vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;

   // Constructing vectors v1a & v1b with default less than ordering
   int i;
   for ( i = -1 ; i <= 3 ; i++ )
   {
      v1a.push_back(  i );
   }

   int ii;
   for ( ii =-3 ; ii <= 1 ; ii++ )
   {
      v1b.push_back(  ii  );
   }

   cout << "Original vector v1a with range sorted by the\n "
        <<  "binary predicate less than is  v1a = ( " ;
   for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
      cout << *Iter1a << " ";
   cout << ")." << endl;

   cout << "Original vector v1b with range sorted by the\n "
        <<  "binary predicate less than is  v1b = ( " ;
   for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
      cout << *Iter1b << " ";
   cout << ")." << endl;
   
   // Constructing vectors v2a & v2b with ranges sorted by greater
   vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
   vector <int>::iterator Iter2a,  Iter2b, Iter2, Result2;
   sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
   sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );

   cout << "Original vector v2a with range sorted by the\n "
        <<  "binary predicate greater is   v2a =  ( " ;
   for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
      cout << *Iter2a << " ";
   cout << ")." << endl;

   cout << "Original vector v2b with range sorted by the\n "
        <<  "binary predicate greater is   v2b =  ( " ;
   for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
      cout << *Iter2b << " ";
   cout << ")." << endl;

   // Constructing vectors v3a & v3b with ranges sorted by mod_lesser
   vector <int> v3a ( v1a ), v3b ( v1b ) ,  v3 ( v1 );
   vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
   sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
   sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser  );

   cout << "Original vector v3a with range sorted by the\n "
        <<  "binary predicate mod_lesser is   v3a =  ( " ;
   for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
      cout << *Iter3a << " ";
   cout << ")." << endl;

   cout << "Original vector v3b with range sorted by the\n "
        <<  "binary predicate mod_lesser is   v3b =  ( " ;
   for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
      cout << *Iter3b << " ";
   cout << ")." << endl;

   // To combine into a union in ascending order with the default 
    // binary predicate less <int> ( )
   Result1 = set_union ( v1a.begin ( ) , v1a.end ( ) ,
      v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
   cout << "Union of source ranges with default order,"
        << "\n vector v1mod =  ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // To combine into a union in descending order, specify binary 
   // predicate greater<int>( )
   Result2 = set_union (  v2a.begin ( ) , v2a.end ( ) ,
      v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
   cout << "Union of source ranges with binary predicate greater "
        << "specified,\n vector v2mod  = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")." << endl;

   // To combine into a union applying a user-defined
   // binary predicate mod_lesser
   Result3 = set_union ( v3a.begin ( ) , v3a.end ( ) ,
      v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
   cout << "Union of source ranges with binary predicate "
        << "mod_lesser specified,\n vector v3mod  = ( " ; ;
   for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")." << endl;
}

Dane wyjściowe

Original vector v1a with range sorted by the
 binary predicate less than is  v1a = ( -1 0 1 2 3 ).
Original vector v1b with range sorted by the
 binary predicate less than is  v1b = ( -3 -2 -1 0 1 ).
Original vector v2a with range sorted by the
 binary predicate greater is   v2a =  ( 3 2 1 0 -1 ).
Original vector v2b with range sorted by the
 binary predicate greater is   v2b =  ( 1 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a =  ( 0 -1 1 2 3 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b =  ( 0 -1 1 -2 -3 ).
Union of source ranges with default order,
 vector v1mod =  ( -3 -2 -1 0 1 2 3 ).
Union of source ranges with binary predicate greater specified,
 vector v2mod  = ( 3 2 1 0 -1 -2 -3 ).
Union of source ranges with binary predicate mod_lesser specified,
 vector v3mod  = ( 0 -1 1 2 3 ).

Wymagania

Nagłówek: <algorithm>

Obszar nazw: std

Zobacz też

Informacje

Standardowa biblioteka szablonu

Udostępnij za pośrednictwem