C++ Standard Template Library

Az előadások a következő témára: "C++ Standard Template Library"— Előadás másolata:

1 C++ Standard Template Library
Időhatékonyság elemzés Dudás László Miskolci Egyetem Alkalmazott Informatikai Tanszék

2 Az algoritmusok aszimptotikus hatékonysága
Egy korlát az algoritmusok műveleteire akkor válik érdekessé, ha n nagy pozitív értékeket vesz fel A korlátokat a c1∙g(n) és c2∙g(n) burkolófüggvények adják A függvény pontos aszimptotikus viselkedését a (n), az alsó aszimptotikus korlátot (n) és a felső azimptotikus korlátot O(n) függvény adja. n f(n) c2∙g(n) n0 O(n) jelölés, f(n)O(g(n)) 1

3 Az O(1) és O(n) időkomplexitás megértése
Az O(1) complexitás azt jelenti, hogy lehet a tároló n elemszáma akármilyen nagy, a művelet f(n) időigénye (a műveletek száma) n-től függetlenül közel állandó, nem függ n-től Példa: egy vektor elem elérése, at(k) n f(n) c c∙g(n)=c∙1 2

4 Az O(1) és O(n) időkomplexitás megértése ..
O(n) complexitás azt jelenti, hogy f(n) burkolható a c1· g(n) = c1·n függvénnyel (ha n ≥ n0). Példa: az L2 listának L-be való belehelyezése a p pozíciótól, L.splice(p,L2) n f(n) c1 · g(n)= c1 · n n0 3

5 Példaprogram O(1) és O(n) időkomplexitásra
#include <iostream> #include <vector> #include <ctime> using namespace std; vector<int> v( ,5); // a méretet változtattuk, 10M..80M void main(){ clock_t start, stop; start= clock(); for (int j= 0; j< ; ++j){ v.pop_back(); v.push_back(7); } stop= clock(); // a mérhető időhöz nagyszámú ismétlést alkalmaztunk cout<< "Time of pop_back - push_back pair= " << double(stop-start)/CLOCKS_PER_SEC << " sec" << endl; // folytatva 4

6 Példaprogram O(1) és O(n) időkomplexitásra..
start= clock(); for (int j= 0; j< ; ++j){ v.push_back(7); v.pop_back(); } stop= clock(); cout<< "Time of push_back - pop_back pair= " << double(stop-start)/CLOCKS_PER_SEC << " sec" << endl; vector<int> v( ,5); vector<int> v( ,5); vector<int> v( ,5); 5

7 Példaprogram O(1) és O(n) időkomplexitásra..
vector<int> v( ,5); vector<int> v( ,5); vector<int> v( ,5); vector<int> v( ,5); vector<int> v( ,5); 6

8 A mért idők diagramja n 0.01 1 pop - push [sec] push - pop 0.02 0.03 0.04 0.05 0.06 2 10 20 30 40 50 60 70 80 *106 O(1) O(n) A pop_back() - push_back() és a push_back() - pop_back() párok időkomplexitása 7

9 A megoldás Mindkét esetben push_back() és pop_back() függvényeket használtunk. Miért adódott ilyen nagy eltérés ??? kapacitás megnövelés pop - push push - pop 5 5 5 5 5 5 5 5 pop push O(n) lépés 5 5 5 5 5 5 5 7 push pop 5 5 5 7 5 5 5 5 pop push O(1) lépések 5 5 5 5 5 5 5 7 8

10 végrehajtva a c tárolón
A fő műveletek időkomplexitása Művelet végrehajtva a c tárolón Idő komplexitás vector list Konstruktorok c; O(1) c(n); O(n) c(n, T init); c(c2); c(iterator1, iterator2); Destruktor ~container(); 9

