Kurssiesittely Tietojenkäsittelytieteiden laitos Tampereen yliopisto 25 Tietorakenteet Periodit I-II, syksy 2007 Luennot/vastuuhenkilö: Heikki Hyyrö Sähköposti: heikki.hyyro@cs.uta.fi Kurssin kotisivu: http://www.cs.uta.fi/tira/ 0 op (5 ov) laajuinen aineopintotasoinen kurssi Pakollinen osa tietojenkäsittelyopin kandidaatin tutkielmaa 26 luentokertaa (52 tuntia) Pinni B:n luentosali B097 Tiistaisin klo 0-2 Keskiviikkoisin klo 0-2 Viimeinen luento ke 5.2 Tietorakenteet, syksy 2007 Kurssiesittely 3 viikkoharjoituskertaa (26 tuntia) Linnan luentosali K08 Kolme eri ryhmää: tiistaisin klo 2-4, 4-6 ja 6-8 Ohjaajat: Pekka Niemenlehto (pekka.niemenlehto@cs.uta.fi) ja Jyri Saarikoski (jyri.saarikoski@cs.uta.fi) Ensimmäiset harjoitukset ti.9, viimeiset ti.2 Tietorakenteet, syksy 2007 2 Kurssiesittely Harjoitustyö Tietorakenteisiin liittyvää ohjelmointia Javalla ihe loka-marraskuussa Ohjaaja: Tuomas Talvensaari (tuomas.talvensaari@cs.uta.fi) Palautus tammikuussa 2008 Harjoitustyöhön liittyy tasapainotestin suorittaminen virtuaalilaboratoriossa Saatavaa testidataa voidaan hyödyntää harjoitustyön aineistona Tietorakenteet, syksy 2007 3
Kurssiesittely Kurssin läpipääsy vaatii seuraavat osasuoritukset Tentti (3.2, uusintatentti tammikuussa 2008) Maksimi 30 pistettä, läpipääsyyraja 2 Viikkoharjoitukset: vähintään 20% tehtynä Tuottaa 0-5 pistettä Pisterajat: 33,33% = p, 46,66% = 2 p, 60% = 3 p, 73,33% = 4 p, 86,66% = 5 p Harjoitustyön hyväksytty palautus rvostellaan asteikolla 0-0 pistettä Kurssiesittely Tasapainotesti ntaa 3 lisäsuoritetta viikkoharjoitustehtäväsaldoon Kurssinumero asteikolla..5 määräytyy kokonaispistemäärän mukaan (välillä 2-40) Harjoitustehtävien avulla saatavissa olevat pisteet ovat bonuspisteitä Kysymyksiä kurssijärjestelyistä tms.? Tietorakenteet, syksy 2007 4 Tietorakenteet, syksy 2007 5 Tietorakenteet (ja algoritmit) Tietorakenne: tapa tallentaa ja organisoida tietoa tiedon lukemisen ja/tai päivittämisen kannalta sopivalla tavalla Tietorakenteet, syksy 2007 6 Tietorakenteet (ja algoritmit) Esim. nimiluettelo näin... SMITH NDERSON CLRK JOHNSON THOMS RODRIGUEZ WILLIMS JCKSON LEWIS JONES WHITE LEE BROWN HRRIS WLKER DVIS MRTIN HLL MILLER THOMPSON LLEN WILSON GRCI YOUNG MOORE MRTINEZ HERNNDEZ TYLOR ROBINSON KING Tietorakenteet, syksy 2007 7
Tietorakenteet (ja algoritmit)...vain näin? LLEN JOHNSON RODRIGUEZ NDERSON JONES SMITH BROWN KING TYLOR CLRK LEE THOMS DVIS LEWIS THOMPSON GRCI MRTIN WLKER HLL MRTINEZ WHITE HRRIS MILLER WILLIMS HERNNDEZ MOORE WILSON JCKSON ROBINSON YOUNG Tietorakenteet, syksy 2007 8 Tietorakenteet (ja algoritmit) Tietorakenne: tapa tallentaa ja organisoida tietoa tiedon lukemisen ja/tai päivittämisen kannalta sopivalla tavalla lgoritmi: äärellinen joukko täsmällisesti määriteltyjä ohjeita jonkin tehtävän suorittamiseksi Korkean tason suunnittelussa kaksi tärkeää päämäärää: oikeellisuus tehokkuus Tietorakenteet, syksy 2007 9 Tietorakenteet (ja algoritmit) Toteutukseen liittyviä tavoitteita vahvuus (eng. robustness) mukautuvuus uudelleenkäytettävyys Olioperustaisia suunnittelu/toteutusmenetelmiä abstraktio kapselointi modulaarisuus Tietorakenteet (ja algoritmit) Sovellus lgoritmi lgoritmi2 lgoritmi3 Sovellus lgoritmi lgoritmi2 lgoritmi3 Tietorakenteet, syksy 2007 0 Tietorakenteet, syksy 2007
lgoritmien analysoinnista lgoritmin tehokkuuden mittaaminen? haluttaisiin muodostaa funktio f(n), joka kuvaa algoritmin suoritusaikaa lgoritmien analysoinnista Kokeellinen analyysi? algoritmin suoritusaika t lgoritmi lgoritmi 2 Syötteen koko (parametri) n Tietorakenteet, syksy 2007 2 Tietorakenteet, syksy 2007 3 lgoritmien analysoinnista Kokeellinen analyysi + sinänsä varmin tapa tutkia tietyn algoritmin suorituskykyä tietyn tehtävän ratkaisussa - vaikea arvioida algoritmin suorituskykyä kaikilla mahdollisilla syötteillä - algoritmien yleisempi vertailu/luokittelu hankalaa - vaatii algoritmin toteuttamisen lgoritmien analysoinnista jatus 2: suoritettujen perusoperaatioiden tarkka analysointi muodostetaan algoritmille alhaisen tason koodiesitys (esim. kännetään konekielelle) määritetään t i = alhaisen tason komennon i vaatima suoritusaika määritetään n i = alhaisen tason komennon i suoritusten lukumäärä kokonaisaika = Σ i (n i t i ) Ehkä tarkkaa, mutta työlästä ja laite/kieliriippuvaista! Tietorakenteet, syksy 2007 4 Tietorakenteet, syksy 2007 5
Pseudokoodi lgoritmin tarkastelu paperilla: pseudokoodi Geneeristä ohjelmakoodia, jossa sivuutetaan tarpeettomat yksityiskohdat oleellista toiminta-askeleiden kuvaus, ei esim. pilkulleen tietynlainen syntaksi sekoitus luonnollista kieltä ja geneerisiä ohjelmointirakenteita (kontrollirakenteet, aliohjelmakutsut jne.) kuvaa algoritmin toiminnan riittävän täsmällisesti (asiayhteyden vaatimalla tarkkuudella) Tietorakenteet, syksy 2007 6 Pseudokoodi lgorithm OddCount(, n) Input: Taulukko, jossa n kokonaislukua Output: Tulostaa taulukon parittomien lukujen lukumäärän odds 0 for i 0 to n Do if [i] on pariton then odds odds + end if end for tulosta arvo odds return Tietorakenteet, syksy 2007 7 Pseudokoodi int OddCount( int [ ], int n ) { /* Funktio OddCount C/C++ -kielellä */ int odds = 0, i = 0; for( i = 0; i < n; i++ ) { if( ([i] % 2) == ) { odds++; } } printf( %d\n, odds ); return; } Suoritusajan arviointi yleisellä tasolla Yhä ongelma: konkreettinen suoritusaika riippuu suoritusympäristöstä suoritusajan abstraktimpi tarkastelu? Suoritusaika kuitenkin aina verrannollinen suoritettujen operaatioiden lukumäärään funktion f(n) abstrakti aikayksikkö = suoritettavien alkeisoperaatioiden määrä lkeisoperaatio: perusoperaatio, jonka suoritusaika oletetaan vakioksi Tietorakenteet, syksy 2007 8 Tietorakenteet, syksy 2007 9
lkeisoperaatiot Esim. seuraavat voidaan katsoa alkeisoperaatioiksi arvon asetus muuttujaan taulukon alkion muistipaikan laskenta olioviitteen laskenta kahden arvon vertailu aritmeettinen operaatio metodikutsu metodin arvon palauttaminen Esimerkki alkeisoperaatioiden määrän laskennasta lgorithm OddCount(, n) odds 0 operaatio for i 0 to n Do 2 alkuoperaatiota, 3 operaatiota if [i] on pariton then odds odds + end if end for return odds 2 operaatiota 2 operaatiota operaatio Yhteismäärä? vähintään? + 2 + n (3 + 2) + = 4 + 5n enintään? + 2 + n (3 + 4) + = 4 + 7n Tietorakenteet, syksy 2007 20 Tietorakenteet, syksy 2007 2 Toinen esimerkki lgorithm OCRepeat(, n) for i to n Do 2 alkuoperaatiota, 3 operaatiota OddCount(, i) end for return + kork. 4 + 7i operaatiota operaatio Yhteismäärä enintään? 3+n (3+)+Σ n i= (4+7i) = 3+4 n+4 n+7 Σ n i= i = 3+8 n+7 n(n+)/2 Tietorakenteet, syksy 2007 22
Palataan edellisen kerran esimerkkiin lgorithm OddCount(, n) odds 0 operaatio for i 0 to n Do 2 alkuoperaatiota, 3 operaatiota if [i] on pariton then odds odds + end if end for return odds 2 operaatiota 2 operaatiota operaatio Saatiin alkeisoperaatioiden lukumääriksi vähintään 4 + 5n ja enintään 4 + 7n Paras/keskimääräinen/pahin Tyypillisesti kolme analysointinäkökulmaa Parhaan tapauksen (syötteen) analyysi Keskimääräisen tapauksen (syötteen) analyysi Pahimman tapauksen (syötteen) analyysi Yleisin ja usein tärkein: pahimman tapauksen analyysi esim. laskentaresurssien riittävyyden arviointi Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2 Paras/keskimääräinen/pahin Kiinnostava mutta yleensä hankalin: keskimääräisen tapauksen analyysi keskimääräinen syöte usein hankala määrittää (alkeisoperaatioiden lukumäärän keskiarvo kaikkien mahdollisten syötteiden käsittelyssä) Vähemmän tärkeä: parhaan tapauksen analyysi Joskin voi olla mielenkiintoista esim. verrata, paljonko parhaan ja pahimman syötetapauksen suoritusajat poikkeavat toisistaan Edellisen kerran viimeinen esimerkki lgorithm OCRepeat(, n) for i to n Do 2 alkuoperaatiota, 3 operaatiota OddCount(, i) end for return + kork. 4 + 7i operaatiota operaatio lkeisoperaatioiden yhteismäärä enintään 3 + 8n + 7n(n + )/2 rvion f(n) = 3+8n+7n(n+)/2 vertailukelpoisuus?jos esim jollekin muulle algoritmille saadaan arvio f 2 (n) = 0n + 4n 2? Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
Vakiokertoimet Kuinka tarkkoja vertailuja saadaan käyttäen alkeisoperaatioihin perustuvia arvoja f(n)? Seikka : eri alkeisoperaatioiden suoritusajat voivat vaihdella, mutta ovat kuitenkin vakioita Olkoon t min nopeimman ja t max hitaimman alkeisoperaation suoritusaika jat vakioita, joten on vakiokerroin c jolla t max = c t min f(n) voi poiketa vakiokertoimen c verran Tietorakenteet, syksy 2007 5 Vakiokertoimet Esimerkki: olkoon kahden algoritmit alkeisoperaatioiden määrät f (n) = 3 + 5n ja f 2 (n) = 2 + 6n lgoritmin oikea suoritusaika on välillä 3 + 5n...3c + 5cn, ja algoritmin 2 välillä 2 + 6n...2c + 6cn (kun ajan mittayksikkö on t min ) kumpi on nopeampi riippuu algoritmien alkeisoperaatioiden yksityiskohdista Korkean tason analyysin kannalta resurssivaatimuksenvakiokerroin ei ole kovin oleellinen kasvun suuruusluokka on tärkeämpi Tietorakenteet, syksy 2007 6 Funktion f(n) kasvun suuruusluokka lgoritmien analysointia yksinkertaistava ja yleistävä (joskin epätarkentava) ajatus: jätetään arvon f(n) termien vakiokertoimet pois Nyt esim. f (n) = 3+5n voidaan esittää muodossa + n Tulkinta: f (n) on jokseenkin muotoa c(+n) jollakin vakiolla c Seuraava askel: jätetään jäljelle ainoastaan dominoiva termi (määrää kasvun suuruusluokan) Esim. f(n) = n + n 2 supistuu muotoon n 2 Tietorakenteet, syksy 2007 7 symptoottinen analyysi symptoottinen analyysi: tarkastellaan funktion f(n) käyttäytymistä suurilla n:n arvoilla (n ) Dominoiva termi syrjäyttää alemmat termit Esim. n + n 2 + n 3 n 3, kun n n+n2 +n 3 n 3 = + n 2 n +, kun n lempien termien poisjättö tuottaa korkeintaan vakiotermin suuruisen virhekertoimen Virhekerroin pienenee arvoon kun n kasvaa epätarkkuus mitätön suurilla n:n arvoilla Tietorakenteet, syksy 2007 8
O-notaatio (iso O, ordo eli järjestys latinaksi) lgoritmin suoritusajan (usein myös muistinkäytön) kuvaamiseen käytetään yleisesti iso O -notaatiota Määritelmä: f(n) on O(g(n)), jos on olemassa vakioarvot n 0 > 0 ja c > 0 siten, että f(n) c g(n) kun n > n 0 O ilmaisee asymptoottisen ylärajan resurssivaatimusten kasvun suuruusluokalle Jos algoritmille pätee f (n) = O(g(n)), niin algoritmin suoritusajan kasvu n:n suhteen on korkeintaan luokkaa g(n) Tietorakenteet, syksy 2007 9 O-notaatio (iso O, ordo eli järjestys latinaksi) algoritmin suoritusaika t f(n) cg(n) n 0 Syötteen koko (parametri) n Tietorakenteet, syksy 2007 0 O-notaatio (iso O, ordo eli järjestys latinaksi) Nyrkkisääntö: funktion f(n) suuruusluokka = sen suurimman suuruusluokan omaavan yksittäisen termin suuruusluokka (dominoi alempia luokkia) Esim. 00n + 3 log(n) + n2 00 = O(n2 ) Tarkastellaan esimerkkinä tämän todistamisesta O-notaatio (iso O, ordo eli järjestys latinaksi) Todistetaan: 00n + 3 log(n) + n2 00 = O(n2 ) rajataan vasemmanpuolen termit yksitellen muotoa c i n 2 olevilla termeillä, missä kukin c i vakio: selvästi esim. 00n 2 00n, 3n 2 3 log(n) ja n 2 n2 00 esim. kun n > n 0 = vakio c: summataan yhteen termirajausten c i - vakiokertoimet: c = 00 + 3 + = 04 00n+3log(n)+ n2 00 00n2 +3n 2 +n 2 = 04n 2 = cn 2, kun n > n 0 = Väite on O:n määritelmän nojalla todistettu Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2
Kasvunopeuden suuruusluokista Tyypillisiä suuruusluokkatyyppejä (kasvavassa järjestyksessä, alempi dominoi ylempiä) O(): vakio O(log(n)): logaritminen O(n): lineaarinen O(n log(n)): n log n O(n 2 ): neliöllinen O(n k ): polynomiaalinen (k on vakio) O(a n ): exponentiaalinen (a > ) Kasvunopeuden suuruusluokista Suuruusluokkien kasvunopeuksia log(n) n n log(n) n 2 2 n 2 2 4 4 2 4 8 6 6 4 6 64 256 65536 6 64 384 4096.84 0 9 8 256 2048 65536.5 0 77 0 024 0240 048576.79 0 308 Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4 Lisää O-esimerkkejä 0 000 on O() (vakio) vasemmanpuolen luku on valtava, mutta kuitenkin vakio voidaan valita esim. c = 0 000 + ja n 0 = selvästi n:n arvosta riippumatta (eli myös kun n > n 0 = ) pätee 0 000 c = 0 000 + kaikki vakiot ovat O() Tietorakenteet, syksy 2007 5 Lisää O-esimerkkejä Yleisesti: kun f(n) = a 0 n 0 + a n +... + a k n k on k-asteen polynomi, niin f(n) on O(n k ) Todetaan, että ilman vakiokertoimia ylemmän asteen termit rajaavat alempia: n k n k... n n 0 =, kun n > n 0 = Yksittäisten termien ylärajat: valitaan c i = a i (itseisarvo huolehtii negatiivisista vakiotermeistä) c i n k = a i n k a i n i a i n i Valitaan c = Σ i c i a 0 n 0 + a n +... + a k n k c 0 n k + c n k +... + c k n k = cn k, kun n > n 0 = Tietorakenteet, syksy 2007 6
Lisää O-esimerkkejä Entä esim. f(n) = n2 log(n)? voidaan toki osoittaa esim. että n2 log(n) = O(n2 ), n mutta......toisaalta myös 2 log(n) on oma kasvun suuruusluokka n:stä riippuvia kertoimia ei yleensä tule poistaa! Esim. n = O(n 2 ), koska O-notaatio sinänsä sallii turhan löysän ylärajan antamisen Käytännössä O-arvo tulisi määrittää mahdollisimman todenmukaiseksi (tiukaksi) ylärajaksi Tietorakenteet, syksy 2007 7 O-laskusääntöjä O-laskusääntöjä, jotka pätevät reaalifunktiolle f(n), g(n) ja h(n) kun n > 0 f(n) = O(cf(n)) millä tahansa vakiolla c 2 jos f(n) g(n) ja g(n) = O(h(n)), niin f(n) = O(h(n)) 3 jos f(n) = O(g(n)) ja g(n) = O(h(n)), niin f(n) = O(h(n)) 4 f(n) + g(n) = O(max{f(n),g(n)}) 5 jos g(n) = O(h(n)), niin f(n) + g(n) = O(f(n) + h(n)) Tietorakenteet, syksy 2007 8 O-laskusääntöjä 6 jos g(n) = O(h(n)), niin f(n)g(n) = O(f(n)h(n)) 7 jos f(n) on k-asteen polynomi, niin f(n) = O(n k ) 8 n k = O(a n ) millä tahansa vakioilla a >, k > 0 9 log(n k ) = O(log(n)) millä tahansa vakiolla k > 0 0 log(n) k = O(n a ) millä tahansa vakioilla a > 0, k > 0 (luentomonisteessa merkintä log k (n)) Toinen esimerkki suuruusluokkien eroista Kuinka suuri syöte saadaan hoidettua aikarajan puitteissa, jos jokainen alkeisoperaatio vie µs aikaa? aikaraja: alkeisoperaatioita sekunti minuutti tunti 400n 2500 50000 9000000 20n log(n) 4096 66666 7826087 2n 2 707 5477 42426 n 4 3 88 244 2 n 9 25 3 Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 20
O, Ω ja Θ Määritelmä: f(n) on O(g(n)), jos on olemassa vakioarvot n 0 > 0 ja c > 0 siten, että f(n) c g(n) kun n > n 0 O eli iso-o tai ordo ilmaisee asymptoottisen ylärajan resurssivaatimusten kasvun suuruusluokalle Samankaltaisia notaatioita: Ω eli iso-omega ja Θ eli theta Ω: asymptoottinen alaraja Θ: asymptoottinen yhtäsuuruus Tietorakenteet, syksy 2007 O, Ω ja Θ Terminologiasta: kasvunopeuden suuruusluokkaa nimitetään usein algoritmin (asymptoottiseksi) kompleksisuudeksi Määritelmä: f(n) on Ω(g(n)), jos on olemassa vakioarvot n 0 > 0 ja c > 0 siten, että f(n) c g(n) kun n > n 0 ainoa ero O:n määritelmään on suuremmuuden suunta f(n) = Ω(g(n)): kompleksisuus on vähintään g(n) Tietorakenteet, syksy 2007 2 O, Ω ja Θ algoritmin suoritusaika t f(n) O, Ω ja Θ f(n) = Ω(g(n)) jos ja vain jos g(n) = O(f(n)) algoritmin suoritusaika t f(n) cg(n) g(n) c f(n) f(n) cg(n) cg(n) n 0 Syötteen koko (parametri) n n 0 Syötteen koko (parametri) n Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
O, Ω ja Θ Esimerkiksi f(n) = 2n 2 + 3n log(n) = Ω(n 2 ) 2n 2 + 3n log(n) n 2, kun n > n 0 = Esimerkiksi f(n) = 00 n2 3n = Ω(n 2 ) 00 n2 = 200 n2 + 200 n2 200 n2 3n, kun n > n 0 = 600 f(n) = 00 n2 3n = 200 n2 + ( 200 n2 3n) 200 n2, kun n > n 0 = 600 O, Ω ja Θ Θ eli theta yhdistää O- ja Ω-merkinnät Määritelmä: f(n) on Θ(g(n)), jos f(n) on Ω(g(n)) ja f(n) on O(g(n)) on olemassa vakio n 0 > 0, c > 0 ja c 2 > 0, joilla c g(n) f(n) c 2 g(n) aina kun n > n 0 f(n) = Θ(g(n)): kompleksisuus on täsmälleen g(n) (vakiotekijän rajoissa) Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 O, Ω ja Θ algoritmin suoritusaika t c 2 g(n) f(n) c g(n) O, Ω ja Θ f(n) = Θ(g(n)) jos ja vain jos g(n) = Θ(f(n)) c g(n) f(n) c 2 g(n) c 2 f(n) g(n) c f(n) algoritmin suoritusaika t c 2 g(n) f(n) c g(n) n 0 Syötteen koko (parametri) n n 0 Syötteen koko (parametri) n Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8
O, Ω ja Θ Θ on asymptoottisesti yksikäsitteinen jos esim. f(n) = Θ(g (n)) ja f(n) = Θ(g 2 (n)), niin g (n) ja g 2 (n) omaavat keskenään saman kompleksisuuden Esim. O-raja voi olla asymptoottisesti epätarkka, mutta Θ-arvo ei 2n = O(n) (tarkka) ja toisaalta 2n = O(n 2 ) (epätarkka raja) O, Ω ja Θ Esimerkiksi f(n) = 00 n2 3n = Θ(n 2 ) aiemmin todettiin, että f(n) = Ω(n 2 ) tarvitsee näyttää, että f(n) = O(n 2 ) 00 n2 n 2 3n n 2 f(n) = 00 n2 3n 2n 2, kun n > n 0 = 0 00 n2 3n = Ω(n 2 ) ja 00 n2 3n = O(n 2 ), joten f(n) = 00 n2 3n = Θ(n 2 ) Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 0 symptoottisen notaation käytöstä Huomioita O-notaation käytöstä merkintä f(n) = O(g(n)) ei oikeasti tarkoita yhtäsuuruutta, vaan että funktiolla f(n) on suuruusluokkaa g(n) oleva yläraja formaalisti O(g(n)) on funktioiden joukko sisältää kaikki funktiot f(n), joiden kasvunopeus on korkeintaan samaa suuruusluokkaa kuin funktion g(n) voitaisiin siis (oikeammin) merkitä f(n) O(g(n)) Tietorakenteet, syksy 2007 symptoottisen notaation käytöstä Kuitenkin vallitseva tapa: f(n) = O(g(n)) Esimerkki: 2n 2 + 5n = 2n 2 + O(n) O(g(n)): jokin kasvunopeuden O(g(n)) omaava funktio O-arvot on yleensä tarkoituksenmukaista antaa mahdollisimman sievennetyssä muodossa Mukaanlukien vakiotermien poisto (esim. O(3n 2 ) sievennetään muotoon O(n 2 )) Vastaavat huomiot pätevät myös esim. Ω- ja Θ-notaatioille Tietorakenteet, syksy 2007 2
symptoottisen notaation käytöstä symptoottisen notaation päätarkoitus on auttaa algoritmien korkean tason analysoinnissa vakiokertoimien huomioimatta jättäminen voi olla käytännössä merkittävää esim. O(n log(n)) toisinaan käytännössä tehokkaampi kuin O(n) Usein O-notaatiota käytetään Θ-notaation roolissa Tyypillinen tulkinta: O(f(n)) tarkoittaa (mahdollisimman) tiukkaa pahimman tapauksen kompleksisuutta Tietorakenteet, syksy 2007 3 symptoottisen notaation käytöstä Jos puhutaan yleisesti ottaen algoritmin kompleksisuudesta, niin O: algoritmin kompleksisuuden yläraja pahimman tapauksen analyysi Ω: algoritmin kompleksisuuden alaraja parhaan tapauksen analyysi Θ: algoritmin kompleksisuus vakiokertoimeen asti syötteestä riippumaton parhaalla ja pahimmalla tapauksella sama kompleksisuus Tietorakenteet, syksy 2007 4 symptoottisen notaation käytöstä Jos tarkastellaan nimenomaan parasta / keskimääräistä / pahinta tapausta: f(n) = Θ(g(n)): kompleksisuus on kyseisessä tapauksessa tarkalleen g(n) f(n) = O(g(n)): kompleksisuus on kyseisessä tapauksessa korkeintaan g(n) f(n) = Ω(g(n)): kompleksisuus on kyseisessä tapauksessa vähintään g(n) tällöin O ja ω mielekkäitä lähinnä jos tarkka Θ vaikea määrittää (tai se on vaikealukuinen) Tietorakenteet, syksy 2007 5 o ja ω O- ja Ω-merkintöjen aidot versiot: o ja ω Määritelmä: f(n) on o(g(n)), jos mille tahansa vakiolle c > 0 on olemassa vakioarvo n 0 siten, että f(n) < cg(n), kun n > n 0 f(n) on o(g(n)): f(n) g(n) 0, kun n tarkoittaa, että funktion f(n) kompleksisuus on aidosti pienempi kuin funktion g(n) vrt. f(n) = O(g(n)): kompleksisuus on pienempi tai yhtäsuuri kuin g(n) Esim. 2n + log(n) = 2n + o(n) Tietorakenteet, syksy 2007 6
o ja ω Määritelmä: f(n) on ω(g(n)), jos mille tahansa vakiolle c > 0 on olemassa vakioarvo n 0 siten, että f(n) > cg(n), kun n > n 0 funktion f(n) kompleksisuus on aidosti suurempi kuin funktion g(n) vrt. f(n) = Ω(g(n)): kompleksisuus on suurempi tai yhtäsuuri kuin g(n) Esim. 2n log(n) + 5n = ω(n) f(n) = ω(g(n)) g(n) = o(f(n)) Muutama esimerkki lgorithm OddCount(, n) odds 0 for i 0 to n Do if [i] on pariton then odds odds + end if end for return odds symptoottinen analyysi: riittää laskea alkeisoperaatioiden lukumäärän suuruusluokka o- ja ω-notaatioita käytetään melko harvoin Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8 Muutama esimerkki lgorithm OddCount(, n) odds 0 for i 0 to n do if [i] on pariton then odds odds + end if end for return odds for-silmukan sisällä: O() silmukkaa suoritetaan O(n) kertaa kompleksisuus O() O(n) = O( n) = O(n) Tietorakenteet, syksy 2007 9 Toinen esimerkki lgorithm FindFirstOdd(, n) i 0 while i < n ja [i] ei ole pariton do i i + end while return i Paras tapaus? [0] on pariton parhaan tapauksen työmäärä Θ() Pahin tapaus? jokainen [i] parillinen pahimman tapauksen työmäärä Θ(n) Ω() ja O(n), Θ ei yleisesti ottaen olemassa Tietorakenteet, syksy 2007 20
Toinen esimerkki lgorithm FindFirstOdd(, n) i 0 while i < n ja [i] ei ole pariton do i i + end while return i Keskimääräinen tapaus? O() jos sisältää satunnaislukuja todennäköisyys 2, että [i] parillinen todennäköisyys edetä alkioon i: 2 i esim. i 4 n. = 2 4 6-osalle syötteistä Tietorakenteet, syksy 2007 2 Toinen esimerkki lgorithm FindFirstOdd(, n) i 0 while i < n ja [i] ei ole pariton do i i + end while return i Keskimääräinen tapaus jatkuu... olkoon q erilaisten kokoa n olevien syötteiden lukumäärä 2 i q syötettä, joilla tutkitaan alkio [i] Tietorakenteet, syksy 2007 22 Toinen esimerkki lgorithm FindFirstOdd(, n) i 0 while i < n ja [i] ei ole pariton do i i + end while return i Keskimääräinen tapaus jatkuu... kaikkien syötteiden käsittely: tutkitaan yhteensä Σ n i=0 (q ) alkiota 2 i keskiarvo: em. lukumäärä jaettuna arvolla q: Σi=0 n ( ) = 2 < 2 = O() 2 i 2 n Tietorakenteet, syksy 2007 23 Toinen esimerkki Hieman hankalampi tapaus: lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Voidaan soveltaa induktiota koodin yhteydessä ns. silmukkainvariantti Tutkitaan mitä tapahtuu algoritmin alkuvaiheessa (pienillä i:n arvoilla), ja yritetään edetä induktiivisesti arvosta i arvoon i + Tietorakenteet, syksy 2007 24
Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return luksi nyrkkisääntö: algoritmin kompleksisuuden määrää sen useimmin suoritetun operaation suorituskertojen lukumäärä, lkm max operaatioita vakio c operaatioiden kokonaislukumäärä korkeintaan c lkm max Tietorakenteet, syksy 2007 25 Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Tästä ensimmäinen huomio: algoritmin Mysteeri kompleksisuus verrannollinen sisäsilmukan suorituskertojen lukumäärään Jatkohuomio: kukin sisäsilmukan suoritus kasvattaa muuttujan c arvoa yhdellä kompleksisuus verrannollinen c:n lopulliseen arvoon Tietorakenteet, syksy 2007 26 Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Tutkitaan arvon c muutosta induktiivisesti i = : sisäsilmukka suoritetaan arvoille j = 2...n eli c kasvaa arvosta arvoon n i = 2: sisäsilmukka suoritetaan arvoille j = n +...n 2 eli c kasvaa arvosta n arvoon n 2 Tietorakenteet, syksy 2007 27 Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return i = 3: sisäsilmukka suoritetaan arvoille j = n 2 +...n 3 eli c kasvaa arvosta n 2 arvoon n 3 c:n arvot kun i =...3: n, n 2, n 3 c:n arvo näyttäisi noudattavan kaavaa n i Edetään induktioperiaatteen mukaisesti ja silmukkainvarianttia käyttäen Tietorakenteet, syksy 2007 28
Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Silmukkainvariantti: c:n arvo on n i kierroksen i jälkeen Induktio-oletus: sääntö päti kun i =...3. Oletetaan, että c:n arvo on n i aina kun i < i Induktioaskel: tutkitaan päteekö väite kierroksen i jälkeen Tietorakenteet, syksy 2007 29 Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Oletuksen nojalla c:n arvo kierroksen i jälkeen on n i kierroksen i alussa asetetaan k cn eli k saa arvon nn i = n i c:n arvo kasvaa arvolla k c, joten c:n uusi arvo on c + k c = k = n i Induktion nojalla väite pätee kaikilla i Tietorakenteet, syksy 2007 30 Toinen esimerkki lgorithm Mysteeri(n) c for i to n do k cn for j c + to k do c c + end for end for return Kierroksen i = n jälkeen c = n i = n n lgoritmin Mysteeri kompleksisuus on näin ollen O(n n ) tarkkaan ottaen Θ(n n ), koska pahin ja paras tapaus identtisiä ja esitetyssä analyysissä ainoastaan vakiotekijän suuruinen epätarkkuus Tietorakenteet, syksy 2007 3
Pino (stack) Pino: viimeisenä sisään, ensimmäisenä ulos (LIFO, Last In, First Out) -tietorakenne kaksi perusoperaatiota: alkion lisäys pinon päälle (push), ja päällimmäisen alkion poisto (pop) tietoalkio Push(alkio2) eli lisätään tietoalkio 2 tietoalkio 2 tietoalkio tietoalkio 3 tietoalkio 2 tietoalkio tietoalkio 2 tietoalkio Push(alkio3) eli lisätään tietoalkio 3 Pop() eli poistetaan päällimmäinen alkio Push(alkio4) eli lisätään tietoalkio 4 tietoalkio 4 tietoalkio 2 tietoalkio Tietorakenteet, syksy 2007 Pinon tarkempi määrittely Pino S on abstrakti tietotyyppi, jolla on ainakin perusmetodit: Push(x): lisää tietoalkion x pinon päälle Pop(): palauttaa pinon päällimmäisen alkion (ja poistaa sen pinosta) tapahtuu virhe, jos pino on tyhjä Muutamia pinon mahdollisia apumetodeja IsEmpty(): palauttaa arvon true, jos pino on tyhjä, ja muuten arvon false Tietorakenteet, syksy 2007 2 Pinon tarkempi määrittely Top(): palauttaa pinon päällimmäisen alkion poistamatta sitä pinosta tapahtuu virhe, jos pino on tyhjä käytetään joskus myös nimeä Peek() Size(): palauttaa kokonaislukuarvon, joka kertoo kuinka monta alkiota pinossa on Esimerkki tietoalkio Top() palauttaa päällimmäisen alkion poistamatta sitä tietoalkio 4 tietoalkio 3 tietoalkio 2 tietoalkio Pop() palauttaa (ja poistaa) päällimmäisen alkion tietoalkio 4 tietoalkio 3 tietoalkio 2 Pop() pino on tyhjä virhe! tietoalkio 5 tietoalkio 4 tietoalkio 3 tietoalkio 2 IsEmpty() palauttaa arvon true tietoalkio 4 tietoalkio 3 tietoalkio 2 Size() palauttaa arvon 3 Push(alkio5) lisää pinon päälle alkion 5 Pop() palauttaa ja poistaa päällimmäisen alkion IsEmpty() palauttaa arvon false Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
Pinon rajapinta Javalla public interface Stack { public int size(); public boolean isempty(); public Object top() throws StackEmptyException; public void push (Object element); public Object pop() throws StackEmptyException; } public class StackEmptyException extends RuntimeException { public StackEmptyException(String err) { super(err); } } Pinon taulukkototeutus bstrakti määrittely ei ota kantaa toteutustapaan Perustapa: pinon alkiot talletetaan taulukkoon Taulukkototeutuksen osat: kokoa N oleva taulukko S muuttuja top, joka kertoo taulukon päällimmäisen alkion indeksin toteutustavan aiheuttama rajoitus: pinoon mahtuu korkeintaan N alkiota, missä N on taulukon koko Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 Pinon taulukkototeutus Esim. pino taulukossa S, jonka koko on N = 0 pinossa 4 alkiota 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 top = 3 Push(alkio5) lisää alkion 5 kohtaan top + 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 alkio5 top = 3 top + = 4 ja arvoa top kasvatetaan yhdellä 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 alkio5 Pinon taulukkototeutus tyhjä pino 0 2 3 4 5 6 7 8 9 top = pino on täynnä 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 alkio5 alkio6 alkio7 alkio8 alkio9 alkio0 top = 9 top = N, seuraava paikka N menisi taulukon rajojen yli nyt Push(x) tuottaisi virheen (ylivuoto) top = 4 Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8
Pinon taulukkototeutus Javalla public class rraystack implements Stack { public static final int defaultn = 000; private int N; private Object S[]; private int top = -; public rraystack() { this(defaultn); } public rraystack(int size) { N = size; S = new Object[N]; } Pinon taulukkototeutus Javalla public int size() { return (top + ); } public boolean isempty() { return (top < 0); } public void push(object obj) { if (size() == N) throw new StackFullException("Stack overflow."); S[++top] = obj; } Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 0 Pinon taulukkototeutus Javalla public Object top() throws StackEmptyException { if (isempty()) throw new StackEmptyException("Stack is empty."); return S[top]; } } public Object pop() throws StackEmptyException { Object elem; if (isempty()) throw new StackEmptyException("Stack is Empty."); elem = S[top]; S[top--] = null; return elem; } Tietorakenteet, syksy 2007 Jono (queue) Jono: ensimmäisenä sisään, ensimmäisenä ulos (FIFO, First In, First Out) -tietorakenne kaksi perusoperaatiota: alkion lisäys jonon perälle (enqueue), ja jonon ensimmäisen alkion poisto (dequeue) alkio alkio alkio2 alkio alkio2 alkio3 alkio2 alkio3 alkio3 Enqueue(alkio2) Enqueue(alkio3) Dequeue() Dequeue() Tietorakenteet, syksy 2007 2
Jonon tarkempi määrittely Jono Q on abstrakti tietotyyppi, jolla on ainakin perusmetodit: Enqueue(x): lisää tietoalkion x jonon perälle Dequeue(): palauttaa jonon ensimmäisen alkion (ja poistaa sen jonosta) tapahtuu virhe, jos jono on tyhjä Jonon tarkempi määrittely Front(): palauttaa jonon ensimmäisen alkion poistamatta sitä jonosta tapahtuu virhe, jos jono on tyhjä Size(): palauttaa kokonaislukuarvon, joka kertoo kuinka monta alkiota jonossa on Vastaavat apumetodit kuin pinolla IsEmpty(): palauttaa arvon true, jos jono on tyhjä, ja muuten arvon false Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4 Esimerkki Front() aiheuttaa virheen Enqueue(alkio) lisää alkion alkio Size() palauttaa arvon alkio Enqueue(alkio2) lisää alkion 2 alkio alkio2 IsEpmty() palauttaa arvon false alkio alkio2 Front() palauttaa alkion poistamatta sitä alkio alkio2 Enqueue(alkio3) lisää alkion 3 alkio alkio2 alkio3 Dequeue() palauttaa ja poistaa alkion alkio2 alkio3 Jonon rajapinta Javalla public interface Queue { public int size(); public boolean isempty(); public Object front() throws QueueEmptyException; public void enqueue (Object element); public Object dequeue() throws QueueEmptyException; } public class QueueEmptyException extends RuntimeException { public QueueEmptyException(String err) { super(err); } } Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6
Jonon taulukkototeutus Jonon taulukkototeutuksen osat: kokoa N oleva taulukko Q muuttuja f irst, joka kertoo jonon ensimmäisen alkion paikan taulukossa jos jono on tyhjä, first kertoo mihin ensimmäinen alkio asetetaan muuttuja rear, joka kertoo seuraavan taulukossa vapaana olevan alkion indeksin Jonon taulukkototeutus Esim. jono taulukossa Q, jonka koko on N = 0 jonossa 5 alkiota 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 alkio5 first = 0 rear = 5 Dequeue palauttaa ja poistaa alkion 0 2 3 4 5 6 7 8 9 alkio2 alkio3 alkio4 alkio5 first = 0 rear = 5 ja arvoa first kasvatetaan yhdellä 0 2 3 4 5 6 7 8 9 alkio2 alkio3 alkio4 alkio5 first = rear = 5 Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8 Jonon taulukkototeutus alkutilanne 0 2 3 4 5 6 7 8 9 alkio8 alkio9 first = 7 rear = 9 Enqueue(alkio0) lisää alkion 0 kohtaan 9 0 2 3 4 5 6 7 8 9 alkio8 alkio9 alkio0 first = 7 rear = 9 arvoa rear kasvatetaan yhdellä 0 2 3 4 5 6 7 8 9 alkio8 alkio9 alkio0 rear = (rear + )%N = 0%0 = 0 first = 7 Jonon taulukkototeutus lähtötilanne 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio5 alkio6 alkio7 alkio8 alkio9 alkio0 rear = 3 first = 4 Enqueue(alkio4) lisäsi alkion 4 kohtaan 3 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio4 alkio5 alkio6 alkio7 alkio8 alkio9 alkio0 first = 4 rear = 4 ongelma, jos jonon tyhjyys tutkitaan ehdon first == rear pohjalta (a la luentomoniste) Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 20
Jonon taulukkototeutus ratkaisu : sallitaan vain N alkiota (a la luentomoniste) ratkaisu 2: ylläpidetään erikseen tieto alkioiden lukumäärästä (nämä kalvot) jonon alkioiden lukumäärä ratkaisussa : jos alkioita vähemmän kuin N, niin alkioiden lkm = (rear + N first)%n 0 2 3 4 5 6 7 8 9 aa2a3 a9 a0aa2a3 rear = 3 first = 8 rear + N = 3 + 0 = 3 Jonon taulukkototeutus Javalla public class rrayqueue implements Queue { public static final int defaultn = 000; private int N; private Object Q[]; private int first = 0; private int rear = 0; private int items = 0; public rrayqueue() { this(defaultn); } public rrayqueue(int size) { N = size; Q = new Object[N]; } Tietorakenteet, syksy 2007 2 Tietorakenteet, syksy 2007 22 Jonon taulukkototeutus Javalla public int size() { return items; } public boolean isempty() { return (items == 0); } public void enqueue(object obj) { if (size() == N) throw new QueueFullException("Queue overflow."); Q[rear] = obj; rear = (rear+) % N; items++; } Tietorakenteet, syksy 2007 23 Jonon taulukkototeutus Javalla public Object front() throws QueueEmptyException { if (isempty()) throw new QueueEmptyException("Queue is empty."); return Q[front]; } public Object dequeue() throws QueueEmptyException { Object elem; if (isempty()) throw new QueueEmptyException("Queue is Empty."); elem = Q[front]; Q[front] = null; front = (front+) % N; items--; return elem; } } Tietorakenteet, syksy 2007 24
Loppuhuomautuksia Sekä pinon että jonon taulukkototeutuksen tilavaatimus on Θ(N) muuttumaton, eikä riipu alkioiden lukumäärästä n jos N suuri arvoon n nähden, suuri osa taulukon muistitilasta käyttämättä jos N liian pieni, tila voi loppua kesken Kukin tässä käsitelty perus- sekä apumetodi omaa suoritusajan Θ() Tietorakenteet, syksy 2007 25
Kaksiloppuinen jono (double-ended queue, deque) Viimeksi käsiteltiin pino: lisäys ja poisto lopusta jono: lisäys loppuun, poisto alusta Pinon ja jonon yleistävä tietorakenne: kaksiloppuinen jono alkion lisäys/poisto voidaan kohdistaa jonon alkuun tai loppuun Kaksiloppuinen jono (double-ended queue, deque) Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PushFront(x): lisää tietoalkion x jonon eteen alkio alkio2 alkio3 alkio alkio2 alkio PushFront(alkio2) PushFront(alkio3) muita nimityksiä mm. InsertFront, ppendleft Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2 Kaksiloppuinen jono (double-ended queue, deque) Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PushBack(x): lisää tietoalkion x jonon perään alkio alkio alkio2 alkio alkio2 alkio3 PushBack(alkio2) PushBack(alkio3) vastaa pinon Push(x)- ja tavallisen jonon Enqueue(x)-metodia muita nimityksiä mm. InsertLast, ppend Tietorakenteet, syksy 2007 3 Kaksiloppuinen jono (double-ended queue, deque) Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PopFront(): palauttaa ensimmäisen alkion (ja poistaa sen jonosta) alkio alkio2 alkio3 alkio2 alkio3 alkio3 tapahtuu virhe, jos jono on tyhjä PopFront() PopFront() tavallisen jonon vastine: Dequeue() Tietorakenteet, syksy 2007 4
Kaksiloppuinen jono (double-ended queue, deque) Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PopBack(): palauttaa viimeisen alkion (ja poistaa sen jonosta) alkio alkio2 alkio3 alkio alkio2 alkio tapahtuu virhe, jos jono on tyhjä vastaa pinon Pop()-metodia PopBack() PopBack() Kaksiloppuinen jono (double-ended queue, deque) Vastaavat apumetodit IsEmpty(): palauttaa arvon true, jos jono D tyhjä, ja muuten arvon false Front(): palauttaa jonon ensimmäisen alkion poistamatta sitä jonosta tapahtuu virhe, jos D on tyhjä alkio alkio2 alkio3 alkio alkio2 alkio3 alkio alkio2 alkio3 IsEmpty() palauttaa false Front() palauttaa alkion, ei poista Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 Kaksiloppuinen jono (double-ended queue, deque) Back(): palauttaa jonon viimeisen alkion poistamatta sitä jonosta tapahtuu virhe, jos D on tyhjä vastaa pinon Top()-metodia Size(): palauttaa kokonaislukuarvon, joka kertoo kuinka monta alkiota jonossa D on alkio alkio2 alkio3 alkio alkio2 alkio3 alkio alkio2 alkio3 Back() palauttaa alkion 3, ei poista Size() palauttaa lukumäärän 3 Tietorakenteet, syksy 2007 7 Kaksiloppuisen jonon taulukkototeutus Kaksiloppuinen jono taulukossa: esimerkiksi jonon taulukkototeutusta matkien kokoa N oleva taulukko D muuttuja f irst: jonon ensimmäisen alkion indeksi jos jono on tyhjä, first kertoo mihin ensimmäinen alkio asetetaan muuttuja rear: seuraavan taulukossa vapaana olevan alkion indeksi muuttuja items: jonon alkioiden lukumäärä Tietorakenteet, syksy 2007 8
PushFront(x) taulukossa 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio7 alkio8 alkio9 alkio0 rear = 3 first = 6 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio x alkio7 alkio8 alkio9 alkio0 PushBack(x) taulukossa 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio7 alkio8 alkio9 alkio0 rear = 3 first = 6 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio x alkio7 alkio8 alkio9 alkio0 rear = 3 D.PushFront(x) if items = N then virhe("d täynnä") first (first + N ) mod N D[first] x items items + first = (first + N ) mod N = 5 rear = (rear + ) mod N = 4 D.PushBack(x) if items = N then virhe("d täynnä") D[rear] x rear (rear + ) mod N items items + first = 6 Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 0 PopFront() taulukossa 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio7 alkio8 alkio9 alkio0 rear = 3 first = 6 0 2 3 4 5 6 7 8 9 alkio alkio2 alkio3 alkio8 alkio9 alkio0 PopBack() taulukossa 0 2 3 4 5 6 7 8 9 alkio5 alkio6 alkio7 alkio8 alkio9 alkio0 rear = 0 first = 4 0 2 3 4 5 6 7 8 9 alkio5 alkio6 alkio7 alkio8 alkio9 rear = 3 first = (first + ) mod N = 7 first = 4 rear = (rear + N ) mod N = 9 D.PopFront() if items = 0 then virhe("d tyhjä") elem D[first] vapauta D[f irst] first (first + )mod N items items Return elem D.PopBack() if items = 0 then virhe("d tyhjä") rear (rear + N )mod N elem D[rear] vapauta D[rear] items items Return elem Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2
Linkitetty lista Keskusmuisti (RM) Linkitetty lista Keskusmuisti (RM) Taulukko Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 3 Linkitetty lista Keskusmuisti (RM) Linkitetty lista Keskusmuisti (RM) 2 2 Obj. x Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 3
Linkitetty lista Keskusmuisti (RM) Linkitetty lista Keskusmuisti (RM) 2 Obj. x 3 2 Obj. x 3 2 viite seuraav. alkioon Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 3 Linkitetty lista 3 Keskusmuisti (RM) 2 Obj. x 4 Linkitetyn listan solmu (node) Javalla class Node { private Object element; private Node next; public Node() { this(null, null); } public Node(Object e, Node n) { element = e; next = n; } public void setelem(object newelem) { element = newelem; } public void setnext(node newnext) { next = newnext; } public Object getelem() { return element; } public Node getnext() {return next; } } Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
Linkitetty lista Tyypillinen yhteen suuntaan linkitetty lista: 2 n null head tail head: viite ensimmäiseen solmuun tail: viite viimeiseen solmuun head = tail = null, jos lista tyhjä kukin solmu omaa viitteen seuraavaan solmuun viimeisen solmun viite = null Linkitetty lista 2 n null head tail Lisäys linkitetyn listan L alkuun L.InsertFront(x) tmp new Node(x, head) if tail = null then tail tmp head tmp Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 Linkitetty lista 2 n null Linkitetty lista 2 n null head tail head tail Lisäys linkitetyn listan L loppuun L.InsertBack(x) tmp new Node(x, null) if head = null then head tmp else tail.setnext(tmp) tail tmp Poisto linkitetyn listan L alusta L.RemoveFront() if head = null then virhe("lista tyhjä") elem head.getelem() head head.getnext() if head = null then tail null return elem Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8
Linkitetty lista 2 n null head tail Poisto linkitetyn listan L lopusta L.RemoveBack() tmp.setnext(null) if head = null then elem tail.getelem() virhe("lista tyhjä") tail tmp if head = tail then return elem return L.RemoveFront() tmp head while tmp.getnext() tail do tmp tmp.getnext() Tietorakenteet, syksy 2007 9 Kaksiloppuisen jonon toteutusvaihtoehtoja Kuvatut linkitetyn listan lisäys/poisto-operaatiot toteuttavat kaksiloppuisen jonon tilavaatimus: O(n), missä n jonon alkioiden lukumäärä (vrt. taulukkototeutus: O(N)) tila skaalautuu suoraan solmujen lukumärään suhteen taulukkototeutuksen operaatioiden suoritusaika Θ(), mutta......linkitetyn listan metodi RemoveBack() eli PopBack() oli O(n) toiseksi viimeisen solmun haku! Tietorakenteet, syksy 2007 20 Kahteen suuntaan linkitetty lista Myös viimeisen solmun poisto onnistuu ajassa Θ(), jos käytetään kahteen suuntaan linkitettyä listaa null 2 n head tail null kukin solmu omaa viitteen sekä seuraavaan että edeltävään solmuun toteutus samankaltainen kuin yhteen suuntaan linkitetyllä listalla Kahteen suuntaan linkitetty lista null 2 n head DL.InsertFront(x) tmp new Node(x, null, head) if tail = null then tail tmp else head.setprev(tmp) head tmp tail null Tietorakenteet, syksy 2007 2 Tietorakenteet, syksy 2007 22
Kahteen suuntaan linkitetty lista null 2 n null Kahteen suuntaan linkitetty lista null 2 n null head tail head tail DL.RemoveFront() if head = null then virhe("lista tyhjä") elem head.getelem() head head.getnext() if head = null then tail null else head.setprev(null) return elem Tietorakenteet, syksy 2007 23 Lisäys/poisto kaksoislinkitetyn listan lopussa onnistuu symmetrisesti head tail, Prev Next Tietorakenteet, syksy 2007 24
Sekvenssi Sekvenssi: kokoelma peräkkäisiä alkioita (lineaarinen järjestys) Riku Tero Esim. pino, jono ja kaksiloppuinen jono ovat sekvenssin erikoistapauksia sekvenssejä, jotka kohdistavat operaationsa ensimmäiseen/viimeiseen alkioon alkiolla on yksikäsitteinen seuraaja- ja edeltäjäalkio (paitsi alussa/lopussa) Sekvenssi Yleinen sekvenssi: kullakin alkiolla on aste (rank, järjestysnumero ) Riku Tero aste: 0 aste: aste: 2 aste: 3 aste: 4 ensimmäisen alkion aste on 0, toisen, jne. aste alkion indeksi sekvenssissä Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2 Yleinen sekvenssi kullakin alkiolla on paikka abstrakti sijoituspaikan käsite abstraktina tietotyyppinä: alkio on datajäsen, ja metodi element() palauttaa alkion vrt. esim. solmu, johon alkio on tallennettu paikka a paikka b paikka v paikka y paikka c Riku Tero aste: 0 aste: aste: 2 aste: 3 aste: 4 Yleinen sekvenssi operaatioita voidaan suorittaa sekvenssin mihin tahansa kohtaan kohdan määritys: joko alkion aste, tai sekvenssissä olevan alkion paikka huom: luentomonisteessa käsitellään aluksi erillisinä tapauksina: astetta soveltava sekvenssi (asteet, ei paikkoja) paikkasekvenssi (paikat, ei asteita) Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
Sekvenssin metodit ElemtRank(r): palauttaa asteen r omaavan alkion virhe, jos r ei kuulu väliin 0...n, kun alkioita n kpl paikka b aste: 0 paikka a aste: paikka y Riku aste: 2 ElemtRank(), palauttaa alkion Sekvenssin metodit ReplaceElemtRank(r,x): korvaa asteen r omaavan alkion alkiolla x, ja palauttaa korvatun alkion virhe, jos r ei kuulu väliin 0...n paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a aste: paikka y Riku aste: 2 paikka y Riku aste: 2 paikka c Tero aste: 3 paikka c Tero aste: 3 ReplaceElemtRank(, ), palauttaa alkion Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 Sekvenssin metodit InsertElemtRank(r,x): lisää alkion x sekvenssiin r-asteiseksi alkioksi virhe, jos r ei kuulu väliin 0...n palauttaa uuden alkion paikan (luentomoniste: ei palauta mitään, koska sovelsi vain astetta) paikka b aste: 0 paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a aste: paikka p nu aste: paikka y Riku aste: 2 paikka y Riku aste: 2 paikka a aste: 2 InsertElemtRank(3,Tero), palauttaa paikan c paikka c Tero aste: 3 paikka y Riku aste: 3 InsertElemtRank(,nu), palauttaa paikan p paikka c Tero aste: 4 Tietorakenteet, syksy 2007 7 Sekvenssin metodit RemoveElemtRank(r): poistaa asteen r omaavan alkion ja palauttaa sen virhe, jos r ei kuulu väliin 0...n myös poistetun alkion paikka häviää paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a aste: paikka y Riku aste: 2 paikka c Tero aste: 2 paikka c Tero aste: 3 RemoveElemtRank(2) palauttaa alkion Riku Tietorakenteet, syksy 2007 8
Sekvenssin metodit paikka b paikka a aste: 0 aste: paikka h Hanna aste: 2 paikka y Riku aste: 3 paikka c Tero aste: 4 Size(): palauttaa sekvenssin alkioiden lukumäärän IsEmpty(): palautusarvo true/false kertoo, onko sekvenssi tyhjä Sekvenssin metodit Replace(p,x): korvaa paikassa p olevan alkion alkiolla x, ja palauttaa korvatun alkion paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a aste: paikka y Riku aste: 2 paikka y Topi aste: 2 paikka c Tero aste: 3 paikka c Tero aste: 3 Replace(y, Topi), palauttaa alkion Riku First()/Last(): palauttaa sekvenssin ensimmäisen/viimeisen alkion paikan Before(p)/fter(p): palauttaa paikkaa p edeltävän/seuraavan paikan sekvenssissä Tietorakenteet, syksy 2007 9 Tietorakenteet, syksy 2007 0 Sekvenssin metodit Swap(p,q): vaihtaa paikkojen p ja q alkiot keskenään paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a Tero aste: paikka y Riku aste: 2 paikka y Riku aste: 2 paikka c Tero aste: 3 paikka c aste: 3 Swap(a,c) Sekvenssin metodit InsertFirst(x)/InsertLast(x): lisää alkion x sekvenssin ensimmäiseksi/viimeiseksi alkioksi ja palauttaa alkion paikan paikka a aste: 0 paikka b aste: 0 paikka b aste: 0 paikka y Riku aste: paikka a aste: paikka a aste: InsertFirst(), palauttaa paikan b paikka y Riku aste: 2 paikka y Riku aste: 2 InsertLast(Tero), palauttaa paikan d paikka d Tero aste: 3 Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2
Sekvenssin metodit InsertBefore(p,x)/Insertfter(p,x): lisää alkion x paikassa p olevan alkion eteen/perään ja palauttaa uuden alkion paikan paikka b aste: 0 paikka b aste: 0 paikka b aste: 0 paikka a aste: paikka a aste: paikka a aste: paikka c Tero aste: 2 paikka y Riku aste: 2 paikka h Hanna aste: 2 InserBefore(c, Riku) palauttaa paikan y paikka c Tero aste: 3 paikka y Riku aste: 3 Insertfter(a, Hanna) palauttaa paikan h paikka c Tero aste: 4 Sekvenssin metodit Remove(p): poistaa paikassa p olevan alkion ja palauttaa sen paikka b aste: 0 paikka a aste: paikka y Riku aste: 2 paikka a paikka y paikka c aste: 0 Riku aste: Tero aste: 2 paikka c Tero aste: 3 Remove(b), palauttaa alkion trank(r): palauttaa r-asteisen alkion paikan RankOf(p): palauttaa paikassa p olevan alkion asteen Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4 Sekvenssin toteutuksesta Sekvenssi on luontevaa toteuttaa kaksoislinkitetyllä listalla paikka: viite alkiota vastaavaan solmuun Operaatioiden aikavaativuudet O(n), jos operaation sovelluskohta täytyy etsiä selaamalla listaa trank, RankOf, ElemtRank, ReplaceElemtRank, InsertElemtRank, RemoveElemtRank muut operaatiot: O() Tietorakenteet, syksy 2007 5 Sekvenssin toteutuksesta Sekvenssin toteutus taulukossa erilliset paikkatietueet paikka b aste: 0 paikka a aste: paikka h Hanna aste: 2 paikka y Riku aste: 3 0 2 3 4 5 6 7 8 9 paikka c Tero aste: 4 taulukossa viitteet paikkatietueisiin paikka säilyy samana, vaikka aste muuttuisi Tietorakenteet, syksy 2007 6
Sekvenssin toteutuksesta Lisäys/poisto taulukon keskellä: O(n) paikka b aste: 0 paikka a aste: paikka y Riku aste: 3 0 2 3 4 5 6 7 8 9 paikka b aste: 0 paikka a aste: paikka y Riku aste: 2 paikka c Tero aste: 4 paikka c Tero aste: 3 Sekvenssin toteutuksesta Seuraus: taulukossa operaatioiden Insertfter, InsertBefore, InsertElemtRank, RemoveElemt- Rank ja Remove aikavaatimus on O(n) Kaikki muut operaatiot O() käytetään rengasrakennetta (a la jono) kun lisäys/poisto alkuun/loppuun 0 2 3 4 5 6 7 8 9 Tietorakenteet, syksy 2007 7 Tietorakenteet, syksy 2007 8 Linkitetty lista vs. dynaaminen taulukko Dynaaminen taulukko (esim. Javan Vector) jos koon N taulukko täyttyy(n = N), varataan kokoa 2N oleva taulukko Linkitetty lista vs. dynaaminen taulukko jos n N/4, varataan kokoa N/2 oleva taulukko siirto uuteen taulukkoon: Θ(n) työtä voidaan osoittaa, että pahimmassakin tapauksessa keskimäärin O() per alkio Tietorakenteet, syksy 2007 9 siirto uuteen taulukkoon: Θ(n) työtä voidaan osoittaa, että pahimmassakin tapauksessa keskimäärin O() per alkio N/4 n N taulukon tilahukka O(n) Tietorakenteet, syksy 2007 20
Linkitetty lista vs. dynaaminen taulukko Linkitetty lista: kussakin solmussa tietoalkio (tai viite sellaiseen) ja lisäksi viite toiseen solmuun listan tilahukka on Θ(n) vrt. dynaaminen taulukko: O(n) kutakin lisättyä/poistettua alkiota kohden tehty tietoalkion ja viitteen asetus vrt. dynaamisessa taulukossa siirrettävien alkioiden lukumäärä verrannollinen lisättyjen/poistettujen alkioden määrään Linkitetty lista vs. dynaaminen taulukko Keskusmuisti (RM) Taulukko Tietorakenteet, syksy 2007 2 Tietorakenteet, syksy 2007 22 Linkitetty lista vs. dynaaminen taulukko Keskusmuisti (RM) Linkitetty lista vs. dynaaminen taulukko Yhtenäiselle taulukolle voi olla hankalampaa varata muistia Taulukon ja (kaksoislinkitetyn) listan keskeinen suoritusajan tradeoff: alkion haku indeksin perusteella: taulukossa O(), listassa O(n) lisäys/poisto keskellä: taulukossa O(n), listassa O() (jos lisäyskohta jo tiedetään) Tietorakenteet, syksy 2007 23 Tietorakenteet, syksy 2007 24
Tietoalkioiden hierarkia Pinot, jonot, yleisemmin sekvenssit: kokoelma peräkkäisiä alkioita (lineaarinen järjestys) Riku Tero Yleisempi tilanne: alkioiden hierarkia Tietoalkioiden hierarkia Kukin alkio (viite) talletettuna solmuun (node) vastaa paikan käsitettä solmu c Riku solmu b solmu a solmu d Tero solmu e Kahden solmun u ja v väliset suhteet hierarkiassa: Riku Tero Tietorakenteet, syksy 2007 Tietorakenteet, syksy 2007 2 Tietoalkioiden hierarkia solmu a Tietoalkioiden hierarkia solmu a solmu b solmu e solmu b solmu e solmu c Riku solmu d Tero u on solmun v vanhempi (parent) u on solmun v välitön edeltäjä (askelta ylempänä hierarkiassa) solmut u ja v yhdistetty kaarella ja u on v:n yläpuolella vanhemman sijaan joskus termi isä (father) solmu c Riku solmu d Tero u on solmun v lapsi (child) u on solmun v välitön seuraaja (askelta alempana hierarkiassa) solmut u ja v yhdistetty kaarella ja u on v:n alapuolella Tietorakenteet, syksy 2007 3 Tietorakenteet, syksy 2007 4
Tietoalkioiden hierarkia solmu a Tietoalkioiden hierarkia solmu a solmu b solmu e solmu b solmu e solmu c Riku solmu d Tero u on solmun v esivanhempi (ancestor) u = v tai u on solmun v vanhemman esivanhempi u on v tai jokin sitä edeltävä solmu kukin solmu v on itsensä esivanhempi! solmu c Riku solmu d Tero u on solmun v jälkeläinen (descendant) v on solmun u esivanhempi kukin solmu v on itsensä jälkeläinen! Tietorakenteet, syksy 2007 5 Tietorakenteet, syksy 2007 6 Puurakenteen määritelmä Puu T on sellainen solmujen joukko, jossa: on yksikäsitteinen juuri (root) r (tai puu tyhjä) ylimmän tason solmu kullakin solmulla on yksikäsitteinen vanhempi ainoa poikkeus: juuri ( kantaisä ) kukin solmu on juuren r jälkeläinen tai yhtäpitävästi: juuri r on kunkin solmun esivanhempi Jos puussa on n solmua, niin kaaria on? n Tietorakenteet, syksy 2007 7 Puurakenteen määritelmä Puu? Riku Tero ei: Terolla kaksi vanhempaa Puu? Riku Tero ei: sekä Rikulla että lla ei vanhempaa Tietorakenteet, syksy 2007 8