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

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

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

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

Példaprogram O(1) és O(n) időkomplexitásra #include <iostream> #include <vector> #include <ctime> using namespace std; vector<int> v(10000000,5); // a méretet változtattuk, 10M..80M void main(){ clock_t start, stop; start= clock(); for (int j= 0; j< 1000000; ++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

Példaprogram O(1) és O(n) időkomplexitásra.. start= clock(); for (int j= 0; j< 1000000; ++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(10000000,5); vector<int> v(20000000,5); vector<int> v(30000000,5); 5

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

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

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

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

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

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

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

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(10000000,5); // tíz millió elem list<int> L(10000000,5); list<int>::iterator Lit; void main(){ clock_t start, stop; int element; start= clock(); for (int j= 0; j< 1000000; ++j) element= v[5000000]; // indexes elérés stop= clock(); cout<< "Direct access time in vector= " << double(stop-start)/CLOCKS_PER_SEC << " sec" << endl; // folytatva 13

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< 5000000; ++i) ++Lit; element= *Lit; // sok léptetés után végre elértük } stop= clock(); cout<< "Sequential access time in list= " << 1000.0*(stop-start)/CLOCKS_PER_SEC << " sec" << endl; A középső elem elérése 1 milliószor, illetve 1000-szer 14

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(10000000,5); vector<int>::iterator vit; list<int> L(10000000,5); list<int>:: iterator Lit; void main(){ clock_t start, stop; vit= v.begin(); vit+=5000000; // 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= " << 100000.0*(stop-start)/CLOCKS_PER_SEC << " sec" << endl; // folytatva 15

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<5000000; ++i) ++Lit; start= clock(); for (int j=0; j< 100000; ++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 100 000-szer 16

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 104-106-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: www.tapetki.uq.pl