STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące

Transkrypt

1 1. partition 2. stable_partition 3. sort 4. stable_sort 5. partial_sort 6. partial_sort_copy 7. nth_element 8. lower_bound 9. upper_bound 10.equal_range 11.binary_search 12.merge 13.inplace_merge 14.includes 15.set_union 16.set_intersection 17.set_difference 18.set_symmetric_difference 19.lexicographical_compare 20.next_permutation template<class BidirectionalIterator, class Predicate> BidirectionalIterator partition( BidirectionalIterator _First, BidirectionalIterator _Last, BinaryPredicate _Comp ); porządkuje na nowo sekwencję elementów tak, że w pierwszej kolejności w sekwencji znajdują się elementy spełniające warunek podany w predykacie, a następnie pozostałe, niespełniające warunku. Zwracany iterator wskazuje element graniczny, tj. pierwszy element niespełniający warunku z predykatu // std::partition bool Nieparzyste (int i) { return (i%2)==1; std::vector<int> V; for (int i=1; i<10; ++i) V.push_back(i); // std::vector<int>::iterator bound; bound = std::partition (V.begin(), V.end(), Nieparzyste); std::cout << "nieparzyste elementy:"; for (std::vector<int>::iterator it=v.begin(); it!=bound; ++it) std::cout << "parzyste elementy:"; for (std::vector<int>::iterator it=bound; it!=v.end(); ++it) 77 template<class BidirectionalIterator, class Predicate> BidirectionalIterator stable_partition( BidirectionalIterator _First, BidirectionalIterator _Last, Predicate _Pred ); porządkuje na nowo sekwencję elementów tak, że w pierwszej kolejności w sekwencji znajdują się elementy spełniające warunek podany w predykacie, a następnie pozostałe, niespełniające warunku. Zwracany iterator wskazuje element graniczny, tj. pierwszy element niespełniający warunku z predykatu porządkowanie jest stabilne. Co to znaczy, że jest stabilne? 78 Szereg algorytmów porządkujących występuje w wersjach stabilnych i niestabilnych. Wersje stabilne zachowują wzajemne uporządkowanie elementów traktowanych jako identyczne z punktu widzenia funkcji porządkującej, np. sekwencja: C 1,B 1,C 2,A 1,B 2,A 2 po posortowaniu pod względem dużej litery algorytmem stabilnym będzie miała postać: A 1,A 2,B 1,B 2,C 1,C 2 natomiast po posortowaniu algorytmem niestabilnym może mieć np. postać: A 2,A 1,B 1,B 2,C 2,C 1 template<class RandomAccessIterator> void sort( RandomAccessIterator _First, RandomAccessIterator _Last ); template<class BidirectionalIterator> void stable_sort( BidirectionalIterator _First, BidirectionalIterator _Last ); Np. implementacja algorytmu sort w STL jest oparta na quicksort, a więc jest niestabilna. Istnieje jednak również wersja stable_sort, która zachowuje wzajemne uporządkowanie elementów identycznych. porządkuje elementy w sekwencji określanej przez parę iteratorów [_First,_Last) w porządku nierosnącym,