11 végrehajtva a c tárolón vagy a v vektoron
A fő műveletek időkomplexitása .. Művelet végrehajtva a c tárolón vagy a v vektoron Idő komplexitás vector list Tagfüggvények c.begin() O(1) c.end() c.empty() c.size() v.max_size() - v.capacity() v.reserve(n) O(n) v.resize(n,T init=T()) 10

12 végrehajtva a c tárolón vagy a v vektoron
A fő műveletek időkomplexitása .. Művelet végrehajtva a c tárolón vagy a v vektoron Idő komplexitás vector list Tagfüggvények c1 == c2 O(n) c1 != c2 c1 < c2 c1 = c2; v[ ] O(1) - v.at(n) c.front() c.back() 11

13 végrehajtva a c tárolón vagy az L listán
A fő műveletek időkomplexitása .. Művelet végrehajtva a c tárolón vagy az L listán Idő komplexitás vector list Tagfüggvények c.push_back(e) n≤capacity O(1) c.push_back(e) n>capacity O(n) c.pop_back() L.push_front(e) - L.pop_front() c.erase(p) c.insert(p,e) c.clear() 12

14 Vektorelem indexes elérése szemben a lista soros elérésével
#include <iostream> #include <vector> #include <list> #include <ctime> using namespace std; // Indexelt elérés vs soros elérés demo vector<int> v( ,5); // tíz millió elem list<int> L( ,5); list<int>::iterator Lit; void main(){ clock_t start, stop; int element; start= clock(); for (int j= 0; j< ; ++j) element= v[ ]; // indexes elérés stop= clock(); cout<< "Direct access time in vector= " << double(stop-start)/CLOCKS_PER_SEC << " sec" << endl; // folytatva 13

15 A középső elem elérése 1 milliószor, illetve 1000-szer
Vektorelem indexes elérése szemben a lista soros elérésével .. start= clock(); for (int j=0; j< 1000; ++j){ // Nem akartam olyan sokáig Lit= L.begin(); // várni ... for (int i=0; i< ; ++i) ++Lit; element= *Lit; // sok léptetés után végre elértük } stop= clock(); cout<< "Sequential access time in list= " << *(stop-start)/CLOCKS_PER_SEC << " sec" << endl; A középső elem elérése 1 milliószor, illetve 1000-szer 14

16 A c.insert(p,e) és a c.erase(p) műveletek időigényének összevetése vector és list tárolóknál
#include <iostream> #include <vector> #include <list> #include <ctime> using namespace std; vector<int> v( ,5); vector<int>::iterator vit; list<int> L( ,5); list<int>:: iterator Lit; void main(){ clock_t start, stop; vit= v.begin(); vit+= ; // középre pozicionálás start= clock(); v.erase(vit);v.insert(vit,7); // insert-erase sorrend stop= clock(); // hibát okoz! cout<< "Time of insertion and erasing in case of vector= " << *(stop-start)/CLOCKS_PER_SEC << " sec" << endl; // folytatva 15

17 Egy elem beszúrása és törlése 100 000-szer
A c.insert(p,e) és a c.erase(p) műveletek időigényének összevetése vector és list tárolóknál .. Lit= L.begin(); // a lista közepére pozicionálás igényel egy kis időt: for (int i=0; i< ; ++i) ++Lit; start= clock(); for (int j=0; j< ; ++j){ L.insert(Lit,7); L.erase(Lit);// lista esetén ez a // sorrend jó } stop= clock(); cout<< "Time of insertion and erasing in case of list= " << double(stop-start)/CLOCKS_PER_SEC << " sec" << endl; Egy elem beszúrása és törlése szer 16

18 1. sourece: www.tapetki.uq.pl
Megjegyzések A tárolók különféle típusai belső struktúrájának és működésének megértése segít kiválasztani a megfelelő típust Lehetséges, hogy egy művelet szor gyorsabbá válik a megfelelő tárolótípus alkalmazása után Ne feledjük a tárolóelemekként alkalmazott komplex objektumok konstruktorainak és destruktorának lassú működését. 1. 17 1. sourece: