set_intersection

Artykuł
03/26/2013

Ważnym wszystkich elementów, które należą do obu zakresów źródłowych sortowane w zakresie przeznaczenia pojedynczy, sortowane, gdzie kryterium sortowania może być określona przez predykatu dwuelementowego.

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

Parametry

_First1
Wejściowy iteratora adresowania położenie pierwszego elementu w pierwszych dwóch zakresów źródłowych sortowane united i posortowane w pojedynczy zakres reprezentujących przecięcia 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 przecięcia 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 przecięcia 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 przecięcia dwóch zakresów.
**_**Result
Pozycja pierwszego elementu w zakresie przeznaczenia, gdzie mają być scalone w pojedynczy zakres sortowane reprezentujących przecięcia 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 przecięcia 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.

Sortowane zakresy muszą być ustawione jako warunek zastosowania algorytmu korespondencji seryjnej, zgodnie z tym samym zamawiania jako źródła jest używane przez algorytm do 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.

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ównania dla zakresów źródłowych niepusty.

set_intersectionma dwa powiązane formularze:

Informacji na temat zachowania tych funkcji, zobacz Iteratory zaznaczone.

Przykład

// alg_set_intersection.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 an intersection in asscending order with the
   // default binary predicate less <int> ( )
   Result1 = set_intersection ( v1a.begin ( ) , v1a.end ( ) ,
      v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
   cout << "Intersection of source ranges with default order,"
        << "\n vector v1mod =  ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; ++Iter1 )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // To combine into an intersection in descending order, specify
   // binary predicate greater<int>( )
   Result2 = set_intersection ( v2a.begin ( ) , v2a.end ( ) ,
      v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
   cout << "Intersection 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 an intersection applying a user-defined
   // binary predicate mod_lesser
   Result3 = set_intersection ( v3a.begin ( ) , v3a.end ( ) ,
      v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
   cout << "Intersection 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 ).
Intersection of source ranges with default order,
 vector v1mod =  ( -1 0 1 ).
Intersection of source ranges with binary predicate greater specified,
 vector v2mod  = ( 1 0 -1 ).
Intersection 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