2 // std::stable_sort bool porownajint (double i,double j) { return (int(i)<int(j)); ; double mydoubles[] = {3.14, 1.41, 2.72, 4.67, 1.73, 1.32, 1.62, 2.58; std::vector<double> V; V.assign(mydoubles,mydoubles+8); std::cout << "sortowanie porownajint:"; std::stable_sort (V.begin(), V.end(), porownajint); for (std::vector<double>::iterator it=v.begin(); it!=v.end(); ++it) template<class RandomAccessIterator> void partial_sort( RandomAccessIterator _First, RandomAccessIterator _SortEnd, RandomAccessIterator _Last ); sortuje ograniczoną liczbę elementów z sekwencji określanej przez parę iteratorów [_First,_Last) w porządku nierosnącym, którą da się zmieścić w zakresie [_First,_SortEnd). Reszta elementów trafia do [_SortEnd,_Last) w nieokreślonej kolejności, // std::partial_sort bool porownaj (int i,int j) { return (i<j); int myints[] = {9,8,7,6,5,4,3,2,1; std::vector<int> V (myints, myints+9); std::partial_sort (V.begin(), V.begin()+5, V.end(), porownaj); std::cout << "V zawiera:"; for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it) template<class InputIterator, class RandomAccessIterator> RandomAccessIterator partial_sort_copy( InputIterator _First1, InputIterator _Last1, RandomAccessIterator _First2, RandomAccessIterator _Last2 ); Sortuje liczbę elementów z sekwencji określanej przez parę iteratorów [_First1,_Last1) w porządku nierosnącym, którą da się umieścić w zakresie [_First2,_Last2) i kopiuje posortowane elementy do sekwencji [_First2,_Last2), Jeżeli [_First1,_Last1) jest mniejszy od [_First2,_Last2), kopiowana jest mniejsza liczba elementów, // std::partial_sort_copy bool porownaj (int i,int j) { return (i<j); ; int myints[] = {9,8,7,6,5,4,3,2,1; std::vector<int> V (5); std::partial_sort_copy (myints, myints+9, V.begin(), V.end(), porownaj); std::cout << "V zawiera:"; for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it) template<class RandomAccessIterator> void nth_element( RandomAccessIterator _First, RandomAccessIterator _Nth, RandomAccessIterator _Last ); częściowo sortuje sekwencję określaną przez parę iteratorów [_First,_Last) w porządku nierosnącym. To znaczy, że: po posortowaniu elementy mniejsze od elementu wskazywane przez _Nth umieszczane są w lewej części sekwencji, tj. [_First, _Nth), natomiast większe w prawej [_Nth,_Last). Jednak żadna z podsekwencji nie musi być posortowana,

3 // std::nth_element, std::random_shuffle bool porownaj (int i,int j) { return (i>j); std::vector<int> V; for (int i=1; i<10; i++) V.push_back(i); // std::random_shuffle (V.begin(), V.end()); std::nth_element (V.begin(), V.begin()+5, V.end(), porownaj); std::cout << "V zawiera:"; for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it) template<class ForwardIterator, class Type> ForwardIterator lower_bound( ForwardIterator _First, ForwardIterator _Last, const Type& _Val ); zwraca iterator na pierwsze wystąpienie w posortowanej sekwencji [_First,_Last) elementu o wartości _Val, jeżeli w sekwencji brak takiego elementu, zwracany jest iterator do miejsca, w którym element ten powinien się znajdować, tj. do pierwszego elementu większego od poszukiwanej wartości, template<class ForwardIterator, class Type> ForwardIterator upper_bound( ForwardIterator _First, ForwardIterator _Last, const Type& _Val ); zwraca iterator na pierwszy element za ostatnim elementem o wartości _Val w posortowanej sekwencji [_First,_Last), jeżeli w sekwencji brak takiego elementu, zwracany jest iterator do miejsca, w którym element ten powinien się znajdować, tj. do pierwszego elementu większego od poszukiwanej wartości, 89 // std::lower_bound, std::upper_bound, std::sort int myints[] = {10,20,30,30,20,10,10,20; std::vector<int> v(myints,myints+8); // std::sort (v.begin(), v.end()); // std::vector<int>::iterator low,up; low=std::lower_bound (v.begin(), v.end(), 20); // up= std::upper_bound (v.begin(), v.end(), 20); // std::cout << "lower_bound at position " << (low- v.begin()) << '\n'; std::cout << "upper_bound at position " << (up - v.begin()) << '\n'; ^ ^ 90 template<class Forwa rditer ator, class Type> pair<for wardit erator, Forw ardite rator> equal _range ( ForwardIterator _Fir st, Fo rwardi terato r _Las t, const Ty pe& _V al ); zwraca parę iteratorów ograniczających w sekwencji [_First,_Last) podsekwencję elementów o wartości _Val, jeżeli w sekwencji brak takiego elementu, iteratory wskazują na miejsce, w którym element ten powinien się znajdować, tj. do pierwszego elementu większego od poszukiwanej wartości, szablonu reprezentującym obiekt funkcyjny/funk cję służący do porównań, Uwaga: elementy powinny być posortowane względem operatora < (elementy są uważane za równe, jeżeli: (!(a<b) &&!(b<a))) lub podanego obiektu funkcyjnego/funk cji służącej do porównań. 91 // std::equal_range, std::sort bool mygreater (int i,int j) { return (i>j); int myints[] = {10,20,30,30,20,10,10,20; std::vector<int> V(myints,myints+8); // std::pair<std::vector<int>::iterator,std::vector<int>::iterator> bounds; std::sort (v.begin(), v.end(), mygreater); // bounds=std::equal_range ( v.begin(), v.end(), 20, mygreater); // ^ ^ std::cout << "bounds at positions " << (bounds.first - v.begin()); std::cout << " and " << (bounds.second - v.begin()) << '\n'; 92 3

4 template <class ForwardIterator, class T> bool binary_search ( ForwardIterator _First, ForwardIterator _Last, const T& _Val); zwraca wartość logiczną true, jeżeli w posortowanej sekwencji [_First,_Last) znajduje się element o wartości _Val (dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a))), optymalizuje liczbę porównań poprzez dokonywanie porównań między niesąsiadującymi elementami z posortowanego zakresu, template<class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator merge( InputIterator2 _First2, InputIterator2 _Last2, łączy dwa identycznie posortowane zakresy elementów [_First1,_Last1) i [_First2,_Last2) w jeden posortowany zakres docelowy, którego początek jest wskazywany przez _Result, Wymagany jest kontener docelowy inny niż źródłowy, tj. nie może skierować wyniku swojego działania do kontenera, skąd pochodziły dane wejściowej // std::merge, std::sort int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); std::sort (first,first+5); std::sort (second,second+5); std::merge (first,first+5,second,second+5,v.begin()); std::cout << "Wynikowy wektor zawiera:"; // for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it) 95 template<class BidirectionalIterator> void inplace_merge( BidirectionalIterator _First, BidirectionalIterator _Middle, BidirectionalIterator _Last ); łączy dwa posortowane zakresy elementów [_First,_Middle) i [_Middle,_Last) w jeden sumaryczny zakres docelowy [_First,_Last). Próbuje alokować pomocniczy bufor na dane, aby zwiększyć efektywność, a jeżeli jest to niemożliwe, używa mniej efektywnego algorytmu. Różnice merge vs. inplace_merge: merge: liczba porównań co najwyżej distance(first1, last1) + distance(first2, last2) 1 inplace_merge: dokładnie N-1 porównań, jeżeli dostępny jest wystarczający obszar pamięci, w przeciwnym razie: N log(n) gdzie N = distance(first, last). 96 Różnice merge vs. inplace_merge: std::inplace_merge(a.begin(), a.begin() + n, a.end()); nie jest równoważny: std::merge(a.begin(), a.begin() + n, a.begin() + n, a.end(), a.begin()); ponieważ merge nie może skierować wyniku swojego działania do a (tj. do tego samego kontenera, z którego pochodziły dane wejściowe). inplace_merge przydaje się szczególnie wtedy, gdy działamy na systemie z niewielką pamięcią. 97 // std::inplace_merge, std::sort, std::copy int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); std::vector<int>::iterator it; std::sort (first,first+5); std::sort (second,second+5); it=std::copy (first, first+5, v.begin()); std::copy (second,second+5,it); std::inplace_merge (v.begin(),v.begin()+5,v.end()); std::cout << " Wynikowy wektor zawiera :"; // for (it=v.begin(); it!=v.end(); ++it) 98 4

5 template<class InputIterator1, class InputIterator2> bool includes( InputIterator2 _First2, InputIterator2 _Last2); sprawdza, czy wszystkie wartości z jednego posortowanego zakresu [_First1,_Last1) są zawarte w drugim posortowanym zakresie (_First2,_Last2) (tj. czy pierwszy jest podzbiorem drugiego dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a))), // std::includes, std::sort bool porownaj (int i, int j) { return i<j; int C1[] = {5,10,15,20,25,30,35,40,45,50; int C2[] = {40,30,20,10; std::sort (C1,C1+10); std::sort (C2,C2+4); if ( std::includes(c1,c1+10,c2,c2+4, porownaj) ) std::cout << "C1 zawiera C2!\n"; template<class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_union( InputIterator2 _First2, InputIterator2 _Last2, Łączy wszystkie elementy znajdujące się w przynajmniej jednym z dwóch posortowanych zakresów tworząc jeden wspólny posortowany zakres wynikowy (suma zbiorów) dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a)), Elementy z drugiego zakresu, które występują w pierwszym, nie są kopiowane Elementy w obydwu zakresach muszą być posortowane wg tego samego kryterium. Wynikowy porządek jest taki sam jak dla zakresów wejściowych. szablonu reprezentującym obiekt funkcyjny służący do porównań. 101 // std::set_union, std::sort int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); // std::vector<int>::iterator it; std::sort (first,first+5); // std::sort (second,second+5); // it=std::set_union (first, first+5, second, second+5, v.begin()); // v.resize(it-v.begin()); // std::cout << "Suma ma " << (v.size()) << " elementów:\n"; for (it=v.begin(); it!=v.end(); ++it) 102 template<class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_intersection( InputIterator2 _First2, InputIterator2 _Last2, łączy wszystkie elementy, które należą do obydwu posortowanych zakresów w jeden wspólny posortowany zakres wynikowy (przecięcie zbiorów) dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a)), Wszystkie elementy występujące w obydwu zakresach są kopiowane z pierwszego zakresu w takiej kolejności, w jakiej w nim występują. Elementy w obydwu zakresach muszą być posortowane wg tego samego kryterium. Wynikowy porządek jest taki sam jak dla zakresów wejściowych. szablonu reprezentującym obiekt funkcyjny służący do porównań. 103 // std::set_intersection, std::sort int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); // std::vector<int>::iterator it; std::sort (first,first+5); // std::sort (second,second+5); // it=std::set_intersection (first, first+5, second, second+5, v.begin()); // v.resize(it-v.begin()); // std::cout << "Część wspólna ma " << (v.size()) << " elementów:\n"; for (it=v.begin(); it!=v.end(); ++it) 104 5

6 template<class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_difference( InputIterator2 _First2, InputIterator2 _Last2, łączy wszystkie elementy, które należą do pierwszego, ale nie do drugiego z zakresów (obydwa muszą być posortowane) w jeden posortowany zakres wynikowy (różnica zbiorów) dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a)), Elementy są kopiowane do zakresu wynikowego wyłącznie z pierwszego zakresu w kolejności takiej, jak występują w tym przedziale. Elementy w obydwu zakresach muszą być posortowane wg tego samego kryterium. Wynikowy porządek jest taki sam jak dla zakresów wejściowych. szablonu UKSW, reprezentującym WMP. SNS, Warszawa obiekt funkcyjny służący do porównań. 105 // std::set_difference, std::sort int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); // std::vector<int>::iterator it; std::sort (first,first+5); // std::sort (second,second+5); // it=std::set_difference (first, first+5, second, second+5, v.begin()); // v.resize(it-v.begin()); // std::cout << "Różnica ma " << (v.size()) << " elementów:\n"; for (it=v.begin(); it!=v.end(); ++it) 106 template<class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_symmetric_difference( InputIterator2 _First2, InputIterator2 _Last2, łączy wszystkie elementy, które należą albo do jednego, albo do drugiego zakresu (obydwa muszą być posortowane) w jeden posortowany zakres wynikowy (różnica symetryczna zbiorów) dwa elementy a i b są uważane za równe, jeżeli: (!(a<b) &&!(b<a)), Kopiowane są elementy z obydwu zakresów z zachowaniem kolejności. Elementy w obydwu zakresach muszą być posortowane wg tego samego kryterium. Wynikowy porządek jest taki sam jak dla zakresów wejściowych. szablonu reprezentującym obiekt funkcyjny służący do porównań. 107 // std::set_symmetric_difference, std::sort int first[] = {5,10,15,20,25; int second[] = {50,40,30,20,10; std::vector<int> v(10); // std::vector<int>::iterator it; std::sort (first,first+5); // std::sort (second,second+5); // it=std::set_symmetric_difference(first,first+5,second,second+5,v.begin()); // v.resize(it-v.begin()); // std::cout << "Różnica symetr. ma " << (v.size()) << " elementów:\n"; for (it=v.begin(); it!=v.end(); ++it) 108 template<class InputIterator1, class InputIterator2> bool lexicographical_compare( InputIterator2 _First2, InputIterator2 _Last2 ); porównuje dwa przedziały element po elemencie aby wskazać ten mniejszy. Zwraca true, jeżeli pierwszy jest leksykograficznie mniejszy, lub false w przeciwnym przypadku, 109, std::boolalpha // std::lexicographical_compare #include <cctype> // std::tolower bool porownaj(char c1, char c2) { return std::tolower(c1)<std::tolower(c2); ; char V1[]="Apple"; char V2[]="apartment"; std::cout << std::boolalpha; std::cout << "Porównuje V1 i V2 leksykograficznie (V1<V2):\n"; std::cout << "Operator domyślny (<): "; std::cout << std::lexicographical_compare(v1,v1+5,v2,v2+9); std::cout << "Operator porownaj: "; std::cout << std::lexicographical_compare(v1,v1+5,v2,v2+9,porownaj); 110 6

