Documente Academic
Documente Profesional
Documente Cultură
Algoritmii acoper un domeniu larg de operaii generale asupra containerelor precum: traversare, sortare, cutare, inserare sau tergere de elemente. Algoritmii sunt funcii generice, care se refer la containere prin intermediul iteratorilor. Tipurile iteratorilor folosii de un algoritm sunt date ca parametri ai ablonului. Algoritmii sunt declarai n zona de nume std i semnturile lor se afl n fiierul antet algorithm. Cei mai muli algoritmi sunt scuri i simpli, putnd fi definii inline. Algoritmii care produc rezultate pe care le depun ntr-un container sunt clasificai ca algoritmi de copiere i au numele terminat cu sufixul _copy. Algoritmii a cror funcionare este determinat de satisfacerea unui predicat sunt cunoscui ca algoritmi cu predicate. Lista de parametri a unui asemenea algoritm va conine un obiect funcie predicat. Numele acestor algoritmi conine sufixul _if. n prezentarea algoritmilor vom utiliza urmtoarele abrevieri: InIt - InputIterator, OutIt OutputIterator, FwIt ForwardIterator, BIt BidirectionalIterator, RAIt RandomAccessIterator, Pred Predicate, BinPred BinaryPredicate, OpUnar UnaryOperator, Func Function, T value_type (tipul elementelor din container)
template <class InIt, class T> size_t count_if(InIt prim, InIt ultim, Pred p); 4. compararea a dou secvene equal() ntoarce true/false dac cele dou secvene sunt egale sau dac toate perechile satisfac predicatul template<class InIt1,class InIt2> bool equal(InIt1 prim1, InIt1 ultim1, InIt2 prim2); template<class InIt1, class InIt2, class BinPred> bool equal(InIt1 prim1, InIt1 ultim1, InIt2 prim2, BinPred p); mismatch()ntoarce iteratori la prima pereche de elemente neegale, respectiv perechea care nu satisface predicatul din cele dou secvene. template<class InIt1,class InIt2> pair<InIt1,InIt2> mismatch(InIt1 prim1, InIt1 ultim1, InIt2 prim2); template<class InIt1, class InIt2, class BinPred> pair<InIt1,InIt2> mismatch(InIt1 prim1, InIt1 ultim1, InIt2 prim2, BinPred p); 5 cutarea unei secvene search() determin prima apariie a secvenei2 ca subsecven a secvenei1, respectiv prima apariie a secvenei2 ca subsecven n secvena1 cu elemente aflate n relaia dat cu elementele din secvena2. ntoarce un iterator la primul element din prima secven egalat cu secvena2. template <class FwIt1, class FwIt2> FwIt1 search(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2); template <class FwIt1, class FwIt2, class BinPred> FwIt1 search(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2,BinPred p); find_end() determin ultima apariie a secvenei2 ca subsecven a secvenei1. ntoarce un iterator la primul element din ultima secven egalat cu secvena2. template <class FwIt1, class FwIt2> FwIt1 find_end(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2); template <class FwIt1, class FwIt2, class BinPred> FwIt1 find_end(FwIt1 prim1,FwIt1 ultim1,FwIt2 prim2,FwIt2 ultim2,BinPred p); search_n() gsete o secven cu cel puin n elemente egale / sau n relaia p cu valoarea val. ntoarce un iterator la prima secven de n asemenea elemente. template <class FwIt, class Size, class T> FwIt search_n(FwIt prim, FwIt ultim,Size n, const T& val); template <class FwIt, class Size, class T, class BinPred> FwIt search_n(FwIt prim, FwIt ultim,Size n, const T& val, BinPred p);
template <class BIt1, class BIt2> BIt2 copy_backward(BIt1 prim, BIt1 ultim, BIt2 rez){ while(prim != ultim) *--rez = *--ultim; return rez; } copy_if() copiaz toate valorile din intervalul de iteratori care satisfac predicatul, la destinaie. template <class It1, class It2, class Pred> It2 copy_if(It1 prim, It1 ultim, It2 rez, Pred p){ while(prim != ultim){ if(p(*prim)) *rez++ = *prim; prim++; } return rez; } 2. nlocuiri familia replace replace() nlocuiete toate apariiile ale unei valori vechi valv din intervalul de iteratori cu o valoare nou valn template <class FwIt, class T> void replace(FwIt prim, FwIt ultim, const T& valv, const T& valn); replace_if() nlocuiete toate valorile care satisfac o anumit condiie din intervalul de iteratori cu o valoare nou. template <class FwIt, class T, class Pred> void replace_if(FwIt prim, FwIt ultim, Pred p, const T& valn); Cei doi algoritmi au i variante replace_copy() i replace_copy_if(), n care nlocuirea nu se face in situ ci la o destinaie, specificat printr-un iterator. template <class InIt, class OutIt, class T> OutIt replace_copy(InIt prim, InIt ultim, OutIt rez, const T& valv, const T& valn); template <class InIt, class OutIt, class T, class Pred> OutIt replace_copy_if(InIt prim, InIt ultim, OutIt rez, Pred p, const T& valn); 3. tergeri familia remove remove() terge toate valorile din domeniul de iteratori egale cu o valoare dat template <class FwIt, class T> FwIt remove(FwIt prim, FwIt ultim, const T& val); remove_if() terge toate valorile din domeniul de iteratori care satisfac un predicat template <class FwIt, class Pred> FwIt remove_if(FwIt prim, FwIt ultim, Pred p); i variantele remove_copy() i remove_copy_if() template <class InIt, class OutIt, class T> OutIt remove_copy(InIt prim, InIt ultim, OutIt rez, const T& val); template <class InIt, class OutIt, class Pred> OutIt remove_copy_if(InIt prim, InIt ultim, OutIt rez, Pred p); 4. interschimbri familia swap interschimb elementele sau chiar containerele swap() interschimb dou elemente individuale (chiar din containere diferite) template <class T> void swap(T& a, T& b); iter_swap ()interschimb dou elemente localizate prin iteratori template <class FwIt1, class FwIt2>
void iter_swap(FwIt1 a, FwIt2 b); swap_ranges() interschimb elementele din dou intervale de iteratori template <class FwIt1, class FwIt2> void swap_ranges(FwIt1 prim1, FwIt1 ultim1, FwIt2 prim2); 5. transform() aplic un operator unar elementelor dintr-un interval de iteratori, depunnd elementele transformate n alt interval de iteratori template <class InIt, class OutIt, class OpUnar> OutIt transform(InIt prim, InIt ultim, OutIt rez, OpUnar op); 6. generate() completeaz elementele din intervalul de iteratori cu valori obinute de la un functor generator (predicat fr argumente) template <class FwIt, class Generator> void generate(FwIt prim, FwIt ultim, Generator gen); generate_n() completeaz cu valori furnizate de generator primele n elemente dintr-un domeniu de iteratori template <class OutIt, class Size, class Generator> OutIt generate_n(OutIt prim, Size n, Generator gen); 7. fill() completeaz cu aceeai valoare elementele dintr-un domeniu de iteratori
template <class FwIt, class T> void fill(FwIt prim, FwIt ultim, const T& val); fill_n() completeaz cu aceeai valoare primele n elemente dintr-un domeniu de iteratori template <class OutIt, class Size, class T> OutIt fill_n(OutIter prim, Size n, const T& val); 8. unique() terge elementele consecutive identice cu un element / sau elementele consecutive elementului, aflate n relaie cu acesta. template <class FwIt> FwIt unique(FwIt prim, FwIt ultim); template <class FwIt, class Pred> FwIt unique(FwIt prim, FwIt ultim, Pred p); i variantele _copy: template <class InIt, class OutIt> OutIt unique_copy(InIt prim, InIt ultim, OutIt rez); template <class InIt, class OutIt, class Pred> OutIt unique_copy(InIt prim, InIt ultim, OutIt rez, Pred p); 9. reverse() inverseaz ordinea elementelor din secven
template <class BIt> void reverse(BIt prim, BIt ultim); template <class BIt, class OutIt> OutIt reverse_copy(InIt prim, InIt ultim, OutIt rez); 10. rotate() deplaseaz la stnga elemenetele secvenei; elementele scoase sunt inserate la sfritul secvenei (deplasare circular). Iteratorul med indic nceputul secvenei de elemente rotite. template <class FwIt> void rotate(FwIt prim, FwIt med, FwIt ultim); template <class FwIt, class OutIt> OutIt rotate(FwIt prim, FwIt med, FwIt ultim, OutIt rez);
11. partition() mparte secvena n dou intervale, astfel c elementele care satisfac un predicat vor fi plasate n primul interval (naintea celorlalte). template <class BIt, class Pred> BIt partition(BIt prim, BIt ultim, Pred p); stable_partition() realizeaz n plus fa de algoritmul precedent, ordonarea relativ a elementelor din fiecare partiie template <class BIt, class Pred> BIt stable_partition(BIt prim, BIt ultim, Pred p); 12. random_shuffle() amestec aleatoriu ordinea elementelor din secven. Generatorul de numere aleatoare poate fi specificat ca argument template <class RAIt> void random_shuffle(RAIt prim, RAIt ultim); template <class RAIt, class RandGen> void random_shuffle(RAIt prim, RAIt ultim, RandGen& rand); 13. iota() umple un interval de iteratori cu valori cresctoare, pornind cu o valoare dat ca parametru
template <class FwIt, class T> void iota(FwIt prim, FwIt ultim, T val);
4. nth_element() furnizeaz cel de al n-lea element din secvena sortat cresctor sau descresctor (fr a sorta secvena). template <class RAIt> void nth_element(RAIt prim, RAIt nth, RAIt ultim); template <class RAIt, class Compare> void nth_element(RAIt prim, RAIt nth, RAIt ultim, Compare cp); Valoarea lui n este precizat prin cel de-al doilea parametru n=nth-prim, nainte de apel; dup apel *nth conine cel de-al n-lea element din secvena sortat. Complexitatea n medie este O(N). 5. sortat. binary_search() permite localizarea foarte rapid n O(log n) a unui element ntr-un container cu acces direct
template <class FwIt, class T> bool binary_search(FwIt prim, FwIt ultim, const T& val); template <class FwIt, class T, class Compare> bool binary_search(FwIt prim, FwIt ultim, const T& val, Compare cp); 6. lower_bound() gsete prima poziie i dintr-o secven sortat, n care poate fi inserat o valoare val astfel ca relaia de ordine s se pstreze, adic *j < val (respectiv comp(*j, val)=true)pentru j [prim, i) template <class FwIt, class T> FwIt lower_bound(FwIt prim, FwIt ultim, const T& val); template <class FwIt, class T, class Compare> FwIt lower_bound (FwIt prim, FwIt ultim, const T& val, Compare cp); 7. upper_bound() gsete ultima poziie i dintr-o secven sortat, n care poate fi inserat o valoare val astfel ca relaia de ordine s se pstreze. template <class FwIt, class T> FwIt upper_bound(FwIt prim, FwIt ultim, const T& val); template <class FwIt, class T, class Compare> FwIt upper_bound (FwIt prim, FwIt ultim, const T& val, Compare cp); 8. equal_range() determin cel mai mare interval dintr-o secven sortat, n care poate fi inserat o valoare val , n orice poziie, astfel ca relaia de ordine s se pstreze. template <class FwIt, class T> pair<FwIt,FwIt> equal_range(FwIt prim, FwIt ultim, const T& val); template <class FwIt, class T, class Compare> pair<FwIt,FwIt> equal_range(FwIt prim, FwIt ultim, const T& val, Compare cp); 9. interclasare merge() combin dou secvene sortate ntr-o secven de asemeni sortat. Are complexitate liniar. template <class InIt1, class InIt2, class OutIt> OutIt merge(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez); template <class InIt1, class InIt2, class OutIt, class Compare> OutIt merge(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez,Compare cp); inplace_merge() dac cele dou domenii de iteratori sunt contigue([prim, med) i [med, ultim)), s-ar putea face interclasare peste ele, dac s-ar utiliza o zon tampon de memorie. Rezultatul interclasrii va fi plasat n [prim,ultim) template <class BIt> BIt inplace_merge(BIt prim, BIt med, BIt ultim); template <class BIt, class Compare> BIt inplace_merge(BIt prim, BIt med, BIt ultim, Compare cp);
Algoritmi cu mulimi. 6
Descriu principalele operaii cu mulimi (incluziune, reuniune, intersecie, diferen) pentru mulimi (containere sortate). Au complexitate liniar O(N1+N2), unde N1 i N2 sunt cardinalele celor dou mulimi. 1. includes() determin dac mulimea M2 este inclus n mulimea M1.
template <class InIt1, class InIt2> bool includes(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2); template <class InIt1, class InIt2, class OutIt, class Compare> bool includes (InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, Compare cp); 2. set_union() construiete mulimea reuniune M1 M2 a mulimilor date prin intervalele de iteratori
template <class InIt1, class InIt2, class OutIt> OutIt set_union(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez); template <class InIt1, class InIt2, class OutIt, class Compare> OutIt set_union(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez, Compare cp); 3. set_intersection()construiete mulimea intersecie M1 M2 a mulimilor date prin intervalele de iteratori
template <class InIt1, class InIt2, class OutIt> OutIt set_intersection(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez); template <class InIt1, class InIt2, class OutIt, class Compare> OutIt set_intersection(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez, Compare cp); 4. set_difference() construiete mulimea diferen M1-M2 a mulimilor date prin intervalele de iteratori (conine elementele din prima mulime care nu apar n cea de a doua) template <class InIt1, class InIt2, class OutIt> OutIt set_difference(InIt1 prim1,InIt1 ultim1,InIt2 prim2,InIt2 ultim2,OutIt rez); template <class InIt1, class InIt2, class OutIt, class Compare> OutIt set_difference(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez, Compare cp); 6. set_symmetric_difference() construiete mulimea diferen simetric (M1-M2) (M2-M1)=(M1 M2)(M1 M2) a mulimilor date prin intervalele de iteratori (conine elementele din cele dou mulimi exceptnd elementele comune) template <class InIt1, class InIt2, class OutIt> OutIt set_symmetric_difference(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez); template <class InIt1, class InIt2, class OutIt, class Compare> OutIt set_symmetric_difference(InIt1 prim1, InIt1 ultim1, InIt2 prim2, InIt2 ultim2, OutIt rez, Compare cp);
Algoritmi cu heapuri.
Un heap este un arbore binar complet parial ordont, folosit pentru implementarea cozii prioritare. 1. pop_heap()rearanjeaz elementele din intervalul [prim, ultim-1), astfel c dac se extrage un element din vrful heapului (din poziia prim) prin interschimbul cu elementul din poziia ultim-1 , noul interval [prim,ultim-1) s reprezinte un heap. Complexitatea operaiei este O(log(ultim-prim)). template <class RAIt> void pop_heap(RAIt prim, RAIt ultim); template <class RAIt, class Compare> void pop_heap (RAIt prim, RAIt ultim, Compare cp); 2. push_heap()rearanjeaz elementele din heap astfel c dac se adaug un element n ultima poziie ultim-1 intervalul [prim, ultim) s reprezinte n continuare un heap. Complexitatea operaiei este O(log(ultim-prim))
template <class RAIt> void push_heap(RAIt prim, RAIt ultim); template <class RAIt, class Compare> void push_heap (RAIt prim, RAIt ultim, Compare cp); 3. make_heap() aranjeaz elementele din intervalul de iteratori, astfel nct acestea s reprezinte un heap
template <class RAIt> void make_heap(RAIt prim, RAIt ultim); template <class RAIt, class Compare> void make_heap (RAIt prim, RAIt ultim, Compare cp); 4. sort_heap() transform un heap ntr-o secven sortat (metoda de sortare heapsort). Complexitatea este O(N log N) i sortarea nu este stabil. template <class RAIt> void sort_heap(RAIt prim, RAIt ultim); template <class RAIt, class Compare> void sort_heap (RAIt prim, RAIt ultim, Compare cp);
Algoritmi de permutare.
O permutare provine dintr-o secven prin schimbarea ntre ele a dou elemente. Pentru o secven avnd N elemente, exist N! permutri. Mulimea celor N! permutri se poate considera ordonat dup relaia < (i n general comp) ntre elemente. Conform acestei relaii de ordine putem defini permutarea urmtoare (respectiv permutarea precedent) n raport cu permutarea curent. prev_permutation(), next_permutation() genereaz n intervalul de iteratori permutarea precedent (urmtoare). ntoarece true dac exist permutarea precedent (urmtoare) i false n caz contrar. template <class BIt> bool prev_permutation(BIt prim, BIt ultim); template <class Bit, class Compare> bool prev_permutation(BIt prim, BIt ultim, Compare cp); template <class BIt> bool next_permutation(BIt prim, BIt ultim);
template <class Bit, class Compare> bool next_permutation(BIt prim, BIt ultim, Compare cp);
Algoritmi numerici.
Descriu operaii numerice generale. Accesul la acetia se obine prin includerea fiierului antet <numeric>. 1. accumulate() adun la elementele din intervalul de iteratori o valoare iniial dat ca parametru.
template <class InIt, class T> T accumulate(InIt prim, InIt ultim, T vinit); template <class InIt, class T, class BinOp> T accumulate(InIt prim, InIt ultim, T vinit, BinOp bop); 2. inner_product() adaug o valoare iniial la produsul scalar al celor dou containere x i y:
rez = vinit +
yi .
template <class InIt1, class InIt2, class T> T inner_product(InIt1 prim1, InIt1 ultim1, init2 prim2, T vinit); template <class InIt1, class InIt2, class T, class BinOp1, class BinOp2> T inner_product(InIt1 prim1, InIt1 ultim1, InIt2 prim2, T vinit, BinOp1 bop1, BinOp2 bop2); 3. etc. partial_sum() calculeaz n containerul rezultat valorile acumulate din prima poziie, primele dou, primele trei,
template <class InIt, class OutIt> OutIt partial_sum(InIt prim, InIt ultim, OutIt rez); template <class InIt, class OutIt, class BinOp> OutIt partial_sum(InIt prim, InIt ultim, OutIt rez, BinOp bop); 4. adjacent_difference() calculeaz diferenele ntre elementele consecutive ale unui container c, adic d0=c0, di=ci-ci-1, i>0. template <class InIt, class OutIt> OutIt adjacent_difference(InIt prim, InIt ultim, OutIt rez); template <class InIt, class OutIt, class BinOp> OutIt adjacent_difference (InIt prim, InIt ultim, OutIt rez, BinOp bop);