1 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 1(279) Tietorakenteet ja algoritmit II Simo Juvaste Itä-Suomen yliopisto Tietojenkäsittelytiede 13.4.2011 08:47
Sisällysluettelo (kalvot 13.4.2011) Luku 1: Kertausta algoritmiikasta ja aikavaativuudesta 5 1.1 Kertausta algoritmien ja tietorakenteiden käsitteistä 8 1.2 Suorituksen vaativuus 11 1.3 Rekursiivisten algoritmien aikavaativuus 28 1.4 Aikavaativuuden rajojen todistaminen 45 1.5 Kokeellinen aikavaativuuden määrääminen 50 1.6 Abstraktit tietotyypit (*) 59 1.7 Kertaus abstrakteihin tietotyyppeihin (*) 64 1.8 Lista (*) 67 1.9 Puu (*) 86 1.10 Hakupuut (*) 89 1.11 Joukot (*) 100 Luku 2: Suunnatut verkot 112 2.1 Käsitteitä 115 2.2 Suunnattu verkko abstraktina tietotyyppinä 120 2.3 Lyhimmät polut 130 2.4 Verkon läpikäynti 142 2.5 Muita verkko-ongelmia 147 2 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 2(279)
Luku 3: Suuntaamattomat verkot 162 3.1 Määritelmiä 163 3.2 Pienin virittävä (kattava) puu 166 3.3 Suuntaamattoman verkon läpikäynti 176 3.4 Leikkaussolmut ja 2-yhtenäiset komponentit 180 3.5 Verkon kaksijakoisuus, sovitus 184 Luku 4: Algoritmistrategioita 190 4.1 Ahne eteneminen 191 4.2 Hajoita-ja-hallitse 193 4.3 Dynaaminen ratkaiseminen (ohjelmointi) 195 4.4 Tasoitettu aikavaativuus 198 4.5 Haun rajoittaminen 200 4.6 Satunnaistetut algoritmit 201 4.7 Kantalukulajittelu 203 4.8 Merkkijonon haku 208 Luku 5: Ulkoisen muistin käsittely 222 5.1 Tiedostokäsittely 224 5.2 Onko keskusmuisti ulkoista muistia? 230 5.3 Ulkoinen lajittelu 239 5.4 Tiedosto kokoelmana (*) 243 5.5 B-puu 250 3 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 3(279)
Luku 6: Abstraktien tietotyyppien toteuttaminen (kertausta ja pari täydennystä TRAI:een) (*) 255 6.1 Kotelointi ja parametrointi 257 6.2 Verkot 268 Kirjallisuutta 277 4 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 4(279)
Luku 1 5 Kertausta algoritmiikasta ja aikavaativuudesta Kertausta algoritmiikasta ja aikavaativuudesta Kurssin tavoite ja sisältö Kerrata ja jatkaa TRAI:n asioita. Kerrata perustietorakenteet (lista, puu, joukko). Oppia abtrakti tietotyyppi verkko ja sen käyttö. Syventää aikavaativuusosaamista. Rekursiiviset algorimit. Ongelman aikavaativuus. Massamuistin käytön aikavaativuus. Oppia valitsemaan kuhunkin tarkoitukseen sopivin tietorakenne. Oppia käyttämään valittua tietorakennetta oikein! Oppia suunnittelemaan ja toteuttamaan algoritmeja. Käymme läpi algoritmistrategioita. Käymme läpi erilaisia algoritmeja ja niiden toteutuksia. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 5(279)
Miksi tietorakenne? 6 Kertausta algoritmiikasta ja aikavaativuudesta Tietoa on helpompi ja tehokkaampi käsitellä sovelluksen vaatimalla tavalla kun se tallennetaan sopivaan tietorakenteeseen. Tiedolla on helpompi mallintaa reaalimaailmaa kun sen rakenne vastaa reaalimaailmaa. Käsittelytehokkuuden ja reaalimaailman yhdistäminen vaatii joskus eri tietorakenteiden yhteiskäyttöä. Ohjelmasta tulee selkeämpi ( virheettömämpi, siirrettävämpi, ymmärrettävämpi, muutettavampi). Järjestelmän suunnittelijankin on hyvä ymmärtää miten tieto järjestelmässä tallennetaan. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 6(279)
Miksi tehokkuus on (vieläkin) tärkeää? 7 Kertausta algoritmiikasta ja aikavaativuudesta Vaikka nykyiset tietokoneet ovat tuhansia kertoja aiempia tehokkaampia, ovat toisaalta syötteet kasvaneet (uusia ongelmia, lisää tarkkuutta) ja ohjelmia kirjoitetaan yhä enemmän muille alustoille kuin perinteisille tietokoneille. Korkeamman tason ohjelmointikielet ja käyttöliittyvät vievät tehoa. Akkukäyttöisellä laitteella jokainen säästetty kellojakso merkitsee paitsi käyttömukavuutta, myös pidempää käyttöaikaa: Säädettävä suoritusteho (ja kääntäen sähkönkulutus)! Virransäästötilaan päästään nopeammin. Huipputehoa tarvitaan harvemmin. Yhteiskäyttöisillä tietokoneilla (palvelimilla) kaikki ajansäästö on lisäaikaa muille käyttäjille (palvelin voi palvella useampaa käyttäjää). O(n) tai O(nlogn) on usein huomattavasti parempi kuin O(n 2 ). O(logn) tai O(1) on usein huomattavasti parempi kuin O(n). O(nlogn) ja O(nloglogn) ovat useimmiten jokseenkin tasavertaisia. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 7(279)
1.1 Kertausta algoritmien ja tietorakenteiden käsitteistä 8 Kertausta algoritmiikasta ja aikavaativuudesta Algoritmi on toimintaohjeisto (käskyjono) joka ratkaisee annetun ongelman äärellisessä ajassa. Yleensä deterministisesti. Mieluiten tehokkaasti (kohtuullisessa ajassa, kohtuullisella laitteistolla. Mieluiten kohtuullisella ohjelmointityöllä. Tehokkuuden tasapainotus aikavaativuuden ja ohjelmointityön kesken on myös osattava! Tällä kurssilla opetellaan algoritmien suunnittelumenetelmiä, esimerkkialgoritmeja, kykyä lukea valmiita algoritmikuvauksia ja valmiiden algoritmien toteuttamista. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 8(279)
Kertausta algoritmiikasta ja aikavaativuudesta Annettu ongelma? Toivottavasti riittävän tarkasti määritelty. Tällä kurssilla keskitytään pienehköihin, erillisiin ongelmiin. Tärkeää olisi oppia näkemään reaalimaailman ongelmasta se/ne yksinkertainen algoritminen ongelma joka voidaan ratkaista tällä kurssilla annettavalla opilla. Esimerkki 1-1: Kokoelmaan lisätään (runsaasti) alkioita joilla on jokin lukuarvo. Alkiota lisättäessä pitäisi saada selville ko. alkion sijoitus lisäyshetkellä. Samoin pitäisi pystyä hakemaan nopeasti esimerkiksi sadas alkio. Minkälaista tietorakennetta kannattaa käyttää? 9 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 9(279)
10 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 10(279) Tietorakenne Toisiinsa kytkettyjä tietoja (muuttujia). Tällä kurssilla käsittelemme erityisesti alkioiden välisiä suhteita ja näiden suhteiden ominaisuuksia. Taulukko-lista-puu-verkko-joukko.
1.2 Suorituksen vaativuus 11 Kertausta algoritmiikasta ja aikavaativuudesta Miten suoritusaikaa (aikavaativuutta) mitataan? Absoluuttinen seinäkelloaika? Huono, sillä kaikki vaikuttaa: syöte käytetty laitteisto kuorma välimuistit roskienkeruu mittavälineetkin voivat olla epätarkkoja Huono, sillä vain jo toteutettua algoritmia voidaan tarkastella. Jotain abstraktimpaa kuin sekunti tms. siis tarvitaan. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 11(279)
Kertausta algoritmiikasta ja aikavaativuudesta Kellojakso (tai konekielioperaatio) on parempi, mutta edelleen em. asiat vaikuttavat. Edelleen vain jo toteutettua algoritmia voitaisiin tarkastella (järkevästi). Käytetään yksikköä "askel". a = 1; 1 b = 3; 2 for (i = 0; i < 1000; i++) 1 a = a + A[i]; 2 Kuva 1-1: Suoritusaskel. (n.) kaksi askelta (n.) 1000 askelta 12 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 12(279)
Kertausta algoritmiikasta ja aikavaativuudesta Suoritusaika suhteutetaan käsiteltävän syötteen kokoon. Siirräntään kuluvaa aikaa ei yleensä oteta huomioon. Syötteen oletetaan yleensä olevan valmiina saatavilla (viiteparametrina). Syötteen koko voi vaihdella eri suorituskerroilla. Lajittelu 1000 askeleessa (tai 0,1 sekunnissa). Hyvä vai huono? 10, 1.000, 1.000.000, 1.000.000.000 alkiota? Esitetään suoritusaika syötteen koon funktiona! for (i = 0; i < n; i++) 1 a = a + A[i]; 2 (n.) n askelta 13 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 13(279)
Kertausta algoritmiikasta ja aikavaativuudesta Esimerkki 1-2: Suoritusaikafunktio T(n)=cn 2 + b, missä b ja c ovat vakioita, ilmaisee suoritusajan olevan neliöllinen suhteessa syötteen kokoon. Tämä merkitsee, että syötteen koon kymmenkertaistuessa suoritusaika suurin piirtein satakertaistuu. Aikavaativuus on siis syötteen koon (elementtien määrä tms) funktio. Usein käytämme muuttujaa n kuvaamaan syötteen kokoa. Tämä on kuitenkin aina muistettava mainita aikavaativuutta ilmaistaessa. Joskus myös muita muuttujia tarvitaan, jos n on varattu toiseen tarkoitukseen. Erityisesti, jos kuvattavia syötteitä on useita erikokoisia. 14 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 14(279)
Kertausta algoritmiikasta ja aikavaativuudesta Esimerkki 1-3: Esimerkiksi merkkijonon etsinnän toisesta merkkijonosta vaativuus riippuu sekä etsittävästä avaimesta, että läpikäytävästä kohdetekstistä. Kuvataan avaimen pituutta m:llä ja kohdetekstin pituutta n:llä. Erään yksinkertaisen etsintäalgoritmin suoritusaikafunktio on T(n, m) = cnm, missä c on vakio. Kertaluokkana O(nm). Funktion T mittayksikköä ei kiinnitetä. Sanomme sitä askeleeksi. Todellinen yhden askeleen aikavaativuus riippuu mm. askeleessa suoritettavasta toimenpiteestä ja käytettävästä laitteistosta. 15 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 15(279)
Suoritusaika ei aina riipu pelkästään syötteen koosta, vaan myös syötteen laadusta. 16 Kertausta algoritmiikasta ja aikavaativuudesta Kun tämä otetaan huomioon, voidaan tarkastelu eriyttää seuraaviin kolmeen tapaukseen: 1) T(n) tarkoittaa pahimman tapauksen suoritusaikaa eli pisintä mahdollista n:n kokoisen syötteen aiheuttamaa suoritusaikaa. 2) T avg (n) tarkoittaa keskimääräistä suoritusaikaa eli kaikkien n:n kokoisten syötteiden aiheuttamien suoritusaikojen keskiarvoa. 3) T best (n) tarkoittaa parhaan tapauksen suoritusaikaa eli lyhintä mahdollista n:n kokoisen syötteen aiheuttamaa suoritusaikaa. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 16(279)
Yleensä tarkastellaan aina pahinta tapausta. 17 Kertausta algoritmiikasta ja aikavaativuudesta Paras tapaus ei yleensä ole edes mielenkiintoinen. Esimerkiksi lajittelussa usein paras tapaus on valmiiksi lajiteltu taulukko. Se taas ei juuri kerro lajittelualgoritmista mitään. Keskimääräisen suoritusajan arviointi saattaa puolestaan osoittautua erittäin hankalaksi tehtäväksi, koska kaikki samankokoiset syötteet voidaan vain harvoin olettaa keskenään yhtä todennäköisiksi. Erilaisia syötteitä on yleensä ekponentiaalinen määrä syötteen koon suhteen. Tällä kurssilla sivutaan hieman tasoitettua aikavaativuutta (katso Tasoitettu aikavaativuus sivulla 198). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 17(279)
Kertausta algoritmiikasta ja aikavaativuudesta Suoritusaikafunktioita voidaan vertailla keskenään funktioiden kasvunopeuksia vertailemalla. Vakiokertoimet eivät ole mielenkiintoisia, kone, kääntäjä,... vaikuttaa. Tarkastellaan sensijaan funktioista vain kertaluokkia: Määritelmä 1-4: Kertaluokkamerkinnät O, Ω, Θ ja o 1) T(n) =O(f(n)), jos on olemassa positiiviset vakiot c ja n 0 siten, että T(n) cf(n), kun n n 0. [Lue: T(n) on kertaluokkaa f(n), iso-o, ordo; "rajoittaa ylhäältä"] 2) T(n) =Ω(g(n)), jos on olemassa positiiviset vakiot c ja n 0 siten, että T(n) cg(n), kun n n 0. [omega; "rajoittaa alhaalta"] 3) T(n) =Θ(h(n)), jos T(n)=O(h(n)) ja T(n)=Ω(h(n)). [theta; "rajoittaa ylhäältä ja alhaalta"] 4) T(n) =o(p(n)), jos T(n) =O(p(n)) ja T(n) Θ(p(n)). [pikku-o; "rajoittaa aidosti ylhäältä"] Siis: kunhan valitaan sopiva vakiokerroin c ja annetaan syötteen kasvaa riittävästi, niin sanottu rajoittaminen pätee. 18 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 18(279)
Joskus määritellään myös 5) T(n) =ω(p(n)), jos T(n)=Ω(p(n)) ja T(n) Θ(p(n)). [pikku-omega; "rajoittaa aidosti alhaalta"] 19 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 19(279)
Kertausta algoritmiikasta ja aikavaativuudesta Esimerkki 1-5: Olkoon T(n) =5n+2. Silloin T(n) =O(n), mikä nähdään vaikkapa päättelyllä 5n+2 5n+2n = 7n (kun n 1). Eli c = 7 ja n 0 =1. Ylärajan n rinnalle kelpaisivat myös ylärajat n 2, n 3 ja niin edelleen. Samoin T(n)=Ω(n), mikä nähdään esimerkiksi päättelyllä 5n+2 5n (c =5jan 0 = 1). Näinollen funktio n myös alaraja ja itse asiassa T(n)=Θ(n). Esimerkki 1-6: Näytetään, ettei funktio T(n) =5n+2 ole kertaluokkaa n: Jos olisi T(n) = O( n), niin määritelmän 1-4 nojalla olisi olemassa positiiviset vakiot c ja n 0 siten, että 5n+2 c n, kun n n 0. Tällöin olisi myös 5n c n. Tämä epäyhtälö voidaan järjestellä uudelleen: 5n c n 5 n c n ( c 5) 2. Koska c on vakio, on myös (c/5) 2 vakio. Tämä merkitsee, ettei epäyhtälö 5n+2 c n toteudu ainakaan silloin, kun n > max{n 0,(c/5) 2 }, mikä on vastoin oletusta. Törmäsimme ristiriitaan, eli väite on väärä. 20 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 20(279)
Kertausta algoritmiikasta ja aikavaativuudesta Aikavaativuuksien luokittelu: Eksponentiaaliset aikavaativuudet esim 2 n, 3 n, 2 n /n, n! Käyttökelpoisia vain hyvin pienille syötteille Polynomiset aikavaativuudet n, n 2, n 5, n 12345, n n, nlogn Käytännössä yleisimpiä tehokkaita.. kohtuullisen tehokkaita n lineaarinen n 2 neliöllinen n alilineaarinen (mutta polynominen) Logaritmiset aikavaativuudet logn, loglogn, jne huom: logn on tällä kurssilla log 2 n kaikki o(n) on alilineaarista aikavaativuutta ei kokonaisissa peräkkäisalgoritmeissa Vakioaikainen: O(1) 21 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 21(279)
Suoritusajan laskeminen 22 Kertausta algoritmiikasta ja aikavaativuudesta Annetun algoritmin suoritusajan laskenta voi olla hyvin helppoa tai hyvin vaikeaa. Yleensä riittää osata jossain määrin: sarjojen summien sieventäminen kertaluokkalaskenta auttaa huomattavasti, ei tarvita tarkkoja tuloksia logaritmi- ja eksponenttilaskentaa rekursioyhtälöitä Funktioiden vertailuun riittävät peruslaskutoimitukset (+ / ) ja pari muuta: kaikille vakioille k > 0, b > 0 pätee log k n = o(n b ) (merkintä log k n tarkoittaa (logn) k ) kaikille vakioille a > 1, b > 0 pätee n b = o(a n ) Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 22(279)
Kertausta algoritmiikasta ja aikavaativuudesta Kertaluokkalaskennan perussäännöt Olkoon ohjelmanosan P 1 suoritusaika T 1 (n) = O(f(n)) Olkoon ohjelmanosan P 2 suoritusaika T 2 (n) = O(g(n)) Summasääntö T 1 (n) + T 2 (n) = O(max{f(n), g(n)}) Tulkinta: peräkkäisten suoritusten aikavaativuuden kertaluokan määrää osasuorituksista hitaampi. Summasäännön ansiosta voidaan kertaluokkatarkastelussa jättää vähempimerkityksiset termit kokonaan huomiotta. 23 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 23(279)
Kertausta algoritmiikasta ja aikavaativuudesta Tulosääntö T 1 (n) T 2 (n) = O(f(n) g(n)) Seuraus: jos T(n) = a f(n), (a on nollaa suurempi vakio), niin T(n)=O(f(n)). Siis: kertaluokkatarkastelussa voidaan positiiviset vakiokertoimet jättää huomiotta. Esimerkki 1-7: Jos T(n)=3n 2 +5n+8, = O(max(3n 2, 5n, 8)) (summasääntö) = O(3n 2 ) (tulosääntö) = O(n 2 ). 24 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 24(279)
Kertausta algoritmiikasta ja aikavaativuudesta Aikavaativuuden laskeminen algoritmista Sijoitus-, luku- ja tulostustoiminnot ovat yleensä O(1). poikkeus: suurten rakenteiden käsittely huomaa parametrien tyyppi taulukko arvoparametrina: kopiointi O(n) taulukko viite/muuttujaparametrina: viite O(1) Javassa oliot välitetään viitteinä (paitsi muuttamattomat perusluokat, kuten Integer ja String) Lausekkeen arvottaminen O(1) Paitsi tietysti, jos esimerkiksi kutsutaan aliohjelmaa! Taulukkoviittaukset O(1) Toimintojono (= peräkkäiset käskyt) Summasäännöllä Ehdolliset toiminnot T(ehdon arvottaminen) + T(valittava osa) [yleensä pahin tapaus] 25 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 25(279)
Kertausta algoritmiikasta ja aikavaativuudesta Toisto Tulosäännöllä ( i:s toistokerta) i Usein riittää laskea toistojen lkm T(toistettava osa) [pahin tapaus] Jos pahin tapaus on harvinainen, tilanne on analysoitava tarkemmin (laskettava pahat ja hyvät tapaukset erikseen). for (i = 0; i < n; i++) 1 if (i == n 1) 2 for (j = 0; j < n; j++) // tämä suoritetaan vain kerran, O(n) 3 a = a + 1; 4 else 5 x = x + 1; // tämä vakioaikainen suoritetaan useasti 6 26 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 26(279)
27 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 27(279) Mitään oleellista ei saa jättää huomiotta. while (! etsi_väritys(k)) 1 k = k + 1; 2 aliohjelmakutsut T(parametrien välitys) + T(aliohjelman suoritus) aliohjelma erillisenä lohkona rekursiiviset rekursioyhtälöllä
1.3 Rekursiivisten algoritmien aikavaativuus 28 Kertausta algoritmiikasta ja aikavaativuudesta Aliohjelmakutsun aikavaativuus: lasketaan erikseen. T(parametrien välitys) + T(aliohjelman suoritus) aliohjelma erillisenä lohkona Esimerkki 1-8: Kertoma voidaan laskea seuraavalla rekursiivisella algoritmilla: public static int factorial(int n) { 1 if (n <= 1) 2 return 1; 3 else 4 return i * factorial(n 1); 5 } 6 Rivien 1-4 suoritusaika on selvästi O(1) Rivillä 5 kertolasku ja sijoitus ovat O(1), mutta Funktiokutsun arvottaminen vie aikaa! Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 28(279)
Merkitköön T(n) koko algoritmin suoritusaikaa syötteellä n 29 Kertausta algoritmiikasta ja aikavaativuudesta T(n)=d, kun n 1 (c, d vakioita) (1-1) T(n)=c+T(n 1), kun n >1. Puretaan äskeistä rekursiokaavaa: T(n)=c+T(n 1) (1-2) T(n 1) = c+t(n 2), ja T(n 2) = c+t(n 3), joten T(n 1) = c+ (c+t(n 3)) = 2c+T(n 3), joten T(n)=c+T(n 1) = c+(2c+t(n 3)) = 3c+T(n 3) Jatkamalla tähän tapaan huomaamme, että T(n)=ic+T(n i), kun i < n (1-3) Asetetaan i = n 1 (mennään rekursiossa pohjalle): T(n)=c(n 1) + T(1) = c(n 1) + d (1-4) T(n) = O(n). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 29(279)
Kertausta algoritmiikasta ja aikavaativuudesta Rekursiokaavojen mahdollisuuksia Rekursiivisia kutsuja voi olla esim. 1, 2,..., logn, n,..., n/2, n kpl. Rekursion syötekoko voi olla esim. n 1, n 2, n/2, logn, n. Rekursion lisäksi työtä voidaan tehdä esim. O(1), O(logn), O( n), O(n), O(n 2 ). Rekursioyhtälö on siis esim. muotoa T(n)=cT(n/d) + O(n a ) tai (1-5) T(n)= n T( n) + O( n). Useimmissa (arkipäiväisissä) tapauksissa yllä käyttämämme purkaminen ja kokoaminen toimii riittävän hyvin. 30 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 30(279)
Kertausta algoritmiikasta ja aikavaativuudesta Master theorem Muotoa T(n) = at(n/b) + f(n) (1-6) oleviin rekursioyhtälöihin löytyy valmis ratkaisu helpohkolla säännöstöllä (ns. Master theorem), mutta sitä ei käsitellä tällä kurssilla. Säännöstö löytyy mm. Cormen&al kirjasta ja mahdollisesti esitellään Algoritmien suunnittelu ja analysointi -kurssilla. 31 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 31(279)
Esimerkki 1-9: Lomituslajittelun aikavaativuus: 32 Kertausta algoritmiikasta ja aikavaativuudesta Pätee myös monille muille hajoita-ja-hallitse -algoritmeille. T(n) = 2T(n/2) + d, missä d = O(n) (1-7) T(n/2) = 2T(n/4) + d/2 T(n/4) = 2T(n/8) + d/4 T(n/8) = 2T(n/16) + d/8 T(n/4) = 2T(n/8) + d/4 = 2 ( 2T(n/16) + d/8 ) + d/4 = 4T(n/16) + d/4 + d/4 = 4T(n/16) + d/2 T(n/2) = 2T(n/4) + d/2 = 2 ( 4T(n/16) + d/2 ) + d/2 = 8T(n/16) + d + d/2 = 8T(n/16) + 3d/2 T(n) = 2T(n/2) + d = 2 ( 8T(n/16) + 3d/2 ) + d = 16T(n/16) + 3d + d/2 = 16T(n/16) + 4d Rekursioyhtälön tulosta ei ole enää yhtä helppo nähdä, mutta ylläolevasta voidaan päätellä vaiheita olevan logaritminen määrä, ja kullakin tasolla tehtävän lineaarinen määrä työtä, eli yhteensä O(nlogn). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 32(279)
Esimerkki 1-10: Fibonaccin lukujen laskenta määritelmän mukaan 33 Kertausta algoritmiikasta ja aikavaativuudesta public int fib(int n) { // Tehoton ratkaisu!!! 1 if (n < 2) 2 return 1; 3 else 4 return fib(n 1) + fib(n 2); 5 } 6 Rekursiokutsuja on kaksi, muuta työtä on vain vakioaika. Rekursioyhtälö T(n) = T(n 1) + T(n 2) + c, missä c on vakio. Rekursioyhtälöä purettaessa hieman enemmän, nähdään kutsujen määrän noudattavan Fibonaccin lukuja, mutta käsityötä olisi hieman enemmän, eikä tulos olisi niin ilmeinen. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 33(279)
Yläraja sensijaan on helppo arvioida yksinkertaistamalla kaavaa: 34 Kertausta algoritmiikasta ja aikavaativuudesta T(n 2) T(n 1) (miksi?) T(n) 2T(n 1) + c = 2(2T(n 2) + c) + c = 2(2(2T(n 3) + c) + c) + c = 2 i T(n i) + c(2 i 1) = O(2 n ). (1-8) Mutta onko tämä yläraja-arviointi liian väljä? Arviointi kertautuu joka kierroksella! Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 34(279)
Kertausta algoritmiikasta ja aikavaativuudesta Vastaavasti voidaan todistaa alaraja arvioimalla termiä T(n 2) alaspäin 1 verrattuna -- T(n 1):een: 2 1 T(n 2) -- T(n 1) ("arvaus") (1-9) 2 1 T(n 3) + T(n 4) + c -- (T(n 2) + T(n 3) + c) 2 1 1 1 -- T(n 3) + T(n 4) + -- c -- T(n 2) 2 2 2 1 1 1 -- T(n 3) + T(n 4) + -- c -- (T(n 3) + T(n 4) + c) 2 2 2 1 1 -- T(n 4) -- c 2 2 T(n 4) c, mikä varmasti pitää paikkansa kunhan n kasvaa riittävän suureksi. 35 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 35(279)
Kertausta algoritmiikasta ja aikavaativuudesta 1 Näin ollen alarajatarkastelussa T(n 2) voidaan korvata -- T(n 1):lla: 2 3 3 T(n) -- T(n 1) + c = -- ( 3 T(n 2) + c) + c (1-10) 2 2 2 -- 3 = -- ( 3 ( T(n 3) + c) + c) + c = T(n i) + c( 1) 2 2 -- 3 2 -- 3 -- 2 i 3 -- 2 i 3 = Ω( -- ). 2 n 3 Aikavaativuus on siis Ω( -- )jao(2 n ), joka tapauksessa eksponentiaalinen. 2 n Arvatenkin tarkka kantaluku on kultaisen leikkauksen suhdeluku ϕ 1.618 36 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 36(279)
Kertausta algoritmiikasta ja aikavaativuudesta Rekursiopuu Jos/kun ylläesitetty rekursioyhtälön purkaminen tuntuu hankalalta, (tätäkin) asiaa voidaan havainnollistaa piirtämällä. Rekursiopuuhun piirretään kullekin tasolle solmu kutakin rekursiokutsua kohti ja solmuun siinä käytetty työ. Kullakin tasolla lasketaan solmujen työt yhteen. Koko työ on kaikkien tasojen töiden summa. Piirtoteknisesti solmuja joudutaan yhdistelemään ja käyttämään " " merkintöjä, mutta työ kuitenkin voidaan puusta summata. Kuvan 1-2 puu lomituslajittelusta havainnollistaa rekursiota yksinkertaisessa tapauksessa. Kuvan 1-3 Fibonaccin funktiolle kuva ei anna aivan yhtä tarkkaa tulosta, mutta näyttää selkeästi aikavaativuuden ekponentiaalisuuden. 37 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 37(279)
38 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 38(279) Työ 1 n T(n): n 2 n/2 T(n/2): n/2 T(n/2): n/2 logn 4 n/4 T(n/4): n/4 T(n/4): n/4 T(n/4): n/4 T(n/4): n/4 n 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Yhteensä Θ(nlogn) Kuva 1-2: Rekursiopuu yhtälölle T(n) = 2T(n/2) + n.
39 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 39(279) T(n) n T(n 1) T(n 2) T(n 2) T(n 3): T(n 3): T(n 4) 1 1 1 1 Kuva 1-3: Rekursiopuu Fibonaccin funktiolle T(n)=T(n 1)+T(n 2)+c. 1 1 1 1 n/2
Sanapituuden vaikutus 40 Kertausta algoritmiikasta ja aikavaativuudesta Perusoperaatiot k bittisille luvuille ovat (liki) vakioaikaisia vain jos prosessorimme suorittaa ne rinnakkain k loogisella piirillä. Yleensä prosessorit tukevat sanapituutta 32 tai 64. Mikrokontrollerit yleensä hieman vähemmän. Esimerkki 1-11: Potenssiin korotus suurilla luvuilla: x n Suoraviivainen algoritmi: BigInteger pow(biginteger x, int n) { 1 BigInteger r = new BigInteger("1"); 2 for (int i = 0; i < n; i++) 3 r = r.multiply(x); 4 return r; 5 } 6 Aikavaativuus O(n), vai onko??? Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 40(279)
Kertausta algoritmiikasta ja aikavaativuudesta Mikä on BigInteger.multiply():n aikavaativuus??? JavaAPI:n dokumentaatio ei (tässäkään) anna mitään vihjettä! Lähdekoodista nähdään kyseessä olevan koulualgoritmi ("kertolasku alekkain"). Koulualgoritmilla kerrottavat luvut a ja b, lukujen pituudet loga, logb bittiä, yhden kertolaskun aikavaativuus on O(loga logb). pow -funktiossa r:n pituus on (lopussa ja keskimäärin) O(nlogx) bittiä, x:n pituus on logx bittiä. Koko aikavaativuus on siten n O(nlogx) O(logx) = O(n 2 log 2 x), eli O(n 2 ) jos x on pieni vakio. 41 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 41(279)
Kertausta algoritmiikasta ja aikavaativuudesta Rekursiivinen hajoita-ja-hallitse -algoritmi: (*) x n = ( xx) n 2 jos n on parillinen x n = xxx ( ) n 2 jos n on pariton BigInteger pow2(biginteger x, int n) { 1 if (n == 0) 2 return new BigInteger("1"); 3 if (n == 1) 4 return x; 5 if (n%2 == 0) // n parillinen 6 return (pow2(x.multiply(x), n/2 ) ); // ( xx) n 2 7 else 8 return (x.multiply(pow2(x.multiply(x), n/2 ))); // xxx ( ) n 2 9 } 10 T(n) = T(n/2) + 2T m (pahin tapaus kun n = 2 k 1) T(n) = T(n/2) + T m (paras tapaus kun n = 2 k ). 42 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 42(279)
Kertausta algoritmiikasta ja aikavaativuudesta Mikä on kertolaskun aikavaativuus T m nyt? Logaritminen määrä rekursiotasoja, jokaisella yksi rekursiokutsu, 1-2 multiply() kutsua. Jos kertolasku olisi O(1), aikavaativuus olisi O(logn), jos kertolasku olisi O(n) koko aikavaativuus olisi mukava O(nlogn)??? Kirjoitetaan kukin osa (rekursiokutsu, molemmat kertolaskut) tarkemmin: T(n, x) = T(n/2, x 2 ) + logx n logx + logx logx (1-11) = T(n/2, x 2 ) + logx (nlogx + logx) = T(n/2, x 2 ) + (n + 1)log 2 x Kun rekursiossa edetään, x kasvaa ja n pienenee. Tasolla i on x i = n n i = ---. 2 i Näin ollen koko aikavaativuus on logn T(n, x) = log x 2i 2 n --- + 1. (1-12) i = 0 2 i x 2i ja 43 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 43(279)
Kun summan termeistä viimeinen on suurempi kuin muut yhteensä, tarkastelemme vain sitä: 44 Kertausta algoritmiikasta ja aikavaativuudesta T(n, x) 2 x 2 logn log 2 n ------------ + 1 logn 2 (1-13) = 2( log x n ) 2 n -- + 1 = 2( nlog x) 2 n -- + 1 (1-14) n n = O(n 2 log 2 x) Jos/kun kantaluku x on pienehkö vakio, on aikavaativuus tuttu O(n 2 ). Käytännössä kertolaskuja tulee hieman vähemmän kuin edellisessä suoraviivaisessa algoritmissa, pahin tapaus ei aina toteudu, ja kaavan 1-12 summa ei mene aivan logn:ään asti. Toteutuksesta mitattuna rekursiivinen algoritmi on pienellä kantaluvulla 70-200 kertaa nopeampi, riippuen potenssista ja alustasta. Suurilla kantaluvuilla ero hieman pienenee. Myös Java API (1.6) käyttää tätä algoritmia. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 44(279)
1.4 Aikavaativuuden rajojen todistaminen 45 Kertausta algoritmiikasta ja aikavaativuudesta Hankalassa tapauksessa voi olla helpompaa todeta (todistaa) algorimin tai ongelman aikavaativuudelle erilliset ala- ja ylärajat. Esim. yllä Fibonaccin funktio. Paitsi algoritmeja, voimme analysoida myös ongelmia. Mikä on alaraja annetun ongelman ratkaisemiseen algoritmisesti? Deterministisesti, yleisessä tapauksessa. Päätöspuut Osoitetaan esimerkkinä, ettei vertailuun perustuva lajittelu voi olla nopeampi kuin Ω(nlogn). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 45(279)
Kertausta algoritmiikasta ja aikavaativuudesta Päätöspuu on binääripuu joka kuvaa ratkaisun etsimistä. Juuressa on alkutilanne, ts. kaikki ratkaisut ovat mahdollisia. Kussakin solmussa tehdään yksi vertailu (tai muu operaatio) ja sen mukaan päätös edetä jompaan kumpaan alipuuhun. Alipuun haaroihin on mahdolliset ratkaisut on jaettu kahteen osaan, ts. kullakin päätöksellä mahdollisten ratkaisujen joukko vähenee. Lehtisolmuissa on jäljellä vain yksi ratkaisu. Solmun syvyys kuvaa ko. ratkaisuun päätymiseen vaadittujen vertailujen määrää. Puun korkeus = pahin tapaus. Puun matalin lehtisolmu = paras tapaus. Vertailut ja päätökset riippuvat käytetystä algoritmista. Päätöspuu kuvaa algoritmin toiminnan kaikki mahdolliset haarat. Yksi suoritus on yksi polku juuresta lehtisolmuun. 46 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 46(279)
Kertausta algoritmiikasta ja aikavaativuudesta < < < < < < < < < kyllä < < < < < kyllä ei ei < < kyllä < < < < < < < < < < < < < < < < < Kuva 1-4: Upotuslajittelun päätöspuu, n =3,n! =6. Esimerkki 1-12: Kuva 1-4 esittää upotuslajittelun päätöspuun syötteen koolla n = 3. Alussa kaikki kuusi vaihtoehtoa ovat mahdollisia. Ensimmäisen vertailun < jälkeen vaihtoehdot jakautuvat kahtia. Jos vertai- ei < < < < < kyllä < < < < < < < kyllä ei ei < < < < 47 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 47(279)
Kertausta algoritmiikasta ja aikavaativuudesta lun tulos oli tosi, jäljelle jäävät vain ne vaihtoehdot, joissa edelsi :tä. Epätoden puolelle jäivät loput. Päätöspuun korkeus yleisen lajittelun tapauksessa: Erilaisia mahdollisia järjestyksiä n! kappaletta Lehtisolmuja päätöspuussa siten (vähintään) n! kpl! Olipa algoritmi mikä tahansa. Haarautumissolmuja (vähintään) n! 1 kpl Solmuja yhteensä (vähintään) 2n! 1 kpl Puun korkeus Ω(log(2n! 1)) = Ω(log(n!)). Käytetään yksinkertaistettua versiota Stirlingin kaavasta: n! (n/e) n (1-15) log(n!) log((n/e) n )=nlogn nloge (1-16) log(n!) = O(nlogn) 48 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 48(279)
Kertoman logaritmia voidaan arvioida myös alaspäin: 49 Kertausta algoritmiikasta ja aikavaativuudesta log(n!) (n/2)log(n/2) = (n/2)logn (n/2) (1-17) log(n!) = Ω(nlogn) Optimaalisessa päätöspuussa jokaisen päätöspolun pituus on toisin sanoen Θ(nlogn). Tätä tehokkaampaa vertailuihin perustuvaa lajittelualgorimia ei voi olla olemassa. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 49(279)
1.5 Kokeellinen aikavaativuuden määrääminen 50 Kertausta algoritmiikasta ja aikavaativuudesta Joskus analyysin keinot eivät ole mahdollisia/järkeviä/riittävän tarkkoja! Emme osaa analysoida. Emme tiedä tarpeeksi syötteen rakenteesta (tai sen vaikutuksesta). Lähdekoodi (tai sen osa) ei ole käytettävissä (tai ymmärrettävissä). Tarvitsemme tarkempia tuloksia myös vakiokertoimista. Tavoitteet Selvittää aikavaativuuden kertaluokka. Selvittää (likimääräinen) aikavaativuusfunktio prosessoriajalle (sekunneteina tms.) käytettävälle alustalle. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 50(279)
Kertausta algoritmiikasta ja aikavaativuudesta Miten Pienehkö ohjelmanosa kerrallaan. Usealla eri syötteen koolla. Vakioitu tai satunnainen syöte, riippuen algoritmista. Usean ajon keskiarvo (jos satunnainen syöte) tai minimi (jos vakiosyöte). Kasvata syötteen kokoa aluksi eksponentiaalisesti (esim 2 tai 10). Kun aika alkaa kasvaa, käytä tarkempia askeleita, erityisesti jos aikavaativuus on suuri (eksponentiaalinen). Kasvata ainakin useisiin sekunteihin (pari kertaluokkaa mittaustarkkuutta suuremmaksi). Jos algoritmi on liian nopea mitattavaksi tarkasti kohtuullisen kokoisilla syötteillä, toista algoritmia useasti. 51 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 51(279)
Kertausta algoritmiikasta ja aikavaativuudesta Tarkkaile peräkkäisten syötekokojen ajan suhdetta, esim jos syöte aina kaksinkertaistetaan: jos aika kaksinkertaistuu: lineaarinen jos aika hieman yli kaksinkertaistuu: esim. O(nlogn) (voi olla vaikea erottaa lineaarisesta, vaatii pidemmän jänteen). jos aika nelinkertaistuu: neliöllinen jos aika 8-kertaistuu: kuutiollinen Jos syötteen kasvattaminen yhdellä kasvattaa aikavaativuuden kaksinkertaiseksi: eksponentiaalinen. Tulosten esittäminen käyränä ja vertailufunktioiden piirtäminen auttaa näkemään oleelliset muutokset (kts. alla). Logaritminen asteikko on yleensä parempi. Joissakin mittaustuloksissa esiintyy heittoja, lähinnä välimuistien ja roskienkeruun takia. Kun syöte kasvaa yli välimuistista, aikavaativuus alkiota kohti usein kaksin- kolminkertaistuu (katso Taulukon käsittely peräkkäin/hajasaantina: sivulla 232). 52 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 52(279)
Ajan mittaaminen 53 Kertausta algoritmiikasta ja aikavaativuudesta Miten erottaa algoritmin käyttämä aika muiden ohjelmien, käyttöjärjestelmän, roskienkeruun, jne käyttämästä ajasta? Valitettavasti JavaAPI ei suoraan mahdollista prosessin/säikeen ajankäytön mittaamista. C:ssä clock() palauttaa prosessin käyttämän ajan mikrosekunteina. Java-ohjelmaan on mahdollista sisällyttää kutsuja erillisiin mittaohjelmiin, mutta se ei ole siirrettävä tekniikka (verkosta löytyy valmiita HOWTO -ohjeita). Helpommalla pääsee kun käyttää reaaliaikakelloa java.util.date -luokan avulla ja pyrkii minimoimaan siitä aiheutuvat virheet. Date palauttaa ajan millisekunteina. Minimoi muut prosessit. Älä tulosta mittauksen aikana. Aja useaan kertaan samalla syötteellä, ota ajoista minimi. Käytä riittävän suuria syötteitä tai saman operaation toistamista useasti (suoritusaika vähintään 0,1s). Esim. Ajastin.java kurssin www-sivulla. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 53(279)
Esimerkki 1-13: String vrt. StringBuffer (StringTest.java) 54 Kertausta algoritmiikasta ja aikavaativuudesta Toteutetaan Vector<Integer>.toString() eri tavoin. java.util.vector<integer>.tostring() (valmis toteutus: AbstractCollection) String: s = s + v.get(i).tostring() + ", "; StringBuffer: sb.append(v.get(i).tostring() + ", ") StringBuilder: sb.append(v.get(i).tostring() + ", ") StringBuilder2: sb.append(v.get(i).tostring); sb.append(", "); StringBuilder3: new StringBuilder(n*12). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 54(279)
55 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 55(279) 1M 32768 1024 32 1 1M/s n^2 Vector.tStr SBuffer SBuilder SBuilder2 SBuilder3 String + T(ms) 256 1024 4096 16384 65536 262144 1M Kuva 1-6: Merkkijonon kokoamisen aikavaativuus, logaritminen x ja y. n
56 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 56(279) 30000 25000 20000 15000 10000 5000 0 1M/s n^2 Vector.tStr SBuffer SBuilder SBuilder2 SBuilder3 String + 256 1024 4096 16384 65536 262144 1M n Kuva 1-7: Merkkijonon kokoamisen aikavaativuus, lineaarinen y. T(ms)
Taulukko 1-5: Merkkijonon kokoamisen aikavaativuus (ms) 57 Kertausta algoritmiikasta ja aikavaativuudesta n Vector. tostring String Buffer String Builder String Builder2 String Builder3 String + 50 0 0 0 0 0 1 100 0 0 0 0 0 2 200 0 0 0 0 0 3 400 0 0 0 0 0 11 800 0 0 0 0 0 49 1600 1 2 1 0 1 207 3200 3 4 3 2 1 1039 6400 6 8 8 9 5 8026 12800 15 44 20 41 12 90140 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 57(279)
Taulukko 1-5: Merkkijonon kokoamisen aikavaativuus (ms) 58 Kertausta algoritmiikasta ja aikavaativuudesta n Vector. tostring String Buffer String Builder String Builder2 25000 83 95 94 80 45 50000 152 172 169 146 96 100000 233 262 259 215 144 200000 393 439 442 355 234 400000 699 798 786 650 420 800000 1318 1520 1494 1232 809 1600000 1909 2307 2328 1964 1359 3200000 3851 5207 5543 4022 2732 String Builder3 String + Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 58(279)
1.6 Abstraktit tietotyypit (*) 59 Kertausta algoritmiikasta ja aikavaativuudesta Abstraktit tietotyypit (ATT, ADT (abstract data type)) (joskus abstrakti tietorakenne) ovat malleja tiedon esittämiseksi ja käsittelemiseksi. Abstrakti tietotyyppi määritellään kuvaamalla operaatiot (funktiot, proseduurit, metodit) joilla tietotyypin esittämää tietoa käsitellään. Operaatiot (yms) = abstraktin tietotyypin liittymä. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 59(279)
Kertausta algoritmiikasta ja aikavaativuudesta Vaihtoehtoinen havainnollistus ADT on kokoelmien hallinnan apuväline. Ripustetaan elementit ADT:n hallittavaksi. ADT Hyötytieto Looginen järjestys Kuva 1-8: ADT kokoelman ylläpidon apuvälineenä. Keskitytään itse elementteihin ja niiden keskinäisiin suhteisiin! ADT:n valinta määrää talletettujen elementtien loogisen järjestyksen (jos sellaista tarvitaan). Joskus vain osa elementeistä on "näkyvissä" (kun emme muita tarvitse). 60 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 60(279)
Kertausta algoritmiikasta ja aikavaativuudesta Esimerkki 1-14: Joukko (abstraktina tietotyyppinä) on kokoelma keskenään samantyyppisiä alkioita, vaikkapa verkon solmuja. Joukkomallille tyypillinen piirre on se, että sama alkio voi sisältyä joukkoon vain yhtenä esiintymänä kerrallaan. Joukkoja käsitellään esimerkiksi muodostamalla kahden joukon yhdiste tai tutkimalla, kuuluuko jokin alkio joukkoon. Joukkotyypin liittymä voi sisältää vaikkapa seuraavankaltaisen osan: // returns union of this set and set B 1 public Set<E> union(set<e> B); 2 // returns whether object x is a member of this set or not 3 public boolean member(<e> x); 4 61 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 61(279)
Kertausta algoritmiikasta ja aikavaativuudesta Liittymä antaa ADT:n käyttäjälle kaiken tarpeellisen tiedon tyypin käyttämiseksi: tyypit sallitut operaatiot (metodit) operaatioiden parametrit operaatioiden tuloksen tyypin operaatioiden käyttöä rajoittavat ehdot ADT toteutetaan siten, että liittymässä kuvatut operaatiot toimivat kuvatulla tavalla! Toteutus sisältää operaatioiden ohjelmakoodin ja mallia vastaavan todellisen toteutustietorakenteen määrittelyn. Toteuttamisen helpottamiseksi toteuttaja voi laatia lisää operaatioita omaan käyttöönsä. Nämä operaatiot eivät näy käyttäjälle (kuten ei mikään muukaan toteutukseen liittyvä asia). 62 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 62(279)
Määritelmä 1-15: Muuttujan tietotyyppi on kyseisen muuttujan sallittujen arvojen joukko. 63 Kertausta algoritmiikasta ja aikavaativuudesta Määritelmä 1-16: Tietorakenne on kokoelma toisiinsa kytkettyjä muuttujia. Kyseessä on siis ohjelmointikielen rakenne josta bitit voidaan periaatteessa piirtää näkyviin. Joskin Javan tapauksessa bittien täsmällinen piirtäminen vaatisi hieman enemmän paneutumista Javan toteutukseen. Pelkkä kielen dokumentaatio ei riitä. taulukko objektit viittein kytketyt objektit tiedosto Tietorakenne: ohjelmointikielen rakenne (bitit piirrettävissä). Abstrakti tietotyyppi: kokoelma-abstraktio (toteutus tuntematon). Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 63(279)
1.7 Kertaus abstrakteihin tietotyyppeihin (*) 64 Kertausta algoritmiikasta ja aikavaativuudesta Aloitetaan yksinkertaisesta, yleiskäyttöisestä kokoelmasta, listasta. Listalla on runsaasti variaatioita. Abstraktin tietotyypin tarkoitus on hallita alkiokokoelmaa niin, että kokoelmaa voidaan käyttää käyttäjälle tarkoituksenmukaisella tavalla tehokkaasti Alkiokokoelmien hallinta ja käyttö edellyttää mahdollisuutta. lisätä kokoelmaan uusi alkio hakea alkioita kokoelmasta poistaa alkioita kokoelmasta muuttaa kokoelman alkioita käydä läpi kokoelman alkioita Aina ei tosin tarvita näitä kaikkia mahdollisuuksia. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 64(279)
Mitä kokoelmaan (esim. listaan) talletetaan? 65 Kertausta algoritmiikasta ja aikavaativuudesta Tarkoitus on lisäksi pystyä samalla ADT:llä hallitsemaan erilaisia alkiokokoelmia. Abstraktin tietotyypin tulee olla mahdollisimman riippumaton hallittavien alkioiden tyypistä. Parametroidaan abstrakti tietotyyppi alkioiden tyypillä! Esimerkki 1-17: Listatyypin liittymä alkaa tekstillä: public class List<E> { 1 Tässä E kuvaa alkioiden tyyppiä, jota liittymä ei siis kiinnitä. Muodollinen tyyppiparametri (formal type parameter), kuten muodollinen parametri aliohjelmissa. Listoja luotaessa parametrityyppi sitten kiinnitetään: List<Integer> lukulista = new List<Integer>(); 1 List<List<Integer>> listalista = new List<List<Integer>>(); 2 List<Henkilo> hlolista new List<Henkilo>(); 3 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 65(279)
Tehtäessä geneerisiä algoritmeja kokoelmille, voimme rajoittaa tarvittaessa mahdollisten alkioiden tyyppiä: 66 Kertausta algoritmiikasta ja aikavaativuudesta Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 66(279) public boolean vertailuatms(list<? extends Comparable>) 1
1.8 Lista (*) 67 Kertausta algoritmiikasta ja aikavaativuudesta Lista abstraktina tietotyyppinä Esimerkki 1-18: Lista voidaan esittää vaikkapa luettelemalla listaan sisältyvät alkiot peräkkäin. Viisialkioinen lista L kuvataan esimerkiksi seuraavalla tavalla: L = a 1, a 2, a 3, a 4, a 5. (1-18) Tyhjä lista esitetään tällöin muodossa L =. (1-19) Listan esitysmuoto valitaan aina tilanteen mukaisesti. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 67(279)
Kertausta algoritmiikasta ja aikavaativuudesta Alkioiden peräkkäisyyssuhde. Alkioiden välillä vallitsee yksikäsitteinen edeltäjä-seuraaja -suhde. alkio a 2 edeltää alkiota a 3 alkio a 3 seuraa alkiota a 2 Listan ensimmäisellä alkiolla ei ole edeltäjää. Listan viimeisellä alkiolla ei ole seuraajaa. Käsitellessämme listassa olevia alkioita, meidän on pystyttävä yksilöimään kukin alkio, ja sen sijainti listassa. Asema (listasolmu) Listan i:nnen alkion etäisyys listan alusta on i 1. Jos käytetään tavallista ohjelmointikielen taulukkoa, niin sekä etäisyys alusta, että kunkin alkion sijainti ovat yksikäsitteisiä. Mutta: listaan on voitava mm. lisätä keskelle alkioita, jolloin uuden alkion seuraajien etäisyys alusta muuttuu! Tarvitaan hieman abstraktimpi sijainnin käsite! 68 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 68(279)
Kertausta algoritmiikasta ja aikavaativuudesta Kullakin listan alkiolla on oma asemansa (position) listassa. Listan ensimmäiseen käytössä olevaan aseman ja listan viimeisen käytössä olevan aseman jälkeiseen asemaan pystytään viittaamaan. Aseman tyyppi ja käytös alkioita lisättäessä ja poistettaessa riippuu listan toteutustavasta. 69 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 69(279)
70 Kertausta algoritmiikasta ja aikavaativuudesta Abstraktin listan operaatiot Määritelmä 1-19: Seuraava luettelo kuvaa tällä kurssilla käytettävän tietorakennekirjaston listaoperaatiot. Asemana käytetään viitettä listasolmuun (ListNode). Elementtityyppinä käytämme geneeristä E:tä. (parametrien tyypit: E x, ListNode p, TraLinkedList L) 1) TraLinkedList<Alkiotyyppi> TraLinkedList<Alkiotyyppi>() Muodostaa tyhjän listan L. Alkiotyyppi voi olla mikä tahansa luokka. 2) ListNode L.first() Palauttaa listan L ensimmäisen alkion aseman. Jos L on tyhjä lista, palauttaa aseman L.EOL. 3) ListNode L.last() Palauttaa listan L viimeisen alkion aseman. Jos L on tyhjä lista, palauttaa aseman L.EOL. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 70(279)
Kertausta algoritmiikasta ja aikavaativuudesta 4) void L.insert(p, x) Lisää alkion x listaan L asemaan p (tarkemmin: asemassa p olleen alkion eteen). Jos p = L.EOL, kohdistuu lisäys listan loppuun. Jos taas asemaa p ei listassa L lainkaan ole, on vaikutus määrittelemätön. 5) void L.remove(p) Poistaa listasta L asemassa p olevan alkion. Jos p = L.EOL tai asemaa p ei listassa L lainkaan ole, on vaikutus määrittelemätön. 6) ListNode p.next() Palauttaa asemaa p seuraavan aseman listassa. Jos p on listan viimeisen alkion asema, palauttaa p.next aseman L.EOL ja jos p = L.EOL (tai listassa ei ole asemaa p) on p.next määrittelemätön. 7) ListNode p.previous() Palauttaa asemaa p edeltävän aseman listassa. Jos p on listan ensimmäisen alkion asema (tai listassa ei ole asemaa p), on p.previous määrittelemätön. 8) E p.getelement() Palauttaa asemassa p olevan alkion. Jos p = L.EOL on tulos määrittelemätön. 71 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 71(279)
Kertausta algoritmiikasta ja aikavaativuudesta Listan läpikäynti Yleensä lista läpikäydään käyttäen listasolmuja ja alkuehtoista toistoa. Jollei listaa muuteta, eikä tarvita useaa limittäistä toistoa, myös foreach - toisto toimii, kts. alla LinkedList:n yhteydestä. Listaoperaatioiden aikavaativuus first, next, getelement ja listan luonti tulisi aina olla O(1) (vakioaikaisia) jotta läpikäynti olisi tehokasta. insert, remove, previous, last ja EOL on mahdollista (jopa helppoa) tehdä vakioaikaisiksi, joten jos/kun niitä tarvitaan, niin ne on syytä tehdä vakioaikaisiksi. Lähinnä taulukkototeutuksessa osa voi olla O(listan pituus), mutta... 72 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 72(279)
Esimerkki 1-20: Esimerkki: listojen samuuden vertailu. Listat ovat samat, jos ne ovat yhtä pitkät ja niissä on samat alkiot samassa järjestyksessä. 73 Kertausta algoritmiikasta ja aikavaativuudesta public boolean comparelists(tralinkedlist L1, TraLinkedList L2) { 1 ListNode p1 = L1.first(); 2 ListNode p2 = L2.first(); 3 while ((p1!= L.EOL) && (p2!= L.EOL)) { 4 if (! p1.getelement().equals(p2.getelement())) 5 return false; 6 p1 = p1.next(); 7 p2 = p2.next(); 8 } 9 if (p1 == L1.EOL && p2 == L2.EOL) 10 return true; 11 else 12 return false; 13 } 14 Aikavaativuus? Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 73(279)
Kertausta algoritmiikasta ja aikavaativuudesta java.util.linkedlist Operaatiot kuten Vector:lle, mutta aikavaativuudet erilaiset. Osa Javan vakiokirjastoa, kts. API:n dokumentaatio. Asemaa (listasolmua) ei paljasteta käyttäjälle. Suorat get(index), add(index, element), jne operaatiot ottavat parametrinaan indeksin (järjestysnumeron) listan alusta. Aikavaativuus O( L ) jos joutuvat etsimään indeksin!! Jollei, niin esim. lisäys ja poisto vakioaikaisia. Juuri päinvastoin kuin Vector -luokalla. LinkedList<Integer> L = new LinkedList<Integer>(); 1 for (int i = 0; i < N; i++) // yhteensä O(N) 2 L.add(i, i); // lisäys loppuun O(1) 3 for (int i = 0; i < N; i++) // yhteensä O(N 2 ) 4 L.add(i/2, i); // lisäys keskelle O(N) 5 for (int i = 0; i < N; i++) // yhteensä O(N 2 ) 6... = L.get(i); // indeksin haku O(N) 7 Läpikäynti O(N 2 )??? 74 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 74(279)
Tehokkaaseen läpikäyntiin on käytettävä iteraattoria! 75 Kertausta algoritmiikasta ja aikavaativuudesta Iteraattori toimii osoittimena kuten yllä käyttämämme asemamuuttuja, mutta se viittaa alkioiden (listasolmujen) väliin, eikä asemaan (listasolmuun)! Määritelmä 1-21: java.util.listinterator operaatiot (tärkeimmät). 1) ListIterator i = L.listIterator() Luo ja alustaa uuden iteraattorin. 2) boolean i.hasnext() kertoo onko seuraavaa alkiota olemassa vai ei. 3) E i.next() siirtää iteraattoria seuraavaan väliin ja palauttaa yli hyppäämänsä alkion. 4) E i.previous() siirtää iteraattoria edelliseen väliin ja palauttaa yli hyppäämänsä alkion. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 75(279)
Kertausta algoritmiikasta ja aikavaativuudesta 5) void i.add(x) lisää elementin x iteraattorin osoittamaan väliin. Uusi elementti ei tule mukaan läpikäyntiin next-operaatioilla, mutta jos seuraavaksi kutsutaan previous-operaatioita, se palauttaa tämän uuden alkion.. 6) void i.remove() poistaa elementin joka viimeksi hypättiin yli next:llä tai previous:lla. Esimerkki 1-22: Listan läpikäynti iteraattorilla ja alkuehtoisella toistolla. LinkedList L; 1... 2 ListIterator i = L.listIterator(); 3 while (i.hasnext()) // yhteensä O(N) 4... = p.next() 5 Kokoelmaa voi muuttaa kesken läpikäynnin vain tämän iteraattorin add/remove -metodeillä. Kaksi sisäkkäistä läpikäyntiä ei saa muuttaa listaa (kuten purge:ssa yllä). Yksinkertaisiin läpikäynteihin tämä on suhteellisen näppärä. 76 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 76(279)
Esimerkki 1-23: Alkion x kaikkien esiintymien poisto. 77 Kertausta algoritmiikasta ja aikavaativuudesta ListIterator i = L.listIterator(); 1 while (i.hasnext()) // O(N) 2 if (x.equals(p.next())) 3 i.remove(); 4 foreach -toisto Jos listaa ei aiota muuttaa kesken läpikäynnin, iteraattorikin on turha. Java >=1.5 tukee "tee kaikille alkioille" -toistoa Iterable rajapinnan toteuttaville kokoelmille: for(e x : L) // E on alkiotyyppi, L kokoelma 1 x.foo(); 2 Tämä on toteutettu iteraattorilla. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 77(279)
Kertausta algoritmiikasta ja aikavaativuudesta java.util.linkedlist:n huonot puolet Iteraattorit luontuvat vain yksinkertaiseen peräkkäiseen läpikäyntiin. Monimutkaisemmassa tapauksessa joudutaan turvautumaan tehottomampiin indekseihin. Kts esim. purge, TraListMerge.java vrt. JavaListMerge.java. 78 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 78(279)
Kertausta algoritmiikasta ja aikavaativuudesta Listan käyttökohteet: Mikä tahansa, missä kokoelmaa käydään lävitse peräkkäisjärjestyksessä. Erityisesti, jos kokoelmalla on jokin järjestys. Erityisesti, jos keskelle kokoelmaan kohdistetaan lisäys- tai poistooperaatioita. (jotka taulukossa ovat raskaita!) Esim: "laske kokoelman alkoiden summa". Peräkkäisrakenne ok Esim: "etsi annetun puhelinnumeron haltijan nimi". peräkkäisrakenne liian hidas etsimiseen lista on huono vaihtoehto 79 Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 79(279)
Lista on yleiskäyttöinen tietorakenne. 80 Kertausta algoritmiikasta ja aikavaativuudesta Läheskään aina ei tarvita kaikkea listan toiminnallisuutta. Näissä tapauksissa riittää rajoittaa operaatiojoukkoa sopivaksi, yleensä saantipaikan suhteen Hyöty: saadaan huomattavasti yksinkertaisemmat operaatiot. helppolukuisempi ohjelma vähemmän virhemahdollisuuksia helpompi toteuttaa yksikäsitteisempi Listan rajoitettuja muotoja: Pino: lisäys ja poisto päältä Jono: lisäys häntään, poisto keulalta Pakka: lisäys ja poisto päistä Rengas: listan alku ja loppu samaistettu Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 80(279)
Taulukko 81 Kertausta algoritmiikasta ja aikavaativuudesta Lista ei tue alkion muuttamista, eikä hakemista suoraan (vakioajassa) sijainnin perusteella. Alkion muuttaminen vaatii poiston ja lisäyksen. Alkioiden käsittely mielivaltaisessa järjestyksessä (hajasaanti) on mahdotonta (tai raskasta). Jos sekä peräkkäiskäsittely, että mielivaltaisessa järjestyksessä käsittely ovat tärkeitä, tarvitaan (abstraktia) taulukkotyyppiä. Taulukon alkiot ovat keskenään peräkkäissuhteessa ( lista). Taulukon alkion asema selviää indeksoimalla (ts. (suhteellinen) etäisyys taulukon alusta). Indeksit ovat kokonaislukutyyppiä (tai lueteltua tyyppiä), niillä voidaan jopa laskea. Tietorakenteet ja algoritmit II 13.4.2011 08:47 UEF/tkt Simo Juvaste 81(279)