7 template <class BidirectionalIterator> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last); zmienia porządek elementów w sekwencji [first, last) na następną, leksykograficznie większą permutację, Za pierwszą permutację przyjmujemy sekwencję posortowaną rosnąco. Za ostatnią malejąco. Zwraca true, jeżeli istnieje możliwość dokonania kolejnej permutacji i wykonuje ją. W przeciwnym przypadku, tj. kiedy osiągnięto już ostatnią permutację, zmienia prządek na pierwszą permutację i zwraca false. int myints[] = {1,2,3; std::sort (myints,myints+3); // std::next_permutation, std::sort // ustawiamy początkową permutację std::cout << "The 3! possible permutations with 3 elements:\n"; do { std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; while ( std::next_permutation(myints,myints+3) ); std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; Podsumowanie 1. partition 2. stable_partition 3. sort 4. stable_sort 5. partial_sort 6. partial_sort_copy 7. nth_element 8. lower_bound 9. upper_bound 10.equal_range 11.binary_search 12.merge 13.inplace_merge 14.includes 15.set_union 16.set_intersection 17.set_difference 18.set_symmetric_difference 19.lexicographical_compare 20.next_permutation accumulate 2. partial_sum 3. inner_product 4. adjacent_difference 114 template<class InputIterator, class Type> Type accumulate( InputIterator _First, InputIterator _Last, Type _Val ); sumuje wartości zawarte w sekwencji [_First,_Last) do wartości początkowej sumy zawartej w _Val. Zwraca wynik sumowania. chociaż domyślną operacją jest sumowanie, istnieje wersja z dodatkowym, ostatnim parametrem szablonu reprezentującym funkcję lub obiekt funkcyjny służący do wykonywania dowolnych innych operacji. #include <functional> // std::minus #include <numeric> // std::accumulate int init = 100; int numbers[] = {10,20,30; std::cout << "Domyślna suma: "; std::cout << std::accumulate(numbers,numbers+3,init); // Domyślna suma: 160 std::cout << "Minus z biblioteki <functional>: "; std::cout << std::accumulate (numbers, numbers+3, init, std::minus<int>()); // Minus z biblioteki <functional>:

8 #include <functional> // std::minus #include <numeric> // std::accumulate int MojaFun (int x, int y) {return x+2*y; // y element z zakresu struct MojaKlasa { int operator()(int x, int y) {return x+3*y; // y element z zakresu MObj; int init = 100; int numbers[] = {10,20,30; std::cout << "MojaFun: "; std::cout << std::accumulate (numbers, numbers+3, init, MojaFun); // MojaFun: 220 std::cout << "MObj : "; std::cout << std::accumulate (numbers, numbers+3, init, MObj); // Mobj: template<class InputIterator, class OutIt> OutputIterator partial_sum( InputIterator _First, InputIterator _Last, oblicza uogólnioną sumę częściową zbioru elementów z sekwencji [_First,_Last). Polega to na utworzeniu sekwencji wynikowej, której pierwszy element jest wskazywany przez _Result, zawierającej wartości będące sumą elementów poprzedzających każdą z tych wartości w sekwencji wejściowej. np. dla sekwencji wejściowej 1,2,3,4,5 sumy w sekwencji wynikowej będą miały wartości: 1, 1+2, 1+2+3, , chociaż domyślną operacją jest sumowanie istnieje wersja z dodatkowym, ostatnim parametrem szablonu reprezentującym funkcję lub obiekt funkcyjny służący do wykonywania dowolnych innych operacji. 118 #include <functional> // std::multiplies #include <numeric> // std::partial_sum int myop (int x, int y) {return x+y+1; // y element z zakresu int val[] = {1,2,3,4,5; int result[5]; std::partial_sum (val, val+5, result, std::multiplies<int>()); std::cout << "using functional operation multiplies: "; for (int i=0; i<5; i++) std::cout << result[i] << ' '; std::partial_sum (val, val+5, result, myop); std::cout << "using custom function: "; for (int i=0; i<5; i++) std::cout << result[i] << ' '; template<class InputIterator1, class InputIterator2, class Type> Type inner_product( InputIterator2 _First2, Type _Val ); oblicza iloczyn stanowiący odpowiednik iloczynu skalarnego dwóch wektorów reprezentowanych sekwencjami [_First1,_Last1) i _First2. Wartością takiej operacji jest suma iloczynów odpowiadających sobie elementów sekwencji powiększona o wartość bazową _Val: _Val + (*_First1) * (*_First2) +.. Dwie domyślne operacje dodawania oraz mnożenia można zastąpić dwoma funkcjami lub obiektami funkcyjnymi, odpowiednio op1 (domyślnie - dodawanie) i op2 (domyślnie - mnożenie) : _Val = _Val + (_First1)*(*_First2); _Val = op1 (_Val, op2(*_first1,*_first2)); #include <functional> // std::minus, std::divides #include <numeric> // std::inner_product int myaccumulator (int x, int y) {return x-y; int myproduct (int x, int y) {return x+y; double diffpow2(double x, double y) { return pow((x - y), 2.0); ; int init = 100; int series1[] = {10,20,30; int series2[] = {1,2,3; std::cout << std::inner_product(series1,series1+3,series2,init, std::minus<int>(),std::divides<int>()); std::cout << std::inner_product(series1,series1+3,series2,init, myaccumulator,myproduct); // odległość Euklidesowa miedzy series1 i series2: std::cout << std:: inner_product(series1,series1+3,series2,0,0, std::plus<double>(), diffpow2); template<class InputIterator, class OutIterator> OutputIterator adjacent_difference( InputIterator _First, InputIterator _Last, oblicza różnicę sąsiadujących elementów sekwencji źródłowej. Np. dla sekwencji 1,2,3,4,5 sekwencja wynikowa reprezentuje wartości: 1, 2-1, 3-2, 4-3, 5-4, domyślną operację odejmowania można zastąpić funkcją lub obiektem funkcyjnym

9 #include <functional> // std::multiplies #include <numeric> // std::adjacent_difference int myop (int x, int y) {return x+y; int val[] = {1,2,3,5,9,11,12; int result[7]; std::adjacent_difference (val, val+7, result, std::multiplies<int>()); std::cout << "using functional operation multiplies: "; for (int i=0; i<7; i++) std::cout << result[i] << ' '; std::adjacent_difference (val, val+7, result, myop); std::cout << "using custom function: "; for (int i=0; i<7; i++) std::cout << result[i] << ' '; 123 Ogólna konwencja dotycząca parametrów algorytmów: alg(beg, end, other args); alg(beg, end, dest, other args); alg(beg, end, beg2, other args); alg(beg, end, beg2, end2, other args); beg, end zakres pierwszego zbioru przechowującego dane wejściowe, na których działa algorytm alg dest iterator wskazujący miejsce, gdzie ma być zapisany wynik działania algorytmu alg. Algorytm zakłada, że miejsce to jest bezpieczne, tj. np. dostatecznie duże (nie wykonuje kroku weryfikacji). beg2, end2 zakres drugiego zbioru przechowującego dane wejściowe; algorytmy, korzystające tylko z beg2 zakładają, że liczba elementów drugiej sekwencji jest co najmniej tak duża jak zakres beg, end. 124 Ogólna konwencja dotycząca parametrów algorytmów: Algorytmy używające predykatów występują w dwóch wersjach, np.: 1. unique(beg, end); // używa == do porównywania 2. unique(beg, end, comp); // używa comp do porównywania Pierwsza używa przeciążonego operatora logicznego < lub == zdefiniowanego dla typu danych przechowywanych w kontenerze. Druga używa obiektu funkcyjnego, tj. predykatu comp Ogólna konwencja dotycząca parametrów algorytmów: Algorytmy mające w nazwie if występują w dwóch wersjach, np.: 1. find(beg, end, val); // znajduje pierwsze wystąpienie val 2. find_if(beg, end, pred); // znajduje pierwszą wartość, // gdzie pred==true Algorytmy mające w nazwie _copy występują w dwóch wersjach, np.: 1. reverse(beg, end); // odwraca porządek elementów 2. reverse_copy(beg, end, dest); // kopiuje w odwrotnym // porządku do dest Algorytmy kontenera list: W przeciwieństwie do innych kontenerów, kontener list definiuje kilka algorytmów jako swoje własne metody. Np. dla obiektu lst można wywołać: lst.merge(lst2); // używa operatora < lst.merge(lst2, comp); // używa comp lst.remove(val); // używa operatora == lst.remove_if(pred); // używa pred lst.reverse(); lst.sort(); // używa operatora < lst.sort(comp); // używa comp lst.unique(); // używa operatora == lst.unique(pred); // używa pred 127 Algorytmy kontenera list: Algorytm splice może wystąpić z różnymi listami argumentów, np. dla lst.splice : 1. (p, lst2), gdzie p iterator na element w lst. Przenosi elementy z kontenera lst2 do lst tuż przed p usuwając je z lst2 (lst i lst2 nie mogą być tym samym kontenerem i muszą być tego samego typu), 2. (p, lst2, p2), gdzie p iterator na element w lst, a p2 iterator na element w lst2. Przenosi element p2 do lst w miejsce tuż przed p. (lst i lst2 mogą być tym samym kontenerem), 3. (p, lst2, b, e), gdzie p iterator na element w lst, a b i e określają przedział w kontenerze lst2. Przenosi elementy z przedziału do lst w miejsce tuż przed p. (lst i lst2 mogą być tym samym kontenerem, ale p nie może należeć do przedziału b,e)

10 Algorytmy kontenera list: Algorytmy zadeklarowane jako metody są szybsze od algorytmów generycznych: algorytmy generyczne zamieniają przechowywane wartości (dodają w jednych i usuwają w innych odpowiednich miejscach w liście), algorytmy zadeklarowane jako metody działają na wskaźnikach reprezentujących linki między elementami kontenera (mają dostęp do składowych chronionych i prywatnych i wykorzystują to efektywnie)