set_union

Artykuł
06/09/2015

Łączy wszystkie elementy należące do co najmniej jednego z dwóch zakresów źródłowych sortowane do zakresu docelowego pojedynczy, posortowany, 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 sterująca adresowania położenie pierwszego elementu w pierwszym z dwóch zakresów źródłowych posortowane Zjednoczone i posortowane w pojedynczy zakres reprezentujący sumę dwóch zakresów.
_Last1
Wejściowy iteratora adresowania położenie jednego poza ostatnim elementem w pierwszym dwóch zakresów źródłowych posortowane Zjednoczone i posortowane w pojedynczy zakres reprezentujący sumę dwóch zakresów.
_First2
Wejściowy iterację adresowania położenie pierwszego elementu w drugim z dwóch kolejnych sortowane zakresów źródłowych Zjednoczone i posortowane w pojedynczy zakres reprezentujący sumę dwóch zakresów.
_Last2
Wejściowy iterację adresowania ostatnich pozycji, jeden ostatni element w drugim z dwóch kolejnych sortowane zakresów źródłowych Zjednoczone i posortowane w pojedynczy zakres reprezentujący sumę dwóch zakresów.
**_**Result
Położenie pierwszego elementu w zakresie docelowym, gdzie mają zostać scalone w pojedynczej sortowanym zakresie reprezentujący sumę dwóch zakresów dwóch zakresów adresowania iterację danych wyjściowych.
_Comp
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest większy niż inny.Predykat dwuelementowy ma dwa argumenty i powinna zostać zwrócona true podczas pierwszego elementu jest mniejsza niż drugi element i false inaczej.

Wartość zwracana

Dane wyjściowe iterację adresowania pozycji, jeden obok ostatniego elementu w zakresie docelowym posortowane reprezentujący sumę dwóch zakresów.

Uwagi

Odwołanie do zakresów Yródłowych posortowane musi być prawidłowy; wszystkie wskaźniki muszą być dereferenceable i w ramach każdej sekwencji ostatniej pozycji musi być osiągalny od pierwszego przez incrementation.

Zakres docelowy nie powinien zachodzić albo z zakresów źródłowych i powinien być wystarczająco duży, aby zawierać zakres docelowy.

Zakresów źródłowych posortowane musi każdego uzgodnienia jako warunek wstępny do stosowania korespondencji seryjnej algorytm zgodnie z samej kolejności jak ma być używany przez algorytm sortowania Scalonej zakresów.

Operacja jest stabilna, jak 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 korespondencji seryjnej.

Typy wartości wejściowych Iteratory muszą być mniej-niż porównywalne do zamówione, tak, że biorąc pod uwagę dwa elementy, może zostać stwierdzone, że są one równoważne (w tym sensie, że nie jest mniejsza niż inne) albo że jeden jest mniejsza niż inne.Powoduje porządkowanie między elementami nonequivalent.Gdy istnieją równoważne elementy w obu zakresów źródłowych, elementy w pierwszym zakresie poprzedzać elementy z drugiego zakresu źródłowego w zakresie docelowym.Jeśli zakresów źródłowych zawierają duplikatów elementu, zakres docelowy będzie zawierać maksymalną liczbę tych elementów, które występują w obu zakresów źródłowych.

Złożoność algorytm jest liniowy, za co najwyżej 2 * ((_Last1-_First1) – (_Last2-_First2))-1 porównań.

set_union ma dwa powiązane formularze:

Aby uzyskać informacje o zachowaniu tych funkcji, zobacz Zaznaczone iteratory.

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: <algorytm>

Przestrzeń nazw: std

Zobacz też

Informacje

Standardowa biblioteka szablonów

Udostępnij za pośrednictwem