Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth.

Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth

Kurssin sisältö Kurssi perustuu oppikirjaan: Cormen, T. H. – Leiserson, C. E – Rivest, R. L – Stein, C.: ”Introduction to Algorithms”, 3. painos, MIT press (2009) Myös vanhemmat painokset (erityisesti 2. painos) oppikirjasta kelpaavat Samaisesta oppikirjasta luennoidaan myös kurssi: Tietorakenteet ja algoritmit II (aineopintotasoinen, keväällä 2013 periodilla 3) – jatkoa tälle kurssille Kirjaa on aikaisemmin käytetty oppikirjana myös kurssilla: Algoritmien suunnittelu ja analysointi (syventävä kurssi, syksyllä 2013 periodeilla 1 – 2) – luennoitsijana professori Olli Nevalainen Monet kurssilla käsiteltävistä asioista löytyvät edelleen tästä kirjasta.

Kurssin sisältö (jatkoa)
Sisällysluettelo Luentokalvoissa on käytetty samaa osa- ja lukunumerointia kuin oppikirjassa I Perusteet Algoritmien asema tietojenkäsittelyssä - mitä algoritmiikka tutkii? Algoritmiikan perusteet perusmenetelmät algoritmien analyysiä varten Funktioiden kasvunopeus algoritmien suorituskyvyn mittaaminen ”Hajota ja hallitse” -menettely tehtävän ratkaiseminen osittamalla se alkuperäisen kaltaisiin mutta pienempiin osaongelmiin II Lajittelualgoritmit Kekolajittelu lajittelun suorittaminen käyttämällä aputietorakenteena kekoa Pikalajittelu käytännössä tehokkaaksi osoittautunut rekursiivinen yleinen lajittelumenetelmä Lajittelu lineaarisessa ajassa lajittelun nopeuttaminen käyttämällä hyväksi ennakkotietoja syötteen ominaisuuksista Mediaanit ja järjestysstatistiikat lajittelua helpomman tehtävän – syötteen i. suurimman alkion etsiminen

Kurssin sisältö (jatkoa)
III Tietorakenteet Perustietorakenteet jono, pino ja lista sekä vaihtoehtoja niiden toteuttamiseksi Hajautustaulut esitellään tekniikoita hajautustaulun toteuttamiseksi ja -funktion valitsemiseksi Binääriset hakupuut toteutus, eri selausjärjestykset luennoidaan vasta kurssilla TRAK II, mutta kalvot esitetään TRAKLA-demonstraatioita varten. I Perusteet 1. Algoritmien asema tietojenkäsittelyssä Algoritmilla tarkoitetaan hyvin määriteltyä toimintosarjaa, joka muuntaa syötteen (lähtötiedot) tulosteeksi. Algoritmi ratkaisee jonkin reaalimaailman ongelman, ja ratkaisijana – eli algoritmin suorittajana – voi toimia joko ihminen tai (tieto)kone. Ongelma Algoritmi Syötteet Suorittaja Tuloste

1. Algoritmien asema tietojenkäsittelyssä
Algoritmeilta vaaditaan (yleensä) seuraavien kriteerien täyttämistä: ) Yleisyyskriteeri: algoritmia on pystyttävä soveltamaan kaikille niille syötteille, jotka täyttävät sille asetettavan alkuehdon 2) Deterministisyyskriteeri: kaikissa laskennan vaiheissa pitää olla yksikäsitteisesti tiedossa, miten suoritusta jatketaan  tästä kriteeristä joustetaan sovellettaessa ns. vapaajärjesteisiä eli ei-imperatiivisia algoritmeja (funktionaalinen ja logiikkaohjelmointi) ) Tuloksellisuuskriteeri: algoritmin on aina palautettava tulos, joka a) on oikeellinen ja b) saavutetaan äärellisen ajan kuluessa  tästä kriteeristä voidaan joustaa käytettäessä esimerkiksi heuristisia, likimääräis- tai todennäköisyysalgoritmeja, sillä toisinaan ei-optimaalinen, epätarkka tai jopa tietyllä riskillä virheellinenkin lopputulos saattaa kaikesta huolimatta olla tyhjää parempi

Algoritmiikka tutkii, miten tietokone saadaan yksinkertaisia käskyjä peräkkäin suorittamalla ratkaisemaan tehokkaasti reaalimaailman ongelmia. Tietämys algoritmiikasta helpottaa hyödyntämään aikaisemmin löydettyjä ratkaisuja jonkin tehtävän ratkaisemiseksi.  samankaltaiset alitehtävät, vaikkapa lajittelu, esiintyvät lukuisan eri ongelman ratkaisun vaiheina  kaikkea ei siis välttämättä tarvitse ratkaista aina itse alkutekijöistä lähtien! Vaikka valmiina saatavia algoritmeja on saatavilla paljon ja jopa valmiiksi ohjelmoituinakin, ei tämä kuitenkaan tee algoritmiikan osaamista vähemmän merkittäväksi tai suorastaan tarpeettomaksi, sillä  sopivan algoritmin valitseminen useasta ehdokkaasta pelkästään ”arpomalla” voi johtaa huonolla tuurilla varsin tehottomaan lopputulokseen  ohjelmoijan pitää pystyä ymmärtämään, miksi jokin tietty algoritmi sopii hänen tarkoituksiinsa paremmin kuin jokin toinen saman tehtävän ratkaiseva Lisäksi kannattaa huomioida, että algoritmit ovat ohjelmointikielistä ja pienin varauksin myös tietokoneista riippumattomia  vaikka tietokoneet tehostuvat ja ohjelmointiympäristöt kehittyvät tämän tästä, algoritmit eivät kuitenkaan jää tämän kehityksen jalkoihin, vaan niiden käyttökelpoisuutta kuvaavat ominaisuudet säilyvät muutosten yli  algoritmiikan opiskelulla saavutetut tiedot eivät siis käy vanhanaikaisiksi!

Suomennettu sitaatti D. Harelin kirjasta The spirit of Computing (1992): ”Algoritmiikka on enemmän kuin vain yksi tietojenkäsittelytieteen osa-alue. Se on tietojenkäsittelytieteen ydin, ja sen voidaan rehellisesti sanoa olevan relevantti useimpien tieteiden, liiketoiminnan ja teknologian kanssa.” Tämän kurssin tärkeimpinä tavoitteina ovat siten: Esitellä vuosien mittaan hyviksi osoittautuneita ideoita ja menetelmiä tiettyjen, käytännössä usein esiintyvien tehtävien ratkaisemisessa. Antaa opiskelijalle riittävät perustiedot, mitä tarvitaan algoritmien tehokkuuden analysoimiseksi, jotta hän pystyisi punnitsemaan tarkastelemansa menetelmän hyvyyttä ja soveltuvuutta jonkin tietyn (ali)ongelman ratkaisemiseksi. Tutustutaan seuraavaksi kahden vaihtoehtoisen menetelmän ominaisuuksiin arvon etsimiseksi järjestetystä vektorista: Syöte: yhteensä n alkiota (n > 0) sisältävä järjestetty vektori A, joka on indeksoitu välille [1..n] sekä etsittävä arvo x Tuloste: alkion x sijaintipaikka (indeksi) vektorissa A. Ellei x:ää esiinny kyseisessä vektorissa, palautetaan arvo 0 merkkinä epäonnistuneesta hausta. Oletus: jos x esiintyy vektorissa A useita kertoja peräkkäin (x:llä on duplikaatteja), voidaan palauttaa mikä tahansa x:n esiintymiskohdista

Esimerkkisyöte: 11-paikkainen kokonaislukuvektori A, josta etsitään alkiota 16 A = Ratkaistaan tehtävä ensiksi käyttämällä ns. lineaarihakua: Lineaarihaku(A, n, x): Selaa vektorin A alkioita vuoron perään aloittamalla paikasta Merkitään kulloistakin tarkastelukohtaa muuttujalla i Jos A[i] = x jollain i:n arvolla, palauta kutsujalle arvo i ja poistu Jos yhtään alkiota ei ole enää tutkimatta, eli kaikilla i:n arvoilla , 2, …, n A[i] oli erisuuri kuin x, palauta arvo 0 ja poistu. Esimerkissämme vektoriin joudutaan vektoriin kohdistamaan 7 hakua, kunnes etsitty alkio 16 löytyy  alkiota haetaan järjestyksessä paikoista 1, 2, 3, 4, 5, 6 ja 7. Analyysi: Parhaassa tapauksessa joudutaan tutkimaan ainoastaan yksi alkio, A[1], jos sieltä löytyy heti etsitty x Pahimmassa tapauksessa x esiintyy A:ssa ensi kerran vasta indeksissä n, tai sitten x:ää ei löydy lainkaan vektorista A  kaikki alkiot eli n kappaletta joudutaan tutkimaan. 1 4 5 8 11 15 16 22 25 31 34

… ja sitten käyttämällä puolitushakua: Puolitushaku(A, n, x): alaraja := 1; yläraja := n; 2. keskikohta := A[(alaraja + yläraja)/2]; Tutki paikassa A[keskikohta] oleva alkio Jos x = A[keskikohta], lopeta haku ja palauta indeksi keskikohta Jos x < A[keskikohta]  yläraja := keskikohta – 1 (* x ei keskikohdasta oikealle *) muutoin alaraja := keskikohta + 1 (* x ei keskikohdasta vasemmalle *) Jos alaraja  yläraja  palaa takaisin riville 2 /* Vielä mahdollisia paikkoja x:lle */ muutoin lopeta haku ja palauta indeksi 0 /* Haku epäonnistui. */ Esimerkissämme alkiota 16 etsittäisiin järjestyksessä paikoista 6, 9, 8 ja  tarvitaan ainoastaan 4 hakua Analyysi: Parhaassa tapauksessa joudutaan nytkin tutkimaan ainoastaan yksi alkio, A[keskikohta], jos se on etsityn x:n sijaintipaikka Pahimmassa tapauksessa x löytyy A:sta ensi kerran vasta silloin, kun hakualue on puristunut yhden pituiseksi (alaraja = yläraja), tai sitten x:ää ei löydy lainkaan vektorista A  alkioita x joudutaan etsimään tarkalleen niin kauan kuin rivin ehto toteutuu. Tämä on mahdollista enintään log2n kappaletta. Esimerkkitapauksemme oli siten pahin tapaus (!) tarkastellulle syöteaineistolle. MUTTA: puolitushausta ei ole iloa, jos syöte ei ole lajiteltu! 1 4 5 8 11 15 16 22 25 31 34

Algoritmin tehokkuutta mitataan useimmiten sillä, miten paljon se vaatii aikaa ja/tai muistitilaa eli resursseja suoritusta varten. Jotta algoritmin analyysi voidaan pitää yksinkertaisena, sovitaan, että jokainen suoritettava perusoperaatio vie aikaa yhden aikayksikön. Algoritmin resurssivaativuus eli kompleksisuus ilmoitetaan yleensä ainoastaan kuvaamalla sen suuruus- eli kertaluokka ilman absoluuttisia mittauksia, jotka tietystikin vaihtelevat koneittain. Tähän tarkoitukseen käytetään joko - tai -notaatiota (theta / (iso) ordo). Lineaarihaun aikavaativuus on kertaluokkaa (n). Puolitushaulla se on sen sijaan kertaluokkaa (log2n). Seuraava taulukko esittää funktioiden y = log2x ja lg x arvon riippuvuutta x:stä (Huom! Tällä kurssilla log x = log10x ja lg x = log2x): Taulukosta voi selvästi havaita, että logaritmit reagoivat hyvin hitaasti syötteen koon n kasvuun.  mitä pidempi järjestetty vektori, sitä halvemmaksi puolitushaku pitkän päälle tulee! Tosin myös järjestetyn vektorin lineaarihakua voidaan tehostaa, mutta pahin tapaus silti (n). n 10 100 1 000 10 000 log n 1 2 3 4 5 6 7 lg n  3.3  6.6  10.0  13.3  16.6  19.9  23.3

Edellä tutustuttiin kahteen vaihtoehtoiseen hakumenetelmään. Nyt vertaillaan puolestaan kahta yleiskäyttöistä lajittelumenetelmää. Seuraavassa oletetaan, että ) Syötteenä annetaan n (n > 0) alkiota sisältävä vektori, joka sisältää alkiot A[1], A[2], … A[n]  indeksointi aloitetaan ykkösestä ) Tulosteeksi halutaan täsmälleen syötteen alkuperäiset alkiot, mutta lajiteltuina ei-vähenevään suuruusjärjestykseen, eli lajittelun valmistuttua A[1]  A[2]  …  A[n]. Tarkastellaan ensiksi lisäyslajittelua, joka toimii seuraavasti: ) Kierroslaskuri i saa silmukassa vuoron perään arvot 2, 3, …, n. Kierroksen i alkaessa A[1..i–1] on jo järjestetty ) Kopioidaan alkio A[i] muuttujaan j. Oletetaan, että siitä tulee järjestetyn osan k pienin alkio ) Viedään j oikealle paikalleen. Kuitenkin ennen asetusta A[k] := j joudutaan kaikki alkiot väliltä A[k..i–1] siirtämään vähenevässä indeksijärjestyksessä yhdellä positiolla oikealle päin, ettei kyseisellä indeksialueella olevia arvoa menetetä kirjoittamalla niiden päälle ) Vaiheita 1–3 toistetaan, kunnes viimeinenkin alkio on viety oikealle paikalleen  kun i kasvaa arvoon n + 1, on vektori valmiiksi lajiteltu.

Selvitetään luennolla lisäyslajittelun etenemistä numeerisella esimerkillä, jossa edeltäneiden lineaari- ja puolitushakuesimerkkien vektorin A alkiot on sekoitettu nyt mielivaltaiseen järjestykseen. Alempana nähtävissä silmukan kierrokset i:n arvoilla 2–7. A = i = i = 3 i = 4 i = 5 i = i = 7 31 22 15 34 11 1 16 4 25 5 8 22 31 15 34 11 1 16 4 25 5 8 15 22 31 34 11 1 16 4 25 5 8 15 22 31 34 11 1 16 4 25 5 8 11 15 22 31 34 1 16 4 25 5 8 1 11 15 22 31 34 16 4 25 5 8

Seuraavassa lisäyslajittelun eteneminen pääsilmukan viimeisillä kierroksilla (i:n arvot 8–11): i = i = 9 i = 10 i = 11  i = 12, algoritmin suoritus päättyy, ja lopputuloksena saadaan A lajiteltuna: Esimerkissä järjestetyt alkiot on värjätty punaisella, tutkittava alkio keltaisella ja vielä järjestämättömät valkoisella. Sininen nuoli kuvaa tutkittavan alkion siirtoa ja punainen nuoli alkupään alkioiden siirtoa yhdellä eteenpäin oikeasta reunasta aloittaen. Havaitaan, että järjestetyn osan pidetessä vielä järjestämättömien, mutta alkuosaan kuuluvien siirtomatkat ja siirroista aiheutuva järjestetyn osan kopiointityö alkavat lisääntyä melkoisesti! 1 11 15 16 22 31 34 4 25 5 8 1 4 11 15 16 22 31 34 25 5 8 1 4 11 15 16 22 25 31 34 5 8 1 4 5 11 15 16 22 25 31 34 8 1 4 5 8 11 15 16 22 25 31 34

Tarkastellaan seuraavaksi vaihtoehtoista lajittelualgoritmia, limityslajittelua, joka toimii seuraavasti (jos alla olevassa algoritmissa alku  loppu, ei tehdä mitään): Syöte: Vektorin A osavektorin A[alku], …, A[loppu] alkiot. Aluksi alku = 1 ja loppu = n. JOS alku < loppu /* Vieläkö tarkasteltava osavektori voidaan osittaa (likimain) kahtia? */ 1) Laske taulukon keskikohta, joka on (alku + loppu)/2 ) Lajittele rekursiivisesti alkuosa eli alkiot A[alku], … A[keskikohta] ) Lajittele rekursiivisesti loppuosa eli alkiot A[keskikohta + 1], … A[loppu] ) Limitä rekursiivisesti lajitellut vektorinpuoliskot lajitelluksi osavektoriksi. Katsotaan seuraavaksi, miten limityslajittelu etenee samalle syöteaineistolle kuin edellä lisäyslajittelulla käsitellylle: 1) Alkutilanne:  keskikohta (1 + 11) / 2 = 6  halkaisu osavektoreiksi A[1..6] ja A[7..11] ) Tilanne 1. tason halkaisun jälkeen: 31 22 15 34 11 1 16 4 25 5 8 31 22 15 34 11 1 16 4 25 5 8

 keskikohdat = (1 + 6) / 2 = 3 ja (7 + 11) / 2 = 9   halkaisu osavektoreiksi A[1..3], A[4..5], A[7..9] ja A[10..11] 3) Tilanne 2. tason halkaisujen jälkeen:  saadaan neljä osavektoria A[1..3], A[4..6], A[7..9] ja A[10..11], jotka halkaistaan edelleen paikoista 2, 5, 8 ja  halkaisu kahdeksaksi osavektoriksi A[1..2], A[3..3], A[4..5], A[6..6], A[7..8], A[9..9], A[10..10] ja A[11..11] 4) Tilanne 3. tason halkaisujen jälkeen:  ainoastaan osavektoreiden 1, 3, ja 5 ositusta voidaan jatkaa  muut eli jo yhden mittaisiksi puristuneet osavektorit jäävät toistaiseksi ”lepäämään” ja odottamaan, että vielä halkaisemattomat osavektorit on käsitelty loppuun asti 31 22 15 34 11 1 16 4 25 5 8 31 22 15 34 11 1 16 4 25 5 8

5) Tilanne 4. tason halkaisujen jälkeen: (vain halkaisuun osallistuneet osavektorit esitetty) (15) (1) (25) (5) (8) Nyt on halkaisut suoritettu loppuun asti, joten rekursio alkaa palautua  lähdetään kokoamaan ratkaisua limittämällä kullakin tasolla olevat osavektorit pareittain ei-vähenevään suuruusjärjestykseen  limityksessä tulokseen viedään aina tarkasteltavien osavektoreiden pienin alkio tarjolla olevista  parin muodostavat aina ne kaksi ositetta, jotka ovat muodostuneet rekursiossa yhden ja saman aktivaation aikana (algoritmin kohdat 2 ja 3)  tasolla 4 järjestetään siis pareittain osavektorit 1 – 2, 4 – 5 ja 7 – 8  saadaan aikaan seuraavat, kahden mittaiset järjestetyt osavektorit (kaikissa kolmessa parissa vaihtuu tällä kertaa järjestys alkuperäisestä):  palataan rekursiossa yksi taso ylöspäin tasolle 3, jossa viisi yhden mittaista osavektoria odottaa limitystä 31 22 34 11 16 4 22 31 11 34 4 16

6) Tilanne ennen tason 3 limitystä:  limitetään pareittain tason osavektorit 1 – 2, 3 – 4, 5 – 6 sekä 7 –  saadaan tulokseksi 4 järjestettyä osavektoria, joiden pituus on 2 tai  rekursion taso 3 päättyy, ja siirrytään takaisin tasolle 2 limitysvaiheeseen 7) Tilanne ennen tason 2 limitystä:  limitetään pareittain tason osavektorit 1 – 2 sekä 3 – 4  saadaan tulokseksi 2 järjestettyä osavektoria, joiden pituudet ovat 6 ja 5  rekursion taso 2 päättyy, ja palataan ylimmälle rekursiotasolle: alkuperäisen kutsun limityskomentoon 22 31 15 11 34 1 4 16 25 5 8 15 22 31 1 11 34 4 16 25 5 8

8) Tilanne ennen viimeistä eli tason 1 limitystä:  limitetään pareittain jäljellä olevat osavektorit 1 –  saadaan tulokseksi alkuperäinen vektori järjestettynä ei-vähenevään järjestykseen  koko limityslajittelualgoritmin suoritus päättyy 9) Lopputilanne: Muutamia ensi havaintoja limityslajittelun etenemisestä (tarkempi analyysi myöhemmin): ) Halkaisuoperaatio on itse asiassa erittäin yksinkertainen: siihen kuuluu ainoastaan uuden osituskohdan määrääminen  mitään muita toimenpiteitä ei tapahdu ) Kaikki alkiot käydään läpi ainoastaan niin monta kertaa, miten monelle rekursiotasolle ne osallistuvat ) Syötteen koon kaksinkertaistuminen tuottaa vain yhden rekursiotason lisää!  alkioparien vertailujen määrä kasvaa hitaasti verrattuna lisäyslajitteluun 1 11 15 22 31 34 4 5 8 16 25 1 4 5 8 11 15 16 22 25 31 34

Seuraavassa esitetään vielä äskeisen limityslajitteluesimerkin kutsupino, jotta nähtäisiin, miten suoritus etenee järjestyksessä (edellä näytettiin, mitä tapahtuu eri tasoilla): 1. Limityslajittelu([31, 22, 15, 34, 11, 1, 16, 4, 25, 5, 8]), alku = 1, loppu = 11 2. Limityslajittelu([31, 22, 15, 34, 11, 1]), alku = 1, loppu = 6 3. Limityslajittelu([31, 22, 15]), alku = 1, loppu = 3 4. Limityslajittelu([31, 22]), alku = 1, loppu = 2 5. Limityslajittelu([31]) X (alku = loppu = 1: kutsu päättyy) 6. Limityslajittelu([22]) X (alku = loppu = 2: kutsu päättyy) Limitä([31], [22])  osavektori A[1..2] := [22, 31] 7. Limityslajittelu([15]) X (alku = loppu = 3: kutsu päättyy) Limitä([22, 31], [15])  osavektori A[1..3] := [15, 22, 31] 8. Limityslajittelu([34, 11, 1]), alku = 4, loppu = 6 9. Limityslajittelu([34, 11]), alku = 4, loppu = 5 10. Limityslajittelu([34]) X (alku = loppu = 4: kutsu päättyy) 11. Limityslajittelu([11]) X (alku = loppu = 5: kutsu päättyy) Limitä([34], [11])  osavektori A[4..5] := [11, 34] 12. Limityslajittelu([1]) X (alku = loppu = 6: kutsu päättyy) Limitä([34, 11], [1])  osavektori A[4..6] := [1, 11, 34] Limitä([15, 22, 31], [1, 11, 34])  osavektori A[1..6] := [1, 11, 15, 22, 31, 34] 13. Limityslajittelu([16, 4, 25, 5, 8]), alku = 7, loppu = 11) 14. Limityslajittelu([16, 4, 25]), alku = 7, loppu = 9 15. Limityslajittelu([16, 4]), alku = 7, loppu = 8 16. Limityslajittelu([16]) X (alku = loppu = 7: kutsu päättyy) 17. Limityslajittelu([4]) X (alku = loppu = 8: kutsu päättyy) Limitä([16, 4])  osavektori A[7..8] := [4, 16] 18. Limityslajittelu([25]) X (alku = loppu = 9: kutsu päättyy) Limitä([4, 16], [25])  osavektori A[7..9] := [4, 16, 25] 19. Limityslajittelu([5, 8], alku = 10, loppu = 11 20. Limityslajittelu([5]) X (alku = loppu = 10: kutsu päättyy) 21. Limityslajittelu([8]) X (alku = loppu = 11: kutsu päättyy) Limitä([5], [8])  osavektori A[10..11] := [5, 8] Limitä([4, 16, 25], [5, 8])  osavektori A[7..11] := [4, 5, 8, 16, 25] Limitä[1, 11, 15, 22, 31, 34], [4, 5, 8, 16, 25])  vektori A[1..11] = [1, 4, 5, 8, 11, 15, 16, 22, 25, 31, 34]  tehtävä valmis

Aikavaativuuden kertaluokka
1. Algoritmien asema tietojenkäsittelyssä Seuraavassa on taulukko, joka esittää muutamien käytännön lajittelumenetelmien toteutuneita suoritusaikoja, kun kone pystyy laskemaan miljardi alkeisoperaatiota sekunnissa Taulukkoon ei ole merkitty aikakompleksisuuteen vaikuttavia korkeinta termiä alempiasteisia termejä Tästä syystä esimerkiksi aikavaativuudeltaan samaa kertaluokkaa olevat limitys- ja pikalajittelu eroavat suoritusajoiltaan: pikalajittelu osoittautuu tehokkaammaksi  selitys: pienemmät kertoimet alempiasteisilla termeillä kuin limityslajittelussa Taulukosta on helposti pääteltävissä, että jo :n kokoisella syötteellä lisäyslajittelu on tuntuvasti hitaampi kuin muut menetelmät, mutta syötteen koon ollessa se on jo kelvoton menetelmä  ei ole siis yhdentekevää, mikä lajittelumenetelmä kannattaa valita pitkille syötteille!  lyhyillä syötteillä menetelmän valinnalla on vähemmän merkitystä. Lajittelumenetelmä Aikavaativuuden kertaluokka n = n = Lisäyslajittelu (n2) s lähes 8 tuntia Limityslajittelu (nlog2n) 0.062 s 6.797 s Pikalajittelu 0.031 s 3.047 s Laskentalajittelu (n) 0.015 s 1.734 s

Algoritmin suoritusaikaa kuvaava lauseke antaa verrattain hyvän ennakkokäsityksen siitä, miten tehokkaan tarkasteltavan algoritmin voi olettaa olevan sovellettavaksi.  käytännön tehokkuus tosin paljastuu parhaiten lopulta vasta suorittamalla algoritmia – isot vakio- ja alempiasteisten termien kertoimet voivat tuntua käytännön suoritusajassa – mutta huono teoreettinen suoritusaika ei lupaa hyvää käytännön kannalta Kaikki taulukossa esitetyt lajittelumenetelmät ovat aikavaativuudeltaan polynomiaalisia, mikä tarkoittaa sitä, että suoritusajan korkeinta astetta oleva termi on enintään jokin syötteen koon potenssi k, eli suoritusaika on tällöin (nk), missä k on vakio. On kuitenkin olemassa myös sellaisia ongelmia, joita ei ole mahdollista ratkaista polynomiaalisessa ajassa, vaan niiden ratkaisemiseen kuluva aika on eksponentiaalinen. Tällöin syötteen kokoa kuvaava muuttuja n esiintyy suoritusaikalausekkeen eksponentissa, eli lauseke on muotoa T(n) = kn, missä k > 1, n > 0 (merkintä T(n) tarkoittaa kooltaan n olevan syötteen ratkaisemiseksi tarvittavaa aikaa).  muun muassa Hanoin tornit on esimerkki algoritmista, jonka aikakompleksisuus on eksponentiaalinen, ja sitä kuvaa lauseke T(n) = 2n.  mikäli oletetaan, että n:n kokoinen tehtävä vaatii tasan 2n alkeisoperaatiota, ja kone laskee miljardi ( ) alkeisoperaatiota sekunnissa voidaan todeta, että n = 20  T(20) = 220 = alkeisoperaatiota  aikaa tarvitaan s n = 40  T(40) = 240 = alkeisoperaatiota  aikaa tarvitaan  s  18 min 20 s n = 60  T(60) = 260 = alkeisoperaatiota  aikaa tarvitaan  s  36 v 7 kk Koneen tehon kymmenkertaistuminenkaan ei juuri lohduta, jos n = 60 ja T(n) = 2n … !

Eksponentiaalisia ongelmia voidaan pitää käytännössä kelvottomina. Tähän ryhmään kuuluvat lisäksi muun muassa seuraavat ongelmat: Graafin väritys: voidaanko graafi värittää k värillä siten, että sen jokaisesta pisteestä lähtevät viivat ovat erivärisiä? Hamiltonin sykli: löytyykö graafista polkua siten, että sitä pitkin kuljettaessa vieraillaan graafin jokaisessa pisteessä tarkalleen kerran ja viimeisestä pisteestä palataan vielä takaisin lähtöpaikkaan? Kauppamatkustajan ongelma: löytyykö graafista Hamiltonin sykliä, jonka pituus on enintään ennalta asetetun ylärajan k suuruinen, kun graafin jokaiseen viivaan liittyy sen päätepisteiden etäisyyttä paino?

Algoritmien esittämisestä tällä kurssilla: 1) Aluksi esitetään sanallinen kuvaus siitä, että Millaisesta ongelmasta on kyse Miten algoritmi etsii ratkaisua tarkasteltavaan ongelmaan Mitä annetaan syötteeksi ja mitä tulostetaan Mitä erityisiä merkintöjä käytetään algoritmin kuvaamiseksi 2) Algoritmista esitetään pseudokielinen ohjelma Käytetty pseudokoodi muistuttaa melko lailla kursseilla JIT1 ja JIT2 käytettyä Käskysulkuja, kuten myöskään ehto- ja toistorakenteiden lopetinsanoja ei käytetä, vaan ne on korvattu sisennyksillä (poikkeus: REPEAT-UNTIL), ellei se ole välttämätöntä selvyyden kannalta (esimerkiksi ehdon tai toiston vaikutusalueen ollessa hyvin pitkä) 3) Esitetään algoritmin toimintaa havainnollistavia esimerkkejä 4) Todetaan algoritmin oikeellisuus 5) Analysoidaan algoritmin vaatima suoritusaika

2. Algoritmiikan perusteet
2.1 Algoritmien analysointi Algoritmia analysoitaessa pyritään arvioimaan sen resurssien tarvetta. Tarkasteltavana resurssina on useimmiten aika, mutta myös sen muistinkulutusta voidaan mitata. Näitä harvemmin voi tarkasteltavana resurssina olla myös jokin muu, kuten laitteistovaatimukset (tietoliikenteen tarpeisiin) yms. Tällä kurssilla keskitytään lähestulkoon ainoastaan algoritmin ajankäytön analysointiin. Tätä merkitään termillä T(n), missä n edustaa syötteen kokoa, joka voi tarkoittaa esimerkiksi 1) käsiteltävien alkioiden lukumäärää (listan, taulukon tai muun tietorakenteen koko) 2) tietokantaan tallennettujen tietueiden lukumäärä (esimerkiksi B-puiden yhteydessä) 3) pisteiden ja kaarten määrää graafialgoritmeissa (molemmat arvot esitetään parina) Miten arvioida algoritmien suoritusaikaa? 1) lasketaan ohjelman ns. alkeisaskeleiden eli yksinkertaisten operaatioiden kokonaismäärä 2) analyysissä oletetaan, että jokaisen samaa tyyppiä olevan alkeisaskeleen suorituskustannus on vakio (esimerkiksi minkä tahansa alkion välinen vertailu, kahden luvun välinen aritmeettinen operaatio jne.) 3) useimmiten turvaudutaan yksistään algoritmin pahimman tapauksen analysointiin  ainakaan tätä kauemmin ei algoritmin suoritus voi teoriassa kestää! 4) tällä kurssilla ei kiinnitetä huomiota algoritmien empiiriseen testaamiseen!

2.1 Algoritmien analysointi
Ennen analysointiin ryhtymistä esitellään vielä muutamia kurssilla käytettävään pseudokoodiin liittyviä oletuksia: 1) käskysulkuja eikä ehto- ja toistolauseiden lopettavia sanoja ei käytetä, ellei se ole esityksen selvyyden kannalta välttämätöntä (poikkeus: REPEAT-UNTIL); muutoin käytetään pelkkiä sisennyksiä 2) kommentti merkitään merkkiparilla /* */, ja se voi jatkua rivinvaihdonkin ylitse 3) taulukoiden indeksointi alkaa aina ykkösestä 4) kaikki käytetyt muuttujat ovat tällä kurssilla paikallisia. Sen sijaan jatko-osassa käytetään graafialgoritmeissa tapahtuman aikaleiman osoittamiseksi globaalia muuttujaa. 5) taulukosta A[1..n] voidaan valita osataulukko A[i..j], missä 1  i, j  n 6) muuttujien tunnukset esitetään kursiivilla 7) FOR-silmukan laskuria saa käyttää silmukan jo päätyttyäkin. Tällöin oletetaan, että laskurin silmukan jälkeinen arvo on sama, jolla toistoa ei enää jatkettu (yhden askeleen verran yli maksimin tai alle minimin) 8) on käytettävissä funktio pituus(x), joka palauttaa argumenttina annettavan vektorin pituuden, eli vektorin pituustietoa ei tarvitse välttämättä välittää syötteenä

9) asetusoperaattorina käytetään merkintää ”:=” 10) merkintä nil tarkoittaa tyhjää osoitinta linkitetyissä rakenteissa 11) loogisia lausekkeita lasketaan vasemmalta oikealle ja sen arvon määräämiseksi käytetään ns. oikosulkuevaluaatiota  jos lausekkeen totuusarvo käy jo ilmi, se kiinnitetään heti, kun tämä on mahdollista (vaikkei lauseketta olekaan käsitelty vielä loppuun asti)  esimerkki: IF x  nil AND x.arvo >  jos x on tyhjä osoitin, ei oikeanpuoleista ehtoa mennä enää testaamaan, joten lauseke ei johda ajonaikaiseen virheeseen  vältytään usein sisäkkäisten ehtolauseiden kirjoittamiselta, jottei määrittelemätöntä arvoa käytäisi testaamassa 12) algoritmeissa esiintyvät pseudokielen varatut sanat (IF, FOR jne.) kirjoitetaan isolla ja ne myös lihavoidaan 13) samoin algoritmien nimet on kirjoitettu isolla 14) jos samalla algoritmin rivillä esiintyy useita käskyjä, niiden erottimena toimii puolipiste ”;” 15) syötteen kokoa (usein sama kuin alkioiden lukumäärä) merkitään tunnuksella n

Aloitetaan algoritmien analysointi lähtemällä liikkeelle lisäyslajittelusta, jota käsiteltiin jo edellä sanallisen kuvauksen ja esimerkin avulla kalvopaketin sivuilla 11 – 13. Lisäyslajittelun pseudokoodilistaus on esitetty seuraavassa: LISÄYSLAJITTELU(A) 1 FOR j := 2, 3, …, pituus(A) DO alkio := A[j] /* Otetaan paikassa j oleva alkio talteen käsiteltäväksi. */ i := j – WHILE i > 0 AND A[i] > alkio DO A[i + 1] := A[i] i := i – A[i + 1] := alkio Lisäyslajittelu on esimerkki ns. minimitilassa toimivista lajittelualgoritmeista. Minimitilaisuudella tarkoitetaan, että menetelmä tarvitsee toimiakseen ainoastaan vakiomäärän työmuistia. Toisin sanoen, lajittelun suorittamiseksi tarvittavan lisämuistin määrä ei riipu syötteen koosta n. Lisäyslajittelualgoritmissa ainoat tarpeelliset apumuuttujat ovat silmukkalaskurit i ja j sekä kullakin ulomman silmukan kierroksella tarkasteltavan alkion kopioimiseen tarvittava apumuuttuja alkio.

Suorituskertojen määrä
2.1 Algoritmien analysointi Lähdetään nyt analysoimaan, montako kertaa algoritmin eri rivejä suoritetaan lajittelun ollessa käynnissä. Rivikohtaiset tiedot on koottu seuraavaan taulukkoon. Taulukon riveillä 4 – 6 esiintyvä termi tj tarkoittaa, montako kertaa algoritmin rivillä 4 esiintyvän WHILE-silmukan alkuehtoa joudutaan testaamaan tietyllä j:n arvolla Kannattaa huomioida, että rivin 1 FOR-silmukan alkuehtoa testataan yhden kerran enemmän kuin silmukassa on kierroksia. Viimeisellä kerralla ainoastaan todetaan, että laskurin arvo on kasvanut n + 1:een, eli suoritusta ei enää jatketa. Rivi Rivin kustannus Suorituskertojen määrä 1 c1 n 2 c2 n – 1 3 c3 4 c4 5 c5 6 c6 7 c7

Nyt pystytään edellisen taulukon avulla laskemaan algoritmin kokonaissuoritusaika summaamalla rivikohtaiset kustannukset: T(n) = c1n + c2(n – 1) + c3(n – 1) + c c c c7(n – 1) Algoritmin kokonaissuoritusaika vaihtelee selvästikin sen mukaisesti, mikä tj:n arvoksi kulloinkin määräytyy. Tutkitaan ensiksi paras tapaus: jos vektori A on jo alun perin järjestettynä ei-vähenevään suuruusjärjestykseen, ei eri kierroksilla käsiteltäviä alkioita eikä niiden edeltäjiä tarvitse siirtää minnekään (A[1]  A[2]  …  A[j – 1]  A[j] = alkio).  tällöin jokaisella ulomman eli FOR-silmukan kierroksella j (2, 3, …, n) WHILE-silmukan aloitusehdon jälkimmäinen osa (A[i] > alkio) on epätosi  silloin tj = 1 jokaiselle j:n arvolle 2, 3, … n. Koska WHILE-ehtoa testataan aina vain kertaalleen, saadaan = … + 1 = n – 1 (ykkösiä yhteensä n – 1 kappaletta) Tällöin vastaavasti riveillä 5 ja 6 ei vierailla kertaakaan!

Siten parhaassa tapauksessa: T(n) = c1n + c2(n – 1) + c3(n – 1) + c4(n – 1) + c7(n – 1) = (c1 + c2 + c3 + c4 + c7)n – (c2 + c3 + c4 + c7) = an + b  edellä kertoimien c1, c2, c3, c4 ja c7 summa on nimetty uudelleen vakiolla a ja vastaavasti summa c2 + c3 + c4 + c7 vakiolla b  syötteen koko n esiintyy lausekkeessa ainoastaan ensimmäisen asteen termissä  parhaassa tapauksessa lisäyslajittelun suoritusaika on lineaarinen eli suoraan verrannollinen lajiteltavien alkioiden lukumäärään Tarkastellaan nyt vastaavasti tilannetta pahimmassa tapauksessa, jolloin lajittelun suorittamiseksi tarvittavan työn määrä maksimoituu:  jos lajiteltava vektori on alun perin aidosti vähenevässä järjestyksessä, joudutaan jokaisella ulomman silmukan kierroksella testaamaan WHILE-silmukan aloitusehtoa j kertaa. Viimeisellä eli j. testauskerralla ehdon alkuosa i > 0 ei enää toteudu.  tällöin T(n) = c1n + c2(n – 1) + c3(n – 1) + c c c c7(n – 1) Nyt pitäisi pystyä vielä avaamaan termien 4 – 6 summalausekkeet.

Aritmeettisen sarjan Sn = summa voidaan määrätä seuraavasti: Sn = … n – n (alusta loppuun päin) Sn = n n – n – … (lopusta alkuun päin) __________________________________________________________________ 2Sn = (n + 1) + (n + 1) + (n + 1) + … (n + 1) + (n + 1) (termien 2-kertainen summa) Koska yhteenlaskettavia on yhteensä n kappaletta, summa 2Sn = n(n + 1)  Sn = n(n + 1)/2 Siten lisäyslajittelun pahimmassa tapauksessa ... = – 1 = n(n + 1)/2 – 1, ja vastaavasti = = ½(n – 1)n, joten … T(n) = c1n + c2(n – 1) + c3(n – 1) + c4(n(n + 1)/2 – 1) + c5n(n – 1)/2 + c6n(n – 1)/2 + c7(n – 1) = ½(c4 + c5 + c6)n2 + (c1 + c2 + c3 + ½c4 + ½c5 + ½c6 + c7)n – (c2 + c3 + c4 + c7) = an2 + bn + c, missä a = ½(c4 + c5 + c6), b = (c1 + c2 + c3 + ½c4 + ½c5 + ½c6 + c7) ja c = -(c2 + c3 + c4 + c7)  Lisäyslajittelun pahinta tapausta kuvaava suoritusaika on neliöllinen (syötteen koon 2. potenssi)

Lisäyslajittelusta tekee aikavaativuudeltaan neliöllisen se, että siihen kuuluu kaksi sisäkkäistä silmukkaa, joiden kummankin suorituskertojen määrä riippuu n:stä  teoreettinen silmukoiden sisältämien lauseiden suorituskertojen yläraja olisi n * n, mutta todellisuudessa tätä ei lisäyslajittelussa koskaan saavuteta (luennolla tästä esimerkki) Silmukoiden sisällä suoritettavat yksittäiset operaatiot ovat kustannukseltaan vakioaikaisia  esimerkiksi kahden alkion välinen vertailu, alkion siirto toiseen paikkaan  yksittäisen tällaisen operaation kustannus ei ole riippuvainen syötteen koosta Miksi analysoida juuri pahinta tapausta? Perusteita tälle: 1) Saadaan yläraja algoritmin suoritusajalle: suoritus ei varmasti kestä pidempään! 2) Pahin tapaus saattaa esiintyä verrattain usein  etsitään esimerkiksi vektorista tai linkitetystä listasta alkiota, jota siellä ei esiinny 3) Niin sanotun ”keskimääräisen tapauksen” määritteleminen ei ole välttämättä aivan suoraviivaista, ja vaikka näin olisikin, se saattaa olla vaikeudeltaan samaa kertaluokkaa pahimman tapauksen kanssa!  ajatellaanpa esimerkkinä lisäyslajittelua Oletetaan, että kierroksella j tutkittava alkio on aina suurempi kuin järjestetyn osan alkupuoliskon alkiot mutta aina pienempi kuin sen loppupuoliskon alkiot. Tällöin tj  j / 2. Jos tämä sijoitetaan suoritusaikalausekkeeseen, saadaan  = ½ = ¼n(n + 1) – ½ = ¼(n2 + n – 2) Saatu lauseke on yhä edelleen neliöllinen n:n funktio!  keskimääräinen tapaus  pahin tapaus!

2.2 Algoritmien suunnittelu
Tietyn tehtävän suorittava algoritmi voidaan yleensä suunnitella ja toteuttaa usealla vaihtoehtoisella tavalla. Yksi mahdollinen tapa algoritmin ratkaisutapa on rekursio. Rekursiivinen algoritmi pyrkii ratkaisemaan alkuperäisen tehtävän kokoamalla ratkaisun samankaltaisten, mutta alkuperäistä pienempien ongelmien osaratkaisuista. Siten tällainen algoritmi kutsuu itseään, kunnes tarkasteltava osaongelma on niin pieni, että se ratkeaa suoraan eli triviaalisti. Kun algoritmin kontrolli siirtyy rekursiivisen kutsun kohdalle, algoritmista käynnistyy tällöin ns. uusi aktivaatio. Samalla aikaisempi aktivaatio keskeytyy odottamaan sitä, että uusi saadaan vietyä päätökseen.  Yhdestä algoritmista voi olla samanaikaisesti luotuna mielivaltaisen monta aktivaatiota, mutta vain yhtä niistä käsitellään kerrallaan: muut ovat ”lepäämässä” rekursiopinossa.  Aktivaatioita käsitellään pinomaisesti, eli mitä aikaisemmin aktivaatio on käynnistynyt, sitä myöhemmin se päättyy (vrt. edellä esitetty limityslajittelun rekursiopino: viimeksi valmistuu alkuperäinen tehtävä).  Jokaisella aktivaatiolla on omat paikalliset muuttujansa, vaikkakin ne ovat muodollisesti saman nimisiä toisten aktivaatioiden vastaavien muuttujien kanssa. Siten ei ole pelkoa, että vaikkapa nykyisessä aktivaatiossa tehtävä asetus a := a + b muuttaisi aikaisemmin käynnistyneissä aktivaatioissa esiintyvän muuttujan a arvoa. Suoraan eli ilman rekursiivista kutsua ratkeavaa tehtävää kutsutaan rekursion kannaksi tai perustapaukseksi.

Jotta rekursiivinen ratkaiseminen olisi mahdollista, pitää seuraavien kahden ehdon täyttyä: 1) Algoritmille on määriteltävä ainakin yksi perustapaus 2) Joka kerta, kun muodostetaan uusi rekursiivinen kutsu, tehtävän pitää helpottua aikaisemmasta. Tämä tarkoittaa sitä, että kutsun suorittaminen vie lähemmäs jotain tällaista suoraan ratkeavaa tapausta.  Elleivät molemmat ehdot täyty, rekursio ei milloinkaan pääty muutoin paitsi mahdollisesti tietokoneen ajonaikaisen muistipinon täyttymiseen, jos algoritmi ajautuu aina vain loitommas kaikista perustapauksesta (jokainen uusi rekursiivinen kutsu varaa muistia uusien aktivaatioiden paikallisia muuttujia varten, mikä ei voi jatkua loputtomiin) Tarkastellaan seuraavaksi ns. hajota ja hallitse -tekniikkaa (lat. divide et impera), joka perustuu rekursioon ja jota käytetään hyväksi muun muassa lajittelualgoritmeissa. Tekniikan voi todeta sisältävän kolme eri vaihetta: 1) Ellei ongelma ole triviaali, hajota se aliongelmiksi 2) Hallitse ratkaisemalla rekursiivisesti jokainen aliongelma 3) Yhdistä aliongelmien ratkaisut alkuperäisen ongelman ratkaisuksi Yksi tunnetuimmista hajota ja hallitse -algoritmeista on jo edellä alustavasti tarkasteltu limityslajittelu.

Seuraava hahmotelma kuvaa limityslajittelun etenemistä Hajota Hallitse Yhdistä

Limityslajittelussa hajottaminen tapahtuu halkaisemalla tarkasteltava osavektori kahtia, hallitseminen ratkaisemalla syntyneet osaongelmat rekursiivisesti ja yhdistäminen limittämällä osaratkaisujen tulokset yhdeksi pidemmäksi järjestetyksi vektoriksi. Hajottaminen vaatii pelkän keskikohdan määräämisen ja hallitseminen kaksi rekursiivista kutsua , eli ne ovat erittäin helppoja toimenpiteitä. Limitys vaatii sen sijaan enemmän työtä. Tarkastellaan seuraavaksi limitysalgoritmia. LIMITYS(A, p, q, r) 1 n1 := q – p n2 := r – q 3 Perusta apuvektorit V[1..n1 + 1] ja O[1..n2 + 1] 4 FOR i := 1, 2, …, n1 DO V[i] := A[p + i – 1] 6 FOR j := 1, 2, …, n2 DO O[i] := A[q + j] 8 V[n1 + 1] :=  9 O[n2 + 1] :=  10 i := 1; j := 1; FOR k := p, p + 1, …, r DO IF V[i]  O[j] THEN A[k] := V[i] i := i ELSE A[k] := O[j] j := j + 1

Ennen limityslajittelun analyysiä mainittakoon vielä muutama sana algoritmien suoritusaikojen kasvunopeudesta Lisäyslajittelun pahimman tapauksen suoritusajaksi laskettiin edellä T(n) = an2 + bn + c, missä a, b ja c ovat joitain nollasta eroavia vakioita Koska jatkossa ollaan kiinnostuneita ainoastaan suoritusajan kasvunopeuden suuruusluokasta, tarkastellaan suoritusaikalausekkeesta ainoastaan korkeinta astetta olevaa termiä.  alempiasteisten termien vaikutus heikkenee sitä mukaa, kun n kasvaa  sama koskee myös korkeinta astetta olevan termin kerrointa  tarkastellaan myöhemmin asiaa koskevia esimerkkejä Siten voidaan todeta, että lisäyslajittelun pahimman tapauksen suoritusaika on suuruusluokkaa (n2). Seuraavassa esitetään limityslajittelualgoritmi kokonaisuudessaan … LIMITYSLAJITTELU(A, p, r) 1 IF p < r 2 THEN q := (p + r)/2 LIMITYSLAJITTELU(A, p, q) LIMITYSLAJITTELU(A, q + 1, r) LIMITYS(A, p, q, r)

… ja suoritetaan sille seuraavaksi analyysi: Todetaan aluksi, että yhdistämisvaiheessa käytettävä algoritmi LIMITYS toimii ajassa O(n),sillä Rivien 1 – 3 ja 8 – 10 suoritus vie vakioajan (pelkkiä asetuslauseita ja muistin varauksia) Rivien 4 – 7 FOR-silmukoiden suoritus vie ajan O(n1 + n2) = O(n) Rivien 11 – 16 FOR-silmukka pyörii n kertaa, ja kaikki siinä suoritettavat lauseet ovat vakioaikaisia Sitten itse pääalgoritmi: Rivin 1 testi: vakioaikainen eli O(1) Rivillä 2 tapahtuva halkaisu: samoin vakioaikainen Rivien 3 ja 4 rekursiiviset kutsut: T(n/2) + T(n/2) = 2T(n/2) Rivin 5 limitys: O(n) Siten saadaan: T(n) = (1), kun n = = 2T(n/2) + (n) , kun n > 1 Kannattaa huomioida, että (n) + (1) = (n). Vastaavasti (n2) + (n) = (n2). Myöhemmin tullaan näyttämään toteen, että limityslajittelulle T(n) = (n log2n)

3 Funktioiden kasvunopeus
3.1 Asymptoottinen merkintätapa Kuten jo edellä lyhyesti mainittiin, algoritmin aikavaativuus kuvataan yleensä esittämällä sen tarkan teoreettisen suoritusajan asemesta vain sen suuruus- eli kertaluokka.  tällä tarkoitetaan sitä, miten algoritmin suoritusaika muuttuu suhteessa syötteen kokoon silloin, kun syötteen koon annetaan kasvaa rajatta Yleisimmin käytetyt kuvaustavat ovat ns. - (theta) ja - (iso ordo) notaatiot -merkinnällä tarkoitetaan ns. asymptoottista yhdistettyä ylä- ja alarajaa Mikäli jonkin algoritmin suoritusaikaa kuvaa lauseke T(n) = (n), tarkoittaa se sitä, että kyseisen algoritmin ajankäyttö on kaikilla kelvollisilla syötteillä suoraan verrannollinen syötteen pituuteen n, kunhan n on riittävän iso. Matemaattisesti -merkintä voidaan ilmaista seuraavasti:  c1, c2  R+ ja  n0  N siten, että (g(n)) = { f(n) | 0  c1g(n)  f(n)  c2g(n) jokaiselle n  n0 } ”Suomennettuna” edellinen merkintä tarkoittaa, että algoritmin ajankäyttöä ilmaiseva funktio (lauseke) f(n) kuuluu kasvunopeusluokkaan (g(n)) silloin, kun löydetään mielivaltaiset kaksi positiivista reaalilukuvakiota c1 ja c2 sekä jokin syötteen koko n0  0 , josta lähtien lauseke c1g(n) pysyy aina pienempänä tai yhtä suurena kuin f(n), ja tämä puolestaan pysyy aina pienempänä tai yhtä suurena kuin c2g(n).  funktion f(n) kuvaaja sijoittuu n:n arvosta n0 lähtien kuvaajien c1g(n) ja c2g(n) väliin  sillä, miten f(n) käyttäytyy n0:aa pienemmillä n:n arvoilla, ei ole merkitystä!

3.1 Asymptoottinen merkintätapa
Esimerkki: Osoitetaan, että ½n2 – 3n = (n2)  Nyt pitää pystyä löytämään sellaiset positiiviset reaalilukuvakiot c1 ja c2 sekä syötteen koko n0, josta lähtien on kaikilla n:n arvoilla voimassa c1n2  ½n2 – 3n  c2n2 Tarkastellaan aluksi epäyhtälön oikeaa puolta: ½n2 – 3n  c2n  On helppo havaita, että jos c2:n paikalle sijoitetaan ½ tai tätä suurempi arvo, epäyhtälö on tosi kaikille ei-negatiivisille n:n arvoille (½n2 – 3n  ½n2) Siten voidaan valita vaikkapa c2 = ½ Sitten epäyhtälön vasen puoli: c1n2  ½n2 – 3n jaetaan epäyhtälö puolittain n2:lla  c1  ½ – 3/n  sitä mukaa kun n kasvaa, vähentäjä 3/n pienenee. Kun n saavuttaa arvon 7, tulee erotuksen ½ – 3/n arvoksi aidosti positiivinen ½ – 3/7. Tästä laventamalla saadaan edelleen = 7/14 – 6/14 = 1/  n:n arvosta 7 eteenpäin erotus ½ – 3/n vain kasvaa jatkuvasti. Siten voimme valita vakion c2 paikalle arvon 1/14 ja vakion n0 paikalle arvon 7. Vakion c1 paikalle valittiin jo edellä ½  siten (1/14)n2  ½n2 – 3n  ½n2, kun n  7, joten todetaan, että ½n2 – 3n = (n2).□

Kannattaa huomioida, että algoritmien analyysissä on käytetään merkintätapaa f(n) = (x), missä x on jokin aikakompleksisuusluokka, siitä huolimatta, että (x) edustaa itse asiassa funktioiden joukkoa eikä mitään yksittäistä funktiota (oikeaoppisempi merkintä olisi f(n)  (x)). Esimerkki: Osoitetaan, että 6n3  (n2)  Tehdään vastaoletus ja uskotaan, että pystytään sittenkin löytämään sellaiset positiiviset reaalilukuvakiot c1 ja c2 sekä syötteen koko n0, josta lähtien on kaikilla n:n arvoilla voimassa c1n2  6n3  c2n2 Jaetaan epäyhtälö puolittain termillä n2 ja tarkastellaan aluksi epäyhtälön vasenta puolta: c1  6n  Voidaan valita c1:n paikalle vaikkapa vakio 1, jolloin vasen puoli toteutuu kaikilla positiivisilla n:n arvoilla Mutta mitä mahtaa tapahtua epäyhtälön oikealla puolella? Saadaan: n  c Sitä mukaa kun n kasvaa, myös termin 6n arvo kasvaa, mutta vakio c2 pysyy ennallaan  valittiinpa vakio c2 miten suureksi tahansa, ennemmin tai myöhemmin kohdataan sellainen n:n arvo, jolloin 6n ylittää vakion c2 arvon, toisin sanoen mille tahansa vakiolle c2 > 0 on voimassa = .  vastaoletus virheellinen, joten alkuperäinen väite pitää paikkansa. □

Jotta funktio f(n) kuuluisi johonkin luokkaan (x), pitää f(n)-lausekkeen korkeimman asteen termin olla sama kuin kasvunopeusluokan termi x. Lause: Jos p(n) on astetta k oleva polynomi, eli p(n) = , missä ai:t ovat vakioita ja ak > 0, niin silloin p(n) = (nk).  Lauseen todistus sivuutetaan tässä, mutta todistaminen onnistuu jakamalla aikaisempien esimerkkien tapaan muodostettava kaksoisepäyhtälö termillä nk. Esimerkki: Jos p(n) = ⅓n n n , niin p(n) = (n7). Muut paitsi polynomin korkeinta astetta olevan termi ja sen mahdollinen n:stä riippuva kerroin voidaan jättää huomiotta kasvunopeutta ilmoitettaessa, sillä n:n kasvaessa tarpeeksi paljon mainittu termi tulee peittämään muiden termien vaikutuksen alleen.  korkeinta astetta oleva termi ns. dominoi lauseketta n:n ollessa riittävän iso  edellisessä esimerkissä seitsemännen asteen termin vaikutus tulee pitkän päälle kaikkein suurimmaksi, vaikka vielä esimerkiksi n:n arvolla 3000 toinen termeistä on arvoltaan tätä isompi. Edellisen perusteella kannattaa muistaa, että vaikkapa lauseke p(n) = nlog2n + 4n + 1  (n), sillä n:stä riippuvan logaritmikertoimen ansiosta nlog2n kasvaa nopeammin kuin n. Kannattaa lisäksi huomioida, että vakio on nollannen asteen polynomi, joten vakiofunktio kuuluu kasvunopeusluokkaan (n0) = (1).

-merkinnällä tarkoitetaan ns. asymptoottista ylärajaa Mikäli jonkin algoritmin suoritusaikaa kuvaa lauseke T(n) = (n), tarkoittaa se sitä, että kyseisen algoritmin ajankäyttö on kaikilla kelvollisilla syötteillä verrannollinen korkeintaan syötteen koon 1. potenssiin, mutta ylärajan ei tarvitse olla tiukka.  algoritmi saa toimia tätä nopeamminkin (toisin kuin -merkinnän yhteydessä)! Matemaattisesti -merkintä voidaan ilmaista seuraavasti:  c  R+ ja  n0  N siten, että (g(n)) = { f(n) | 0  f(n)  cg(n) jokaiselle n  n0 }  mikäli funktio f(n) toteuttaa nämä ehdot , merkitään, että f(n) = (g(n)). ”Suomennettuna” edellinen merkintä tarkoittaa, että algoritmin ajankäyttöä ilmaiseva funktio (lauseke) f(n) kuuluu kasvunopeusluokkaan (g(n)) silloin, kun löydetään mielivaltainen positiivinen reaalilukuvakio c sekä jokin syötteen koko n0  0 , josta lähtien f(n) pysyy aina pienempänä tai yhtä suurena kuin cg(n).  funktion f(n) kuvaaja sijoittuu n:n arvosta n0 lähtien kuvaajan cg(n) alapuolelle.  sillä, miten f(n) käyttäytyy n0:aa pienemmillä n:n arvoilla, ei ole merkitystä! Kannattaa huomioida, että f(n) = (g(n))  f(n) = (g(n)). Sen sijaan päinvastaisesta ei ole mitään takeita (eli implikaatio ei ole yleisesti voimassa toiseen suuntaan)!

Esimerkki: Lisäyslajittelun parhaan tapauksen aikakompleksisuus T(n) = an + b = O(n2), mutta se ei kuitenkaan ole suuruusluokkaa (n2).  lauseketta an + b ei pysty rajoittamaan alhaalta termillä c1n2 millään kertoimen c1 arvolla! -merkintää käytetään usein kuvaamaan algoritmin pahinta tapausta, eli se rajoittaa sen suoritusaikaa kaikilla kelvollisilla syötteillä vain ylhäältä päin. Algoritmin aikavaativuus on polynomiaalinen, jos se kuuluu luokkaan O(nk), kun k on jokin ei-negatiivinen vakio. Seuraavat laskusäännöt ovat voimassa O-merkinnöille. Ne pätevät myös  -merkinnöille, joten säännöistä voi ordot korvata kaikkialta thetoilla. Jos T1(n) = O(f(n)) ja T2(n) = O(g(n)), niin 1) T1(n) + T2(n) = max{O(f(n)), O(g(n))} 2) T1(n)  T2(n) = O(f(n)  (g(n)) Jos f(n) = (g(n))  = c  0. Esimerkki: Osoitetaan, että aritmeettisen sarjan summa = (n2). Todistus: = ½n(n + 1) ja = ½ = ½ = ½. □

Seuraavassa taulukossa on lueteltu muutamien, algoritmien analyysissä hyödyllisten funktioiden arvoja eri n:n arvoilla. Hyviä muistisääntöjä: 1) mikä tahansa kasvava logaritmifunktio kasvaa asymptoottisesti nopeammin kuin yksikään vakiofunktio (sen arvo ei tietystikään riipu lainkaan syötteen koosta) 2) mikä tahansa kasvava potenssifunktio kasvaa nopeammin kuin yksikään logaritmifunktio 3) mikä tahansa kasvava eksponenttifunktio kasvaa nopeammin kuin yksikään potenssifunktio n lg n n lg n n2 n3 2n 10 3.3 33 100 1 000 1 024 6.6 660 10 000 > 1030 10.0 > 10301 13.3 > 16.6 > 19.9 >

3.2 Matemaattisia merkintöjä ja funktioita
Seuraavassa esitetään muutamia kurssilla toistuvasti käytettäviä matemaattisia määritelmiä ja laskusääntöjä. 1) Kertoma sekä katto- ja lattiafunktiot Luonnollisen luvun n kertoma (merkitään n!) määritellään rekursiivisesti seuraavasti: n! = 1, jos n = = n  (n – 1)!, jos n > 0 Toisin sanoen, n! = 1  2  3  …  n, kun n > 0 n!  nn kaikilla n > 0, ja lisäksi nn kuuluu kertomaa ylempään aikavaativuusluokkaan Kattofunktiolla x tarkoitetaan luvun x pyöristämistä ylöspäin lähimpään kokonaislukuun. Lattiafunktiolla x tarkoitetaan puolestaan luvun x pyöristämistä alaspäin lähimpään kokonaislukuun. 2) Eksponenttifunktio Oletetaan, että a > 0, sekä m ja n ovat mielivaltaisia reaalilukuja a0 = 1 a1 = a a-1 = 1/a ja a-n = 1 / an (am)n = amn = (an)m aman = am + n Mikäli a > 1, niin mille tahansa vakiolle b  R on voimassa seuraava tulos: = 0  tämä tarkoittaa sitä, että mikä tahansa eksponenttifunktio, jonka kantaluku a > 1, kasvaa nopeammin kuin yksikään polynomifunktio  sama voitaisiin ilmaista myös merkinnällä nb = (an), missä merkintä  (pikku-ordo) tarkoittaa ns. epätarkkaa ylärajaa (tarkempi esittely sivuutetaan tällä kurssilla)

3.2 Matemaattisia merkintöjä ja funktioita
3) Logaritmit lg n = log2n (2-kantainen logaritmijärjestelmä: tarvitaan useimmin tietojenkäsittelyssä) log n = log10n (10-kantainen logaritmijärjestelmä) ln n = logen (luonnollinen logaritmijärjestelmä, jonka kantalukuna on Neperin luku e  2.718) logkn = (log n)k log log n = log(log n) Kaikille reaaliluvuille a, b, c > 0 on voimassa: logc(ab) = logca + logcb logc(a/b) = logca – logcb logcan = n logca blogba = a logba = 1 / logab logba = (1 / logcb)  logca /* logaritmien muunnossääntö toiseen kantalukuun */ Viimeisestä laskusäännöstä pystyy päättelemään, että eri logaritmit eroavat toisistaan vain vakion suuruisella suhdeluvulla n:stä riippumatta.  eri logaritmeilla on sama asymptoottinen kasvunopeus!  kaikki logaritmit kasvavat hitaammin kuin yksikään kasvava polynomifunktio!

4 Rekursioyhtälöistä Rekursioon ja rekursiivisiin algoritmeihin ehdittiin tutustua jo kursseilla ”Johdatus informaatioteknologiaan I / II”.  rekursiivisten algoritmien ongelmanratkaisutapa syötteen koolle n perustuu tätä aidosti pienemmän (esimerkiksi n – 1:n kokoisen) syötteen ratkaisemiseen.  ajatuksena on, että sitä mukaa kun n jatkuvasti pienenee, tehtävä ratkeaa alkuperäistä helpommin.  kun aikanaan n tulee riittävän pieneksi, tehtävän tiedetään ratkeavan vakioajassa Esimerkkejä: 1) kertoman laskennassa voidaan asettaa perustapaukseksi n = 0, jolloin vastaukseksi palautetaan 1 (algoritmille voidaan asettaa useampiakin perustapauksia, mutta se ei kertoman tapauksessa ole tarpeen, mutta esimerkiksi Fibonaccin lukujen rekursiivisessa laskennassa näin on) ) (limitys)lajitteluongelma on triviaali, jos lajiteltavia alkioita on korkeintaan yksi: pääohjelmassa testataan ainoastaan, onko syötevektorin vasen raja aidosti pienempi kuin oikea. Ellei ole, ei tehdä mitään  siten voidaan olettaa, että korkeintaan 1 alkion lajittelu vie vakioajan. Tällä kurssilla olemme juuri limityslajittelun kohdalla törmänneet suoritusaikalausekkeeseen, jossa yhtälön oikea puoli ei ole ratkaistussa muodossa, vaan sisältää termiä T(x), missä x < n on jokin osa alkuperäisen syötteen koosta. Limityslajittelun tarkka suoritusaikalauseke olisi muotoa: T(n) = (1), kun n  T(n/2) + T (n/2) (n), kun n > 1 Kyseessä on rekursioyhtälö, joka on tarpeen ratkaista, jotta algoritmin kokonaissuoritusaika pystyttäisiin lausumaan turvautumatta jonkin kooltaan n:ää pienemmän syötteen ratkaisuaikaan.

4 Rekursioyhtälöistä Yleensä tyydytään esittämään rekursioyhtälöstä vain rekursiivisia termejä sisältävä tapaus (edellä se, jossa n > 1), sillä tehtävän voidaan olettaa ratkeavan vakioajassa, kun n on riittävän pieni. Myös katto- ja lattiafunktiot jätetään usein merkitsemättä, sillä niillä ei ole merkitystä asymptoottisen suoritusajan kannalta.  siten limityslajittelun suoritusaika kuvataan ratkaisemattomassa muodossa usein seuraavalla tavalla (ilman perustapausta sekä katto- ja lattiafunktioita): T(n) = 2T(n/2) + (n) Tällä kurssilla tarkastellaan iterointimenetelmää rekursioyhtälöiden ratkaisemiseksi. Muitakin menetelmiä on toki olemassa (esimerkiksi ratkaisun arvaaminen ja todistaminen oikeaksi). Lähdetään aluksi tarkastelemaan rekursioyhtälöä T(n) = T(n/2)  Kaavan sanomana on, että n:n kokoisen syötteen ratkeaminen vaatii työtä yhden yksikön enemmän kuin puolet lyhyempi syöte.  Sovelletaan kaavaa toistuvasti sijoittamalla aina oikean puolen T(n) lausekkeen syötteen koko vasemmalle n:n paikalle. Aluksi saadaan: T(n/2) = T(n/4) + 1, seuraavalla yrityksellä T(n/4) = T(n/8) + 1, sitten T(n/8) = T(n/16) + 1 ja niin edelleen. Joka kerta T(x):n argumentti puolittuu edellisestä  Käytetään tällä tavoin saatuja termejä hyväksi alkuperäisen syötteen työmäärän T(n) ilmaisemiseksi:

4 Rekursioyhtälöistä T(n) = T(n/2) /* lausutaan T(n/2) summan T(n/4) + 1 avulla */ = (T(n/4) + 1) + 1 = T(n/4) + 2 /* korvataan nyt puolestaan T(n/4) termillä T(n/8) + 1 … */ = (T(n/8) + 1) + 2 = T(n/8) + 3 /* … ja jatketaan samaan tapaan … */ = (T(n/16) + 1) + 3 = T(n/16) + 4 = T(n/24) … Nähdään, että yleisesti i. iteraatiolla saadaan muoto = T(n/2i) + i Koska voimme olettaa, että pienillä n:n arvoilla – esimerkiksi syötteen koolla 1 – suoritusaika on vakio, pitää ratkaista, milloin T:n argumenttina oleva n/2i saavuttaa arvon 1, eli montako iteraatiokierrosta pitää tehdä  Ratkaistaan yhtälö n/2i = 1 termin i suhteen: kerrotaan ensin puolittain 2i:llä …  n = 2i … ja otetaan molemmilta puolilta log2:  i = log2n  Tarvitaan siis i = log2n iteraatiokierrosta, että saavutetaan n:n arvo Sijoitetaan tämä i:n arvo ylempänä saatuun yleiseen muotoon: T(n) = T(n/2i) + i = T(n/2log2n) + log2n /* 2log2n = n */ = T(1) + log2n = c + log2n, missä c on jokin positiivinen vakio (kuvaa tapauksen n = 1 ratkeamiseen kuluvaa aikaa) Siten T(n) = (log2n), koska logaritmi kasvaa nopeammin kuin vakio (joka on tietysti kiinteä).

4 Rekursioyhtälöistä Lähdetään seuraavaksi tarkastelemaan limityslajittelun rekursioyhtälön yksinkertaistettua muotoa T(n) = 2T(n/2) + (n) Muunnetaan algoritmin ajankäytössä limityksen osuutta kuvaava termi (n) muotoon dn, sillä limitykseen menevää aikaa voidaan rajoittaa tulotermillä, joka on n:n ensimmäistä potenssia. T(n) = 2T(n/2) + dn /* lausutaan T(n/2) T(n/4):n avulla sijoittamalla kaavassa n/2 n:n paikalle */ = 2(2T(n/4) + dn/2) + dn = 22T(n/4) + 2dn /* lausutaan nyt puolestaan T(n/4) termin T(n/8) avulla … */ = 22(2T(n/8) + dn/4) + 2dn = 23T(n/8) + 3dn /* … ja jatketaan samaan tapaan … */ = 23(2T(n/16) + dn/8) + 3dn = 24T(n/16) + 4dn … Nähdään, että yleisesti i. iteraatiolla saadaan muoto = 2iT(n/2i) + idn Koska voimme nytkin olettaa, että pienillä n:n arvoilla – esimerkiksi syötteen koolla 1 – suoritusaika on vakio, pitää ratkaista, milloin T:n argumenttina oleva n/2i saavuttaa arvon 1, eli montako iteraatiokierrosta pitää tehdä  Ratkaistaan yhtälö n/2i = 1 termin i suhteen: kerrotaan ensin puolittain 2i:llä …  n = 2i … ja otetaan molemmilta puolilta log2:  i = log2n  Tarvitaan tässäkin tapauksessa siis i = log2n iteraatiokierrosta, että saavutetaan n:n arvo Sijoitetaan tämä i:n arvo ylempänä saatuun yleiseen muotoon: T(n) = 2iT(n/2i) + idn = 2log2n T(n/2log2n) + log2ndn /* 2log2n = n */ = nT(1) + dlog2n = cn + dnlog2n, missä c ja d ovat joitain positiivisia vakioita (d kuvaa limityksen tulotermin kerrointa ja c tapauksen n = 1 ratkeamiseen kuluvaa aikaa) Siten T(n) = (nlog2n), koska nlog2n kasvaa nopeammin kuin pelkkä n (n:stä riippuvaa kerrointa ei saa hävittää, jos se liittyy n:n korkeinta astetta olevaan termiin!).

4 Rekursioyhtälöistä Seuraavaksi siirrytään tarkastelemaan Hanoin tornien ongelman rekursioyhtälöä, jonka yleinen muoto on: T(n) = 2T(n – 1) + 1  Jotta saataisiin siirrettyä n:stä levystä koostuva torni lähtötolpasta maalitolppaan, pitää ensinnä siirtää n – 1:n kokoinen torni pois tieltä aputolppaan, minkä jälkeen suurin levy saadaan siirrettyä (tästä termi + 1), ja lopulta aputolpassa odottava n – 1:n kokoinen torni tuodaan suurimman levyn päälle maalitolppaan.  Perustapaukseksi voidaan valita tyhjän tornin siirtäminen, sillä sitä varten ei tarvitse tehdä yhtään mitään Valitaan siis T(0) =  Lähdetään nyt iteroimaan alkuperäistä rekursioyhtälöä tavoitteena, että n saavuttaa arvon 0: T(n) = 2T(n – 1) /* Sijoitetaan n:n paikalle n – 1, …*/ = 2(2T(n – 2) + 1) + 1 = 22T(n – 2) /* … sitten n – 1 korvataan n – 2:lla … = 22(2T(n – 3) + 1) = 23T(n – 3) /* … ja jatketaan T(x):n argumentin pienentämistä 1:llä = 24T(n – 4) = 24T(n – 4) …  Nähdään, että yleisesti i. iteraatiolla rekursioyhtälö saa muodon = 2iT(n – i) + 2i – i – 2 + … = 2iT(n – i) +

4 Rekursioyhtälöistä Koska T(0) = 0, eli tyhjän tornin siirtäminen on ilmaista. Lisäksi n:n arvo 0 saavutetaan n:n iteraatiokierroksen jälkeen, sillä n – i =  i = n Sijoittamalla arvo i = n edellisen sivun viimeiseen yhtälöön saadaan: T(n) = 2nT(0) = =  Nyt pitää vielä ratkaista summalausekkeen arvo. Tarkastellaan, mitä saataisiin summan Sn = arvoksi Tehdään tämä muodostamalla kaksinkertainen summa 2Sn ja vähentämällä siitä Sn. 2Sn = … n + 2n+1 Sn = … n  2Sn – Sn = … n_________ … n+1  Siten Sn = 2n+1 – 1, ja kun summalausekkeen yläraja i korvataan termillä i – 1, saadaan Hanoin tornien työmääräksi äskeisen perusteella T(n) = = 2n – 1  Hanoin tornien ongelman ratkaisuaika on siten eksponentiaalinen.

4 Rekursioyhtälöistä Otetaan vielä yksi esimerkki: tarkastellaan rekursioyhtälöä T(n) = T( ) + 1  Ratkaistaan aluksi lausekkeen arvo muutamilla seuraavilla, aina puolitetuilla n:n arvoilla (merkitään jatkossa = n½) … T(n) = T(n½) + 1 T(n½) = T(n½)½ + 1 = T(n1/4) + 1 T(n1/4) = T(n1/8) + 1 T(n1/8) = T(n1/16) + 1  … ja iteroidaan tämän jälkeen alkuperäistä yhtälöä: = T(n1/4) = T(n1/8) = T(n1/23) …  Saadaan lopulta yleinen muoto: T(n) = T(n1/(2i)) + i

4 Rekursioyhtälöistä Oletetaan taasen, että pienellä n:n arvolla tehtävä ratkeaa vakioajassa. Sovitaan, että tällainen n:n arvo olisi 2.  Tällöin pitää ratkaista yhtälö … n1/2i = 2 … joten eipä muuta kuin ratkaisemaan:  log2n1/2i = log22  log2n1/2i =  1/2i log2n = 1  log2n = 2i  i = log2log2n  Tehdään lopuksi sijoitus i = log2log2n yhtälön yleiseen muotoon: T(n) = n1/(2i) + i = n1/(2log2log2n) + log2log2n = c + log2log2n Siten T(n) = (log2log2n) (polylogaritmifunktio)  Kyseinen funktio kasvaa hyvin hitaasti. Se saavuttaa esimerkiksi arvon 4 vasta, kun n =

4 Rekursioyhtälöistä Rekursioyhtälön muodosta pystyy usein ainakin jossain määrin aavistamaan, mitä kasvunopeusluokkaa lausekkeen ratkaistu muoto edustaa.  Kannattaa aluksi pysähtyä hetkeksi miettimään, mitä rekursioyhtälö itse asiassa kertoo algoritmin reagoinnista syötteen koon muutoksiin.  Ei siis välttämättä ole aina tarvetta lähteä suoraan iteroimaan rekursioyhtälöä! Esimerkki 1: T(n) = T(n/2)  Syötteen koon kaksinkertaistuminen aiheuttaa työmäärän kasvamisen nykyisestä ainoastaan yhdellä yksiköllä  Tästä voi päätellä, että funktio kasvaa hyvin hitaasti, ja erityisesti lg on juuri halutun kaltainen funktio: sen arvo kasvaa ykkösellä aina kun syötteen koko kaksinkertaistuu  On siis perusteltua aavistaa, että lausekkeen ratkaistu muoto olisi kasvunopeudeltaan logaritminen. Esimerkki 2: T(n) = T(n – 1)  Syötteen koon kasvattaminen yhdellä lisää työmäärää kahdella yksiköllä  Työmäärä kasvaa siten tasaisesti kulloisestakin n:n arvosta riippumatta: muutos n:ssä näkyy aivan vastaavan suuruusluokan muutoksena työmäärässä  Voidaan hyvällä syyllä olettaa ratkaistun muodon kasvunopeuden olevan lineaarinen – suoraan verrannollinen syötteen kokoon n.

4 Rekursioyhtälöistä Esimerkki 3: T(n) = T(n – 1) + n  Syötteen koon kasvaminen yhdellä johtaa n:n suuruiseen työmäärän lisäykseen  Toisin kuin esimerkissä 2, nyt syötteen kasvattamisesta aiheutuva lisätyö ei olekaan enää vakioaikaista vaan riippuu n:n sen hetkisestä arvosta  Vaikuttaisi, että ratkaistu muoto näyttäisi aritmeettiselta sarjalta, kun yhteenlaskettavat ovat väliltä 1..n  Voidaan päätellä suoritusajan olevan neliöllinen. Esimerkki 4: T(n) = 2T(n – 1)  Syötteen koon kasvattaminen yhdellä yksiköllä yli kaksinkertaistaa tätä ennen tarvitun työmäärän  Ongelman täytyy olla vaikea – eksponentiaalinen. Mikäli rekursioyhtälö on jo ehditty ratkaista iteroimalla, kannattaa aina tarkastaa, onko saatu tulos alkuperäisen rekursioyhtälön muodon kanssa järkeenkäypä.  mahdolliset isot laskuvirheet saattavat paljastua!

6 Kekolajittelu Asymptoottisesti tehokkaimpien, alkioparien välisiin vertailuihin perustuvien yleisten lajittelumenetelmien esittely aloitetaan kekolajittelusta. Keko-tietorakenne ehdittiin lyhyesti esitellä kurssilla ”Johdatus informaatioteknologiaan II”. Keko muistuttaa rakenteensa puolesta binääripuuta, joka on mahdollisesti alinta tasoaan lukuun ottamatta täydellinen. Jokaista keon tasoa täytetään vasemmalta oikealle. On olemassa sekä maksimi- että minimikekoja. Maksimikeon kaikille solmuille pätee seuraava ominaisuus: tarkasteltavan solmun isäsolmu on arvoltaan aina vähintään yhtä suuri kuin solmu itse.  maksimikeon suurin alkio löytyy aina sen juuresta Minimikeossa puolestaan kunkin solmun isäsolmun arvo on tarkasteltavan solmun arvoan kanssa korkeintaan yhtä suuri.  minimikeon juuresta löytyy sen pienin alkio Maksimikeko 31 17 22 13 10 4 6 5 2 7

6 Kekolajittelu Keko voidaan tallentaa hyvin vektoriin, joka on indeksoitu välille [1..n]. Funktio pituus[A] ilmaisee taulukon A alkioiden lukumäärän. Attribuutti KeonKoko[A]osoittaa, miten monta alkiota A:sta kuuluu kekoon Kannattaa huomioida, että KeonKoko[A]  pituus[A], eli vektori A ei välttämättä ole tarkasteluhetkellä kokonaan keon käytössä. Paikasta A[1] löytyy keon huipulla oleva alkio (eli kekoa edustavan puun juuri). Maksimikeko … … ja sen esitys vektorimuodossa 31 17 22 13 10 4 6 5 2 7 31 17 22 13 10 4 6 5 2 7

6 Kekolajittelu Seuraavassa on esiteltyinä tärkeimmät keon solmulle suoritettavat siirtymisoperaatiot: 1) vanhempi(i)  palauttaa solmun i isäsolmun indeksin  tässä esitettävät algoritmit on toteutettu siten, ettei juuren isäsolmuun milloinkaan viitata, sillä tällaista ei ole olemassa  pseudokoodi: VANHEMPI(i) RETURN i/2 2) vasen(i)  palauttaa solmun i vasemman lapsisolmun indeksin  pseudokoodi: VASEN(i) RETURN 2i 3) oikea(i)  palauttaa solmun i oikean lapsisolmun indeksin  pseudokoodi: OIKEA(i) RETURN 2i + 1 Maksimikeolle kaikilla arvoilla i > 1 on voimassa A[VANHEMPI(i)]  A[i] Vastaavasti minimikeolle on jokaista i > 1 kohti voimassa A[VANHEMPI(i)]  A[i] Tällä kurssilla tarkastellaan vastedes aina maksimikekoja, mutta kurssilla ”Tietorakenteet ja algoritmit II” käsitellään tarkemmin myös minimikekoja.

6 Kekolajittelu Määritelmiä: solmun korkeus tarkoittaa pisimmän polun pituutta solmusta lehteen (lehtisolmu = solmu, jonka poikapuut ovat tyhjiä) keon korkeudella tarkoitetaan juuren etäisyyttä kaukaisimmasta lehdestä Tarkastellaan seuraavassa kekoa, jonka korkeutena on h. Tällöin kekoon mahtuu alkioita vähintään (olettaen, että keon alimmalla tasolla on vain yksi alkio, eli keko on mahdollisimman vajaa) = … + 2h–1 + 1 = 2h – = 2h alkiota. Vastaavasti, jos keko on mahdollisimman täynnä (alinkin taso täyttyneenä), siihen mahtuu = … + 2h–1 + 2h = 2h+1 – 1 alkiota. Kun keon alkioiden lukumäärä on n, sen korkeus pystytään laskemaan äskeisen analyysin perusteella seuraavasti ratkaisemalla seuraava kaksoisepäyhtälö korkeuden h suhteen: h  n  2h+1 – 1  2h  n < 2h  h  lg n < h  h = lg n  Esimerkiksi 20 alkion keko on korkeudeltaan lg 20 = 4 (lg 20  4.32), ja siinä on 5 tasoa.

6.2 Keon ylläpito Seuraavaksi esitettävällä algoritmilla KORJAA_MAKSIMIKEKO voidaan korjata yhden solmun kohdalta mahdollisesti rikkoutunut maksimikeko uudelleen kuntoon. Algoritmissa oletetaan, että solmun A[i] molemmat alipuut ovat kekoja, mutta sen sijaan A[i]:n itsensä kohdalla keko-ominaisuus ei välttämättä ole voimassa vaan on saattanut tilapäisesti rikkoutua. KORJAA_MAKSIMIKEKO(A, i) 1 v := vasen(i) o := oikea(i) IF v ≤ KeonKoko[A] AND A[v] > A[i] THEN suurin := v ELSE suurin := i IF o ≤ KeonKoko[A] AND A[o] > A[suurin] THEN suurin := o IF suurin ≠ i THEN vaihda A[i] <---> A[suurin] KORJAA_MAKSIMIKEKO(A, suurin) Algoritmin ajatuksena on siirtää indeksiin i päätynyt liian pieni avain keossa alaspäin oikealle paikalleen.

6.2 Keon ylläpito  Juurisolmun (i = 1) ja sittemmin sen oikean pojan (i = 3) kohdalta rikkoutunut keko korjautuu  1 17 22 13 10 4 6 5 2 7  22 17 6 13 10 4 1 5 2 7

6.2 Keon ylläpito 6.3 Keon rakentaminen
Analysoidaan algoritmin KORJAA_MAKSIMIKEKO(A, i) aikakompleksisuus:  Kaikki rivit viimeistä lukuun ottamatta vaativat vakiomäärän suoritusaikaa, sillä niissä tehdään ainoastaan asetuksia ja vertailuja, joiden kesto ei riipu syötteen koosta n.  Viimeinen eli 10. rivi sisältää rekursiivisen kutsun, jollainen voi pahimmassa tapauksessa kerran jokaista keon tasoa kohti. Keossa on tasoja h + 1 eli yksi enemmän kuin keolla on korkeutta. Koska h = log2n, niin algoritmin suoritusajaksi saadaan T(n) = log2n. 6.3 Keon rakentaminen Keko saadaan perustettua vektorista A[1..n] järjestämällä se kekojärjestykseen. Kekojärjestys saadaan toteutumaan kutsumalla toistuvasti edellä esitettyä keon korjausalgoritmia KORJAA_MAKSIMIKEKO. Keon rakentamismenettely perustuu havaintoon, että kaikki keon lehtisolmut toteuttavat triviaalisti keko-ominaisuuden (ne ovat yhden alkion kekoja: molemmat alipuut tyhjiä), joten niitä ei tarvitse mennä korjaamaan. Kyseiset alkiot sijaitsevat vektorin A paikoissa n/2 + 1, n/2 + 2, …, n – 1, n

6.3 Keon rakentaminen Maksimikeon muodostava algoritmi on esitettynä seuraavassa: MUODOSTA_MAKSIMIKEKO(A) 1 KeonKoko[A] := pituus[A] 2 FOR i := pituus[A]/2, pituus[A]/2 - 1, …, 2, 1 DO KORJAA_MAKSIMIKEKO(A, i) Tehdään algoritmille ensi alkuun yksinkertainen analyysi:  rivin 1 suorituskustannus on vakioaikainen  rivin 2 silmukassa tehdään kiinteät n/2 kierrosta, ja joka kerta siinä ainoana käskynä kutsutaan rivillä 3 proseduuria KORJAA_MAKSIMIKEKO, jonka suoritusaika todettiin jo edellä logaritmiseksi. Analyysin perusteella maksimikeon rakennuskustannus tuntuisi siten olevan suuruusluokkaa T(n) = O(nlog2n). Perusteellisempi, seuraavassa esitettävä analyysi osoittaa kuitenkin, että keko saadaan muodostettua lineaarisessa ajassa, eli T(n) = O(n). Kyseinen tulos perustuu lauseeseen, jonka mukaan keon solmujen korkeuksien summa on korkeintaan 2h+1 – h – 2.  Todistetaan lause seuraavaksi. Oletetaan, että tarkastellaan täyttä kekoa, jonka korkeutena on h. Tällöin keossa on 1 = 20 solmua, joiden korkeutena on h (yksinomaan juurisolmu on korkeudella h) 2 = 21 solmua, joiden korkeutena on h – 1 (juuren molemmat lapset) 4 = 22 solmua, joiden korkeutena on h – 2 (juuren lapsisolmujen lapset) … 2i solmua sijaitsee korkeudella h – i kaikille i = 0, 1, …, h 2h solmua sijaitsee korkeudella 0 (alimman tason solmut)

6.3 Keon rakentaminen Solmujen korkeuksien summaksi saadaan nyt S = (h – j) = h + 2(h – 1) + 4(h – 2) + … + 2h-1(h – (h – 1)) = 1 Muodostetaan laskennan helpottamiseksi kaksinkertainen summa … S = 2h + 4(h – 1) + 8(h – 2) + … + 2h …, josta sittemmin vähennetään alkuperäinen summa: 2S – S = (0 – h) + (2h – (2h – 2)) + (4h – 4 – (4h – 8)) + … + 2h-1(h – (h – 2)) + 2h(h – (h – 1)) = -h … + 2h-1 + 2h /* Nyt lisätään ja vähennetään ykkönen. */ = -h + ( … + 2h) – = -h + ( … + 2h) – = -h + (2h+1 – 1) – 1 = 2h+1 – h – 2 Edellä oletettiin, että keko olisi täysi. Jos puolestaan keko on vajaa, jää sen solmujen korkeuksien summa edellä esitettyä pienemmäksi. Aikaisemmin ratkaistiin, että n-alkioisen keon juuren korkeus h = log2n, joka on ≤ log2n. Sijoittamalla tämä tulos edelliseen korkeuksien summaan todetaan, että keossa, jossa on yhteensä n alkiota, solmujen korkeuksien summa on enintään S = 2h+1 – h – 2 < 2h+1 ≤ 2log2n+1 = 2 ∙ 2log2n = 2n. Koska solmujen korkeuksien summa on pienempi kuin 2n, voidaan todeta, että keon rakentaminen tosiaankin onnistuu lineaarisessa ajassa alkioiden määrän suhteen.

6.4 Kekolajittelualgoritmi
Lopuksi esitetään vielä varsinainen kekolajittelualgoritmi, jossa aluksi perustetaan keko, ja sen valmistuttua siitä irrotetaan aina suurin alkio, joka viedään vektorin loppuosaan oikealle paikalleen. Tilalle juureen viedään tilapäisesti keon viimeinen alkio. Aina, kun juuresta poistetaan suurin alkio, keko korjataan jälleen kelvolliseksi käyttämällä aiemmin esiteltyä korjausalgoritmia. Algoritmi toimii minimitilassa, eli se vaatii toimiakseen ainoastaan vakiomäärän muistia syötevektorin lisäksi. KEKOLAJITTELU(A) 1 MUODOSTA_MAKSIMIKEKO(A) 2 FOR i := pituus[A], pituus[A] – 1, …, 3, 2 DO vaihda A[1] <---> A[i] KeonKoko[A] := KeonKoko[A] – KORJAA_MAKSIMIKEKO(A, 1) Algoritmin kompleksisuus:  Keon muodostaminen rivillä 1: (n)  Riviltä 2 alkavaa silmukkaa suoritetaan n – 1 kertaa, jonka sisällä:  Rivit 3-4 ovat vakioaikaisia  Rivin 5 korjausalgoritmi vaatii (log2n) suuruisen työn Siten T(n) = (n) + (n – 1) ∙ (log2n) = (n) + (n) ∙ (log2n) = (nlog2n) Luennolla esitetään esimerkki kekolajittelun toiminnasta yksittäiselle syötevektorille.

6.5 Prioriteettijonot Töidenjärjestelyongelmien yhteydessä on tarpeellista pitää kirjaa siitä, mikä työ otetaan odottamassa olevien töiden jonosta ensimmäisenä käsittelyyn.  odottavilla töillä on jokin keskinäinen prioriteetti, joka vaikuttaa työn käsittelyyn ottamisen ajankohtaan Kun yksi työ saadaan valmiiksi, valitaan seuraavaksi käsittelyyn se odottamassa oleva työ, jolla on korkein prioriteetti.  tähän tarkoitukseen sopii erinomaisesti maksimikeko tietorakenteeksi Prioriteettijonosta on selvästikin pystyttävä ottamaan korkeimman prioriteetin mukainen työ pois; samoin sinne pitää pystyä lisäämään uusia töitä. Lisäksi saattaa olla tarpeen muuttaa jonkin jonossa olevan työn prioriteettia. Seuraavaksi esitellään operaatiot: ) LISÄÄ(S, x) ) MAKSIMI(S) ) POISTA_MAKSIMI(S) ) KASVATA_ARVOA(S, x, k)  Kyseisissä algoritmeissa parametri S edustaa tarkasteltavaa prioriteettijonoa, x sen solmun indeksiarvoa ja k kyseiseen solmuun asetettavaa uutta avainarvoa.

6.5 Prioriteettijonot Aloitetaan maksimin palauttavasta algoritmista: MAKSIMI(A) 1 IF KeonKoko[A] < THEN virheilmoitus ”Keko on tyhjä.” ELSE RETURN A[1]  Kyseessä on vakioaikainen algoritmi, eli syötteen koko ei mitenkään vaikuta sen suoritusaikaan: T(n) = (1). Seuraavaksi esitellään maksimiarvon keosta poistava algoritmi: POISTA_MAKSIMI(A) 1 IF KeonKoko[A] < THEN virheilmoitus ”Keko on tyhjä.” ELSE max := A[1] A[1] := A[KeonKoko[A]] /* Siirtää keon viimeisen alkion juureen */ KeonKoko[A] := KeonKoko[A] – KORJAA_MAKSIMIKEKO(A, 1) RETURN max Algoritmin suoritusaika on sama kuin keon korjausalgoritmin eli (log2n).

6.5 Prioriteettijonot Seuraavaksi avainarvon (prioriteetin) kasvattaminen: KASVATA_ARVOA(A, i, avain) 1 IF avain < A[i] THEN virheilmoitus ”Uusi avainarvo ei saa olla aikaisempaa pienempi.” ELSE A[i] := avain WHILE i > 1 AND A[VANHEMPI(i)] < A[i] DO vaihda A[i] <---> A[VANHEMPI(i)] i := VANHEMPI(i)  Kannattaa huomioida, että solmusta i alaspäin keko-ominaisuus säilyy, sillä aikaisempi avainarvo ei pienene.  Algoritmin kompleksisuus on (log2n): pahimmassa tapauksessa kuljetaan keon pisin polku ylöspäin lehdestä juureen. Lopuksi esitellään vielä alkion lisääminen kekona toteutettuun prioriteettijonoon: LISÄÄ(A, avain) 1 KeonKoko[A] := KeonKoko[A] A[KeonKoko[A]] := - 3 KASVATA_ARVOA(A, KeonKoko[A], avain) Lisäysalgoritmin suoritusaika on sama kuin avainarvon kasvatusalgoritmin eli (log2n).  Tarkastellaan viimeksi esitellyistä algoritmeista esimerkkejä luennolla.

Hajota- ja hallitse -tekniikan soveltaminen pikalajitteluun
7.1 Algoritmi Pikalajittelu on esiteltiin jo 50 vuotta sitten vuonna Sen kehittäjä on C.A.R. Hoare. Samoin kuin limityslajittelu, niin myös pikalajittelu käyttää hajota ja hallitse -tekniikkaa. Pikalajittelun pahin tapaus on Asymptoottisesti suuruusluokkaa (n2), mutta keskimäärin menetelmä toimii ajassa (n log2n).  pahin tapaus esiintyy erittäin harvoin (silloin, kun syötevektori on jo valmiiksi lajiteltuna, tai syötevektorin ositus tapahtuu jatkuvasti mahdollisimman epäedullisesti)  keskimääräisen tapauksen vakiokerroin pieni, joten menetelmä toimii käytännössä sekä limitys- että kekolajittelua nopeampi Algoritmin toimintaperiaatteena on syötevektorin osittaminen eli ns. partitiointi kahteen alueeseen yhden määrätyn alkion suhteen. Kyseistä alkiota kutsutaan pivot-alkioksi. Hajota- ja hallitse -tekniikan soveltaminen pikalajitteluun Hajottaminen: Partitioidaan vektori A[p..r] kahdeksi osavektoriksi A[p..q-1] ja A[q+1..r] siten, että osassa A[p..q-1] esiintyy ainoastaan pienempiä ja yhtä suuria alkioita kuin A[q], ja vastaavasti osan A[q+1..r] kaikki alkiot ovat suurempia tai yhtä suuria kuin A[q]. Hallitseminen: Lajitellaan partitioinnin synnyttämät kaksi osavektoria rekursiivisesti, kunnes osavektori puristuu korkeintaan yhden mittaiseksi. Yhdistäminen: Ei tarvitse tehdä yhtään mitään: kun kaikki partitioinnit on saatettu loppuun asti, vektori on samalla saatu jo lajiteltua! Ilmeinen ero: limityslajittelussa osittaminen on halpaa mutta ratkaisujen yhdistäminen vaatii työtä, kun taas pikalajittelussa kaikki työ tarvitaan ositukseen: yhdistäminen saadaan ”kaupan päälle”.

7.1 Algoritmi Pikalajittelualgoritmi on esiteltynä seuraavanlainen: PIKALAJITTELU(A, p, r) 1 IF p < r THEN q := PARTITIOI(A, p, r) PIKALAJITTELU(A, p, q – 1) PIKALAJITTELU(A, q+1, r) Ylimmän tason kutsu on muotoa PIKALAJITTELU(A, 1, pituus[A])  Algoritmi suoritetaan, mikäli tarkasteltava osavektori on vähintään kahden mittainen Suoritus koostuu funktion PARTITIOI kutsusta, joka määrää seuraavan alkion, joka määrää osavektorien toisen indeksirajan rivien 3 ja 4 rekursiivisille kutsuille.  Toiminta-ajatus: jokainen rekursiotaso vie rivin 2 suorituksen jälkeen määräytyvän pivot alkion vektorissa oikealle paikalleen. Lisäksi tulee voimaan ominaisuus, että kyseisen alkion eli A[q]:n vasemmalle puolelle sijoitetaan pelkästään tämän kanssa korkeintaan yhtä suuria alkioita, ja oikealle puolelle pelkästään A[q]:n kanssa suurempia tai yhtä suuria alkioita. Seuraavaksi esitellään partitioinnin suorittava algoritmi.

7.1 Algoritmi PARTITIOI(A, p, r) 1 x := A[r] /* Algoritmi tekee osavektorin viimeisestä alkiosta pivot-alkion */ 2 i := p – FOR j := p, p + 1, …, r – 1 DO IF A[j]  x THEN i := i vaihda A[i] <--->A[j] 7 vaihda A[i+1] <---> A[r] 8 RETURN i  Partitiointialgoritmin aikakompleksisuus on (n), sillä se sisältää vain vakioaikaisia asetus ehto- ja palautuslauseita, sekä silmukan, jossa tehdään enintään n – 1 kierrosta. Esitellään luennolla partitiointialgoritmin toiminta (ja samalla pikalajittelun alkuvaiheet) syötteelle A = 19, 11, 37, 8, 62, 3, 9, 28, 26, 30 (sama syöte kuin 1. demonstraatioiden tehtävässä 4)

7.2 Algoritmin analyysi Aloitetaan pikalajittelun analyysi tarkastelemalla pahinta tapausta. Pahimmassa tapauksessa käy aina niin huono tuuri, että pivot-alkioksi päätyy joka kerta tarkasteltavan osavektorin joko suurin tai pienin alkio  Tällöin pivot-alkion toispuoleinen osite jää tyhjäksi, ja toiselle puolelle päätyvät kaikki muut ositukseen osallistuvat alkiot (paitsi pivot-alkio itse).  Saadaan seuraavanlainen rekursioyhtälö: T(n) = T(n – 1) + T(0) + (n) /* pitkän ositteen lajittelu + tyhjän ositteen lajittelu + ositus */ = T(n – 1) + (n) /* olettaen karkeasti, että T(0) = 0 */  Tämä voidaan siten lausua muodossa T(n) = T(n – 1) + cn Lähdetään nyt iteroimaan edellä olevaa rekursioyhtälöä. Saadaan: T(n) = T(n – 1) + cn = T(n – 2) + c(n – 1) + cn = T(n – 3) + c(n – 2) + c(n – 1) + cn … = T(0) + c + 2c + 3c + … + c(n – 1) + cn = 0 + c( … + n) = cn(n + 1)/2 = (c/2)n2 + (c/2)n  Pahimmassa tapauksessa pikalajittelu vaatii siten neliöllisen suoritusajan, eli T(n) = (n2).

7.2 Algoritmin analyysi Tarkastellaan sitten parasta tapausta.
Parhaassa tapauksessa pivot-alkio jakaa ositettavan osavektorin mahdollisimman keskeltä  Tällöin pivot-alkion toiselle puolelle päätyy n/2 alkiota ja toiselle puolelle n/2 – alkiota.  Kumpaakin lauseketta voidaan arvioida ylöspäin arvoon n/2, niin päästään eroon lattia- ja kattofunktioiden merkinnöistä  Saadaan siten seuraavanlainen rekursioepäyhtälö: T(n)  2T(n/2) + (n) /* kummankin likimain yhtä pitkän ositteen ratkaiseminen + ositus */  Tämä voidaan lausua nyt muodossa T(n)  2T(n/2) + dn  Muistuttaa hyvin paljon limityslajittelun rekursiivista kustannusta, mutta nyt on kyseessä epäyhtälö yhtälön sijaan Lähdetään nyt iteroimaan edellä olevaa rekursioepäyhtälöä. Saadaan: T(n)  2T(n/2) + dn  2(2T(n/4) + dn/2) + dn = 22T(n/4) + 2dn  22(2T(n/8) + dn/4) + 2dn = 23T(n/8) + 3dn  23(2T(n/16) + dn/8) + 3dn = 24T(n/24) + 4dn  25T(n/25) + 5dn …  2iT(n/2i) + idn Mikäli oletetaan, että T(1) = c (siis vakio), ratkaistaan, milloin T:n argumentti n/2i saa arvon 1.

7.2 Algoritmin analyysi  Ratkaistaan yhtälö n/2i = 1  n = 2i  i = log2n …  … ja sijoitetaan saatu i:n arvo edellisen sivun epäyhtälön yleiseen muotoon: T(n)  2iT(n/2i) + idn /* Sijoitus: i = log2n */ = 2log2nT(n/2log2n) + log2ndn /* Laskusääntö: 2log2n = n */ = nc + log2n  dn  cnlog2n + dnlog2n /* Voimassa, kun n  2 */ = (c + d)nlog2n /* Termit c ja d ovat vakioita. */  Parhaassa tapauksessa pikalajittelu vaatii siten suoritusajan, eli T(n) = (nlog2n). Partitiointialkion valinnasta: Edellä esitetyssä pikalajittelun versiossa pivot-alkioksi valittiin joka kerta tarkasteltavan osavektorin viimeinen alkio.  Toimii ihan kelvollisesti, mikäli alkioiden järjestys vektorissa on täysin satunnainen ja duplikaatit ovat harvinaisia.  Edellä kuitenkin jo todettiin, että vektorin ollessa jo alun perin lajiteltuna suoritusajaksi tulee neliöllinen, sillä edellä esitetyllä tekniikalla osavektorin suurimmasta alkiosta tulee joka kerta väkisin pivot-alkio: partiointi jättää aina toisen osavektoreista tyhjäksi.  Samoin kävisi, jos ensimmäinen alkio päätyisi pivot-alkioksi.  Pulma: miten estetään huonojen ositusten syntyminen?

7.3 Pikalajittelun satunnaistettu versio
Pikalajittelun satunnaistetun version tarkoituksena on yrittää päästä eroon toistuvista huonoista vektorin osituksista. Seuraavassa on tarkoitus osoittaa, että samoin kuin parhaassa, niin myös keskimääräisessä tapauksessa pikalajittelu toimii ajassa (nlog2n). Satunnaistetuille algoritmeille on ominaista, että niiden suoritusaikaan vaikuttaa paitsi syötteen koko, niin myös satunnaislukugeneraattorin tuottamat arvot. Seuraavassa oletetaan, että funktio SATUNNAISLUKU(p, r) palauttaa mielivaltaisen kokonaisluvun väliltä p..r. Edelleen oletetaan, että funktion tulosteet noudattavat tasaista todennäköisyysjakaumaa, eli funktio palauttaa minkä tahansa luvun annetulta alueelta todennäköisyydellä 1/(r – p + 1).  Esimerkiksi SATUNNAISLUKU(5, 14) palauttaa minkä tahansa luvun väliltä todennäköisyydellä 1/10. Lisäksi tehdään satunnaistetun pikalajittelun analyysiä varten oletus, että syötteenä saatavan lajiteltavan vektorin A[1..n] kaikilla mahdollisilla permutaatioilla on keskenään sama esiintymistodennäköisyys. Esitellään ensiksi satunnaistettua partitiointia … SATUNNAISTETTU_PARTITIOINTI(A, p, r) 1 i := SATUNNAISLUKU(p, r) 2 vaihda A[r] <---> A[i] 3 RETURN PARTITIOI(A, p, r)

… ja sitten satunnaistettua pikalajittelua suorittava algoritmi: SATUNNAISTETTU_PIKALAJITTELU(A, p, r) 1 IF p < r 2 THEN q := SATUNNAISTETTU_PARTITIOINTI(A, p, r) SATUNNAISTETTU_PIKALAJITTELU(A, p, q – 1) SATUNNAISTETTU_PIKALAJITTELU(A, q + 1, r) Analysoidaan seuraavaksi satunnaistetun pikalajittelun vaatima suoritusaika. Koska satunnaislukugeneraattori tuottaa luvun väliltä 1..n todennäköisyydellä 1/n, on syötteen minkä tahansa alkion todennäköisyys päätyä pivot-alkioksi 1/n. Olettaen, että pivot-alkio sijoittuu syötevektorissa paikkaan q, saadaan suoritusajan rekursioyhtälöksi T(n) = T(q – 1) + T(n – q) + (n)  Yhtälön oikealla puolella ensimmäinen termi kuvaa pivot-alkion vasemmalle puolelle jäävien alkioiden lajitteluaikaa, toinen termi pivot-alkion oikeanpuoleisen osavektorin lajitteluaikaa sekä viimeinen termi partitioinnin kustannusta. Lasketaan seuraavaksi suoritusaikojen keskiarvo, kun pivot-alkion lopullisen sijainnin annetaan vaihdella vapaasti:

T(n) = (1/n) (T(q – 1) + T(n – q)) + (n) = (1/n) ((T(0) + T(1) + … + T(n – 2) + T(n – 1)) + (T(n – 1) + T(n – 2) + … + T(1) + T(0))) + (n) = (2/n) T(q) + (n)  Siten saadaan (1): T(n) = (2/n) T(q) + cn Kerrotaan edellinen yhtälö puolittain syötteen koolla n, niin päästään eroon murtoluvusta: (2): nT(n) = T(q) + cn2 Sijoitetaan näin saatuun yhtälöön arvo n – 1 termin n paikalle: (3): (n – 1)T(n – 1) = T(q) + c(n – 1)2 Vähennetään yhtälöstä (2) yhtälö (3): nT(n) – (n – 1)T(n – 1) = 2T(n – 1) + 2cn – c  (4): nT(n) = (n + 1)T(n – 1) + 2cn – c /* Jaetaan puolittain n:llä */  (5): T(n) = ((n + 1)/n)T(n – 1) + 2c – c/n

Kun n kasvaa rajatta, tulee vähentävästä termistä c/n vähitellen merkityksetön, joten se voidaan jättää jatkossa pois yksinkertaisuuden vuoksi:  Jaetaan seuraavaksi yhtälö (5) luvulla n + 1, jolloin saadaan: =  Tästä yhtälöstä saadaan edelleen iteroimalla: = = = … =  Lausuttaessa T(n):n arvo T(1):n avulla saadaan: = c

Lukua Hn = = 1 + ½ + 1/3 + … + 1/n kutsuntaan n. harmoniseksi luvuksi. Hn  dx = 1 + ln n. Tiedetään, että suurilla luvuilla Hn  ln n + , missä   on niin sanottu Eulerin vakio. Täten Hn = (n).  Tämän tarkastelun perusteella: = c = (ln n)  Tästä seuraa edelleen, että T(n) = (n ln n) = (nlog2n)

8 Lajittelu lineaarisessa ajassa
8.1 Alkioiden välisiin vertailuihin perustuvasta lajittelusta Kaikki tällä kurssilla tähän mennessä käsitellyt lajittelualgoritmit ovat perustuneet alkioparien välisiin vertailuihin, minkä perusteella niiden järjestys on määräytynyt. Tarkastellaan seuraavassa, miten lisäyslajittelun suorittama päätöksenteko etenee, kun sille annetaan lajiteltavaksi 3-alkioinen vektori. Seuraavassa vielä lisäyslajittelualgoritmin pseudokoodi muistin virkistämiseksi: LISÄYSLAJITTELU(A) 1 FOR j := 2, 3, …, pituus[A] DO alkio := A[j] i := j – WHILE i > 0 AND A[j] > alkio DO A[i + 1] := A[i] i := i – A[i + 1] := alkio Kiinnitetään seuraavassa huomio ainoastaan algoritmin tekemiin vertailuihin.  Muodostuu seuraavalla sivulla esitetyn kaltainen päätöspuu, jonka sisäsolmuissa tapahtuu vertailuun perustuva haarautuminen, ja mahdolliset syöttöjärjestykset sijaitsevat lehtisolmuissa.

8.1 Alkioiden välisiin vertailuihin perustuvasta lajittelusta
Lisäyslajittelun päätöspuu, kun syötteen koko on kolme: KYLLÄ EI KYLLÄ EI KYLLÄ EI KYLLÄ EI KYLLÄ EI a1  a2 a1  a3 a2  a3 a1  a3 a2, a1, a3 a2  a3 a1, a2, a3 a1, a3, a2 a3, a1, a2 a2, a3, a1 a3, a2, a1 Lehtinä (vihreät solmut) esiintyvät syötteen kaikki mahdolliset 6 permutaatiota. Kutakin syöttövaiheen suuruusjärjestystä vastaa yksikäsitteinen polku juuresta lehteen.

Eri lajittelumenetelmillä on erilainen päätöspuu. Olipa kuitenkin kyseessä mikä tahansa pareittaisiin vertailuihin perustuva lajittelumenetelmä, syötteen kaikkien mahdollisten permutaatioiden pitää esiintyä päätöspuun lehtinä  tämä vaatimus on ilmeinen, sillä lajittelumenetelmän tulee ratkaista ongelma kaikille mahdollisille laillisille syötteille! Mikäli syötteen koko on n, sen alkioista voi muodostaa n! kappaletta permutaatioita.  Esimerkki: n = 10, ja syöte sisältää luvut 1 – 10 jossain järjestyksessä. Ensimmäinen luku voidaan valita vapaasti väliltä 1 – 10. Toiseksi voidaan valita jäljelle jääneistä yhdeksästä mikä tahansa. … Yhdeksännen luvun valitsemiselle on enää kaksi vaihtoehtoa. Viimeiseksi on pakko valita se ainoa, jota ei ole vielä käytetty.  mahdollisia syöttöjärjestyksiä yhteensä 10  9  8  7  6  5  4  3  2  1 = 10! (eli ) kappaletta! Jo aikaisemmin olemme tämän kurssin aikana ehtineet todeta, että binääripuuhun, jonka korkeutena on h, mahtuu korkeintaan 2h lehteä. Tätä tietoa ja syötteen permutaatioiden lukumäärää hyväksi käyttäen pystytään laskemaan minkä tahansa lajittelumenetelmän päätöspuun minimaalinen korkeus h:  Pitää olla voimassa n!  2h  h  log2n! Seuraavaksi todistettava lause antaa teoreettisen optimaalisen aikakompleksisuuden alkioparien vertailuihin perustuville lajittelumenetelmille  Parempaan aikavaativuusluokkaan ei ole mahdollista päästä!

Lause: Mikä tahansa alkioiden vertailuun perustuva lajittelumenetelmä vaatii vähintään ⅟₄ nlog2n vertailua pahimmassa tapauksessa. Todistus: Syötteen kaikkien mahdollisten permutaatioiden pitää olla päätöspuun lehtinä edellisen tarkastelun perusteella, joten päätöspuun korkeus h on tällöin vähintään log2(n!) Arvioidaan seuraavaksi n!:n suuruusluokkaa: n! = n(n – 1)(n – 2)  …  3  2  Kertoman muodostavan tulon tekijät voidaan ryhmitellä seuraavasti: ) Suurimpiin n/2 :een, eli tekijöihin n, n – 1, n – 2, …, n/2 ) Pienimpiin n/2 :een, eli tekijöihin n/2, n/2 - 1, …, 2, Selvästikin pitää paikkansa, että n!  n/2 n/2  …  n/2, sillä jokainen ryhmään 1 kuuluvista termeistä on vähintään n/2:n suuruinen  n!  n/2n/2  (n/2)(n/2)

Siten voidaan päätellä: h  log2(n!)  log2(n/2)(n/2) = ½nlog2(n/2) = ½nlog2n – (n/2) log = ½nlog2n – (n/2)  ½nlog2n – ⅟₄nlog2n /* Voimassa ehdolla, että n  4 */ = ⅟₄nlog2n Tästä tuloksesta seuraa, että kooltaan n olevan syötteen lajittelemiseen tarvitaan vähintään ⅟₄nlog2n alkioparivertailua, eli jos halutaan päästä tätä nopeampaan asymptoottiseen suoritusaikaan, on käytettävä muuta lähestymistapaa kuin alkioparien välisiä vertailuja tekevään lajittelualgoritmiin. Seuraavaksi siirrytään tarkastelemaan näitä toisenlaista lähestymistapaa hyödyntäviin lajittelualgoritmeihin ja osoitetaan, että lajittelu lineaarisessa ajassa on tietyin reunaehdoin mahdollista. Nämä menetelmät eivät siis perustu alkioparien väliseen vertailuun.  päästään siis asymptoottisesti lyhyempään suoritusaikaan kuin (nlog2n), johon pystyvät mm. limitys- ja kekolajittelu sekä pikalajittelu keskimääräisessä tapauksessa  MUTTA: syötteiden pitää täyttää tietyt kriteerit, jotta olisi mahdollista päästä tehokkaampaan suoritusaikaan.

8.2 Laskentalajittelu Aloitetaan lineaarisessa ajassa toimivien lajittelumenetelmien esittely laskentalajittelusta. Laskentalajittelun taustaoletuksena on, että syötevektorin A[1..n] sisältönä on kokonaislukuja, joiden vaihteluväli on 0..k. Mikäli nyt k = (n), toimii algoritmi ajassa (n).  algoritmi toimii tehokkaasti, jos syötteen lukualue on verrattain kapea Algoritmin toiminta-ajatuksena on laskea eri alkioiden esiintymiskerrat syötevektorissa. Jokaista alkiota x kohti lasketaan, montako x:ää pienempää alkiota syötteessä on. Esimerkki: Jos käy ilmi, että vektorin A alkioista 21 on pienempiä kuin x, pitää x:n ensimmäinen esiintymä sijoittaa vektorissa paikkaan 22. Seuraavassa on esitettynä laskentalajittelualgoritmi: LASKENTALAJITTELU(A, B, k) /* Vektoria B käytetään tulosvektorina. */ 1 FOR i := 0, 1, …, k DO C[i] := 0 /* Alustetaan frekvenssivektorin jokainen positio nollalla. */ 3 FOR j := 1, 2, …, pituus[A] DO C[A[j]] := C[A[j]] + 1 /* Kasvatetaan syötevektorista löydetyn merkin frekvenssiä. */ 5 FOR i := 1, 2, …, k DO C[i] := C[i] + C[i – 1] /* Kumuloidaan frekvenssit. */ 7 FOR j := pituus[A], pituus[A] – 1, …, 1 DO /* Viedään A[j]:n esiintymät oikealta … */ B[C[A[j]]] := A[j] /* … vasemmalle tulosvektoriin B. */ C[A[j]] := C[A[j]] – 1

8.2 Laskentalajittelu Tarkastellaan luennolla laskentalajittelun toimintaa syötteelle A = < 6, 2, 11, 4, 3, 1, 6, 3, 0, 8, 10, 10, 5, 1, 1, 9, 13, 6, 1, 1, 9, 4, 5, 14, 2 >. olettaen, että syötettävien lukujen sallittu vaihteluväli on Seuraavaksi suoritetaan lisäyslajittelun analyysi: Rivejä 1 – 2 suoritetaan (k) kertaa.  Jokaisen syötteessä mahdollisesti esiintyvän merkin frekvenssi pitää nollata. Rivejä 3 – 4 suoritetaan (n) kertaa.  Tutkitaan syötteen merkit läpi yksi kerrallaan ja kirjataan niiden esiintymiskerrat. Rivejä 5 – 6 suoritetaan (k) kertaa.  Frekvenssivektori rullataan kertaalleen läpi. Rivejä 7 – 9 suoritetaan (n) kertaa.  Syötevektori käsitellään kertaalleen lopusta alkuun päin. Kokonaissuoritusajaksi määräytyy siten T(n)  c1k + c2n + c3k + c4n = (c1 + c3)k + (c2 + c4)n = d1k + d2n /* Tässä d1 = c1 + c3 ja d2 = c2 + c4)  ck + cn = c(k + n) Edellisessä c = max{d1, d2}.  T(n) = (n + k).

8.2 Laskentalajittelu Kannattaa huomioida, että laskentalajittelu ei toimi minimitilassa, sillä sen tarvitseman työmuistin määrä riippuu syötevektorin A sekä hyväksytyn lukualueen pituudesta k. Lajittelumenetelmän sanotaan olevan stabiili, mikäli se säilyttää syötteen sisältämät duplikaatit alkuperäisessä järjestyksessään.  Laskentalajittelu on stabiili lajittelumenetelmä, kun taas esimerkiksi kekolajittelu ei ole stabiili. Stabilisuus on toisinaan tarpeen – esimerkiksi haluttaessa lajitella kahdesti peräkkäin eri kriteerien mukaan hävittämättä ensimmäisen kriteerin mukaisen järjestyksen mukaisia välituloksia. Esimerkki: lajitellaan seuraavassa kerätyt henkilötiedot ensiksi sukunimen ja sittemmin stabiilisti syntymävuoden mukaan Vaihe 1: Vaihe 2: Enberg Enberg Heinonen Malinen Laaksonen Torikka Malinen Laaksonen Paju Tuominen Perho Paju Saarinen Saarinen Torikka Heinonen Tuominen Perho Välimäki Välimäki  Ellei olisi käytetty toisessa lajitteluvaiheessa stabiilia lajittelumenetelmää, ei aakkosjärjestyksen säilymisestä eri syntymävuosien sisällä olisi ollut varmuutta.

8.3 Kantalukulajittelu Kantalukulajittelu voidaan soveltaa parhaiten kokonaisluvuille, jotka ovat numeroesitykseltään kiinteän mittaisia (tarvittaessa käytetään täytteenä etunollia). Algoritmin toiminta-ajatuksena on lajitella numero kerrallaan aloittamalla vähiten merkitsevästä numerosta  ensiksi ykkösten, sitten kymmenten, tämän jälkeen satojen mukaan jne. Yksittäisen numeron mukainen lajitteluun voidaan käyttää jotain stabiilia lajittelumenetelmää kuten juuri edellä esiteltyä laskentalajittelua. Kantalukulajittelualgoritmi on lyhykäisyydessään seuraavanlainen: KANTALUKULAJITTELU(A, d) 1 FOR i := 1, 2, …, d DO Lajittele A:n alkiot stabiilisti paikan i mukaan oikealta vasemmalle Esitetään luennolla esimerkki, miten syöte A = < 329, 281, 457, 734, 586, 091, 657, 839, 838, 436, 115, 720, 611, 919 ja 355 > lajitellaan soveltamalla kantalukulajittelua.

8.3 Kantalukulajittelu 8.4 Nippulajittelu
Seuraavassa esitetään kantalukulajittelualgoritmin analyysi:  Oletukset: 1) lajiteltavia lukuja on yhteensä n kappaletta ) kantalukuna esiintyy k (esimerkiksi kymmenjärjestelmässä k = 10)  Jokaista numeroa kohti joudutaan suorittamaan laskentalajittelu, jonka suoritusaika yhtä numeroa kohti on (n + k).  Laskentalajitteluja tehdään yhteensä niin monta, kuin lajiteltavien lukujen numeroesityksessä on numeroita. Olkoon numeroiden lukumäärä d  Kantalukulajittelun aikakompleksisuudeksi saadaan siten O(d(n + k)).  Aikakompleksisuus on lineaarinen syötteen pituuden suhteen eli O(n), mikäli d ja k ovat vakioita. 8.4 Nippulajittelu Tällä kurssilla esitettävä nippulajittelun versio perustuu oletukseen, että lajiteltavat avaimet, jotka on tallennettu vektoriin A[1..n], ovat puoliavoimelle välille [0..1) sijoittuvia reaalilukuja.  Menetelmän tarkastelu ja analyysi yksinkertaistuvat oletuksen myötä.  Käytännön tilanteissa tehdään luonnollisestikin skaalaus halutulle vaihteluvälille. Algoritmin toiminta-ajatus:  Jaetaan lukualue [0, 1) yhteensä n:ään osaan seuraavasti: [0..1/n), [1/n..2/n), [2/n..3/n), …, [(n – 1)/n..1). Kutakin tällaista osaa vastaa yksi nippu B[0], B[1], B[2], …, B[n – 1]. Syötteen alkiot sijoitetaan kyseisiin nippuihin, jotka esitetään indeksipaikoista alkavina linkitettyinä listoina.

8.4 Nippulajittelu Nippulajittelun taustalla on oletus syötteen avaimien tasaisesta jakaumasta välillä [0..1).  Mikäli oletus pitää paikkansa, ei ole odotettavissa, että yhteen yksittäiseen nippuun päätyy kovinkaan monta syötevektorin alkiota. Kunkin nipun sisällä tehdään erikseen lajittelu. Kun jokainen nippu on sisäisesti lajiteltu, ei tarvitse muuta kuin yhdistää nippujen sisältämät lajitellut alkiolistat peräkkäin.  Nipun indeksi toimii nippujen välisenä suuruuserottimena: nipussa x sijaitsee isompia avainarvoja kuin nipussa y, jos x:n indeksi > y:n indeksi. Seuraavassa esitetään nippulajittelualgoritmi: NIPPULAJITTELU(A) 1 n := pituus[A] 2 FOR i := 1, 2, …, n DO Lisää A[i] linkitettyyn listaan, joka alkaa indeksipaikasta B[n  A[i] /* Lisäys tapahtuu aina listan alkuun. */ 5 FOR i := 0, 1, …, n – 1 DO Lajittele lista B[i] käyttämällä lisäyslajittelua 7 Yhdistä (eli katenoi) listat B[0], B[1], …, B[n – 1] Kannattaa huomioida, että lisäyslajittelu voidaan tarvittaessa muuntaa muotoon, joka tukee linkitettyjen listojen käsittelyä (lisäyslajittelun syötteen ei välttämättä tarvitse sijaita vektorissa).

8.4 Nippulajittelu Esitetään luennolla esimerkki, jossa lajitellaan seuraava syöte käyttämällä nippulajittelua: A = < 0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.49, 0.23, 0.63 >  Nippujen esittämiseen käytettävät linkitetyt listat sijoitetaan nippuvektoriin B indeksipaikkoihin  Nippuun B[i] sijoitetaan alkiot väliltä [i/10, …, (i + 1)/10). Algoritmin analyysi: 1) Pahin tapaus:  Taustalla olevasta tasaisen jakauman oletuksesta huolimatta syötteen kaikki n alkiota päätyvät kuitenkin yhteen ja samaan nippuun. Kyseistä nippua edustavan listan pituudeksi tulee siten n  Tämän listan lajittelu vie huonoimmassa (ja myös keskimääräisessä) tapauksessa aikaa (n2)  Siten myös koko nippulajittelun pahimman tapauksen suoritusaika on (n2). 2) Keskimääräinen (ja samalla myös paras) tapaus:  Algoritmissa on kaksi silmukkaa, joissa kummassakin tehdään n kierrosta  Alkion lisääminen nippuun B[i] vie vakioajan, sillä lisäys tapahtuu aina alkuun. Koska alkioita on n kappaletta, rivien 2 – 3 silmukkaa suoritetaan (n) kertaa  Jos alkiot ovat tasaisesti jakautuneet, kuhunkin nippuun tulee keskimäärin 1 alkio  Yhden alkion sisältävien nippujen B[i] lajitteleminen vie selvästikin vakioajan ci. Tuolloin yhteensä n kappaletta nippuja voidaan lajitella ajassa (n), sillä c0 + c1 + … + cn  cn, missä c = max{ci | 0  i  n – 1}  Listojen yhdistäminen tapahtuu ajassa (n), sillä ne vain linkitetään toistensa perään  Keskimääräinen kokonaissuoritusaika nippulajittelulle on siten (n).

9.1 Taulukon minimi ja maksimi
9 Valinta-algoritmit 9.1 Taulukon minimi ja maksimi Valinta-algoritmien tarkoituksena on löytää syötteen suuruusjärjestyksessä tietty – yleensä yksittäinen alkio. Syötteeksi annetaan lajittelualgoritmien tapaan vektori A[1..n]. Tulosteeksi halutaan useasti joko syötevektorin 1) minimi 2) maksimi 3) sekä minimi että maksimi samalla kerralla etsittyinä tai 4) järjestyksessä i. pienin alkio (1  i  n) Haluttiinpa näistä mikä tahansa, ongelma voidaan ratkaista triviaalisti lajittelemalla annettu syöte ja palauttamalla asetetut kriteerit täyttävä alkio  minimiä haettaessa lajitellun vektorin 1. alkio  maksimia haettaessa lajitellun vektorin n. alkio  molempia haettaessa sekä ensimmäinen että viimeinen alkio  järjestyksessä i. alkio löytyisi selvästikin indeksistä i On kuitenkin turhaa mennä lajittelemaan syötevektoria, jos ollaan kiinnostuneita ainoastaan yhdestä alkiosta (tai maksimi-minimi -parista), sillä  paras yleiskäyttöinen lajittelumenetelmä vaatii suoritusajan (nlog2n), kun taas yksittäisen alkion etsintä onnistuu lineaarisessa ajassa eli (n). Esitellään seuraavassa menetelmät edellä numeroin 1-4 lueteltujen alkioiden löytämiseksi.

Aloitetaan minimin (tai maksimin) etsinnästä (seuraavassa oletetaan, että syötevektori A ei ole tyhjä): MINIMI(A) MAKSIMI(A) 1 min := A[1] 1 max := A[1] 2 FOR i := 2, 3, …, pituus[A] DO 2 FOR i := 2, 3, …, pituus[A] DO IF min > A[i] IF max < A[i] THEN min := A[i] THEN max := A[i] 5 RETURN min 5 RETURN max Kummassakin tapauksessa joudutaan tekemään yhteensä n – 1 vertailuoperaatiota, mikäli syötteen alkiot voivat olla mielivaltaisessa järjestyksessä  algoritmit ovat optimaaliset – vähemmin vertailuin ei pärjätä! Yhteys käytäntöön: miten löydetään pudotuspelitekniikalla turnauksen paras n:stä osallistujasta?  muut paitsi voittaja häviävät tarkalleen kerran  voittajan lisäksi osallistujia on yhteensä n – 1 Pelkän minimin tai maksimin etsinnän aikakompleksisuus on siten (n).

Tarkastellaan seuraavaksi sekä minimin että maksimin etsintää. Selvästikin molemmat pystytään saamaan selville vertailumäärällä 2(n – 1), sillä voitaisiin ensinnä etsiä vain jompaakumpaa ja sen perään toista.  tarvitaan yhteensä erikseen minimin ja maksimin etsintään kuluva aika Tätä vähemmällä työllä on kuitenkin mahdollista selviytyä (joskaan ei asymptoottisesti).  Esitellään algoritmi MINMAX, joka löytää molemmat tekemällä vain 3n/2 vertailua Algoritmissa oletetaan, että vektori A ei ole tyhjä. MINMAX(A) FOR i := 1, 2, …, n/2 DO IF A[2i – 1] > A[2i] THEN vaihda A[2i – 1] <---> A[2i] min := A[1] FOR i := 3, 5, 7, …, 2n/2 - 1 DO IF min > A[i] THEN min := A[i] max := A[n] i := 2 10 WHILE i < n DO IF max < A[i] THEN max := A[i] i := i RETURN (min, max) Algoritmin toimintaperiaate: verrataan paikoissa 2i – 1 ja 2i olevia alkioita keskenään kaikille i:n arvoille väliltä 1..n/2. Sijoitetaan aina pienempi näiden parien alkioista parittomaan ja suurempi parilliseen indeksiin. Jos n on pariton, jää viimeinen alkio toistaiseksi käsittelemättä. Tämän jälkeen etsitään minimiä pelkästään parittomista indeksipaikoista ja maksimia pelkästään parillisista sekä vertailematta jääneestä viimeisestä indeksistä, jos n on pariton (sieltä voi löytyä yhtäläisesti minimi tai maksimi).

Tarkastellaan luennolla esimerkkiä, kun syötevektorina esiintyy A = < 7, 3, 2, 4, 9, 1, 5, 2, 6 > Algoritmin analyysi: 1) Jos n on parillinen, niin vertailujen määrä on: n/2 + (n/2 – 1) + (n/2 – 1) = 3n/2 – 2  3n/2 2) Jos n on puolestaan pariton, niin vertailuja tehdään: n/2 + (n/2 – 1) + (n/2 – 1) + 2 = 3n/2 Kummassakin tapauksessa joudutaan tekemään enintään 3n/2  1½n

9.2 Valinta keskimäärin lineaarisessa ajassa
Tarkastellaan seuraavaksi ”pikavalintaa”, joka muistuttaa toteutukseltaan melkoisesti pikalajittelua. Pikavalinta palauttaa tarkasteltavan osavektorin A[p..r] i. alkion. Lisäksi oletetaan, että parametrin i valinta on kelvollinen, eli 1  i  r – p + 1, eli tarkasteltavassa osavektorissa on tarpeeksi eli vähintään i alkiota. Pikavalintaa suorittava algoritmi (satunnaistettu versio) on esitetty seuraavassa: SATUNNAISTETTU_VALINTA(A, p, r, i) 1 IF p = r THEN RETURN A[p] 3 q := SATUNNAISTETTU_PARTITIOINTI(A, p, r) 4 k := q – p IF i = k THEN RETURN A[q] 7 ELSE IF i < k THEN RETURN SATUNNAISTETTU_VALINTA(A, p, q – 1, i) 9 ELSE RETURN SATUNNAISTETTU_VALINTA(A, q + 1, r, i – k) Toiminta-ajatus: tutkitaan, mikä on syöteparametri i:n arvo suhteessa pivot-alkion lopulliseen sijoituspaikkaan q.  1) jos i = k, saadaan vastaus heti palauttamalla A[q]:n arvo 2) jos i < k, jatketaan etsimällä järjestyksessä i. alkiota nyt ensimmäisestä osavektorista 3) jos i > k, jatketaan etsimällä järjestyksessä i – k. alkiota jälkimmäisestä osavektorista  Tapauksessa 3 on jo ehditty ohittaa syötevektorin alusta k alkiota pudottamalla ensimmäinen osavektori ja pivot-alkio jatkotarkastelujen ulkopuolelle!

= 2c/n (½(n2 – n) – ½(⅟₄n2 – 3n/2 + 2)) + an = c/n (¾n2 + ½n – 2) + an = c(¾n + ½ – 2/n) + an  ¾cn + ½c + an = cn – (⅟₄cn – ½c – an) Jotta termi cn kelpaisi suoritusajalle ylärajaksi, pitää nyt vielä osoittaa, että ⅟₄cn – ½c – an  0, kun n on tarpeeksi iso  Lisätään yhtälöön puolittain vakio c/2, niin saadaan: ⅟₄cn – an  ½c  n(⅟₄c – a)  ½c  Olettaen, että vakio c on valittu siten, että c > 4a, voidaan jakaa puolittain termillä ⅟₄c – a, joka on nyt > 0:  n  ½c / (⅟₄c – a) = 2c / (c – 4a) /* Lavennetaan nelosella. */  Kun n > 2c / (c – 4a), niin tällöin on voimassa T(n)  cn. Tämän lisäksi oletetaan, että T(n) = (1), kun n < 2c / (c – 4a) Äskeisen analyysin perusteella i. alkio voidaan siten löytää keskimäärin lineaarisessa ajassa.

10 Perustietorakenteet 10.1 Pinot ja jonot 6 10 5 7 13 7 5 10 6 13
Pino on tietorakenne, jonne alkioita voi lisätä ainoastaan päällimmäiseksi, ja ainoastaan viimeksi pinoon tuotuun alkioon päästään tarkasteluhetkellä käsiksi.  Viimeksi pinoon tuotu alkio poistetaan ensimmäiseksi.  Lisäys- ja poisto-operaatiot kohdistuvat pinossa samaan kohtaan. Analogia reaalimaailmasta: bussikuskin tai torimyyjän siilomainen kolikkolipas tietojenkäsittelystä: rekursiopino pinon huippu jonon alku ja loppu Jono on puolestaan tietorakenne, jonne lisääminen tapahtuu loppuun ja jossa poisto kohdistuu aina alkuun.  Kauimmin jonossa ollut poistetaan ensiksi Analogia reaalimaailmasta: kaupan kassajonon eteneminen (ilman etuilua … !) Siitä huolimatta, että pino ja jono ovat luonteeltaan dynaamisia rakenteita – s. o. niiden koot vaihtelevat herkästi, ne voidaan kuitenkin hyvin toteuttaa staattisella tietorakenteella: vektorilla  Vektorille pitää kuitenkin varata tarpeeksi paljon muistia, ettei pino/jono täyty vastoin ennakko-odotuksia.  Seuraavassa tullaan esittelemään pinoja ja jonoja käsittelevät algoritmit siten, että taustalla olevana perustietorakenteena on käytetty juuri vektoria. 6 10 5 7 13 7 5 10 6 13

10.1 Pinot ja jonot ENSIN PINOISTA … Pino toteutetaan seuraavassa vektorin S[1..n] avulla. Pinolla S on olemassa attribuutti huippu[S]:  osoittaa pinoon viimeksi viedyn alkion indeksin pinovektorissa. huippu[S] = 0, jos pinossa S ei ole yhtään alkiota (eli se on tyhjä) Pinoon S ovat tallennettuina alkiot S[1..huippu[S]]. Paikasta S[1] löytyy pinon pohjimmainen alkio. Vastaavasti paikasta S[huippu[S]] löytyy pinon päällimmäisin alkio. Seuraavassa pienoinen esimerkki pinovektorista: S = huippu[S] Seuraavalla algoritmilla voidaan testata, onko pino tyhjä. PINO_TYHJÄ?(S) 1 IF huippu[S] = THEN RETURN tosi 3 ELSE RETURN epätosi Kyseinen algoritmi toimii vakioajassa (1). 13 7 5 10 6

10.1 Pinot ja jonot Seuraava algoritmi lisää alkion pinoon:
LISÄÄ_PINOON(S, x) huippu[S] := huippu[S] S[huippu[S]] := x Uusi alkio asetetaan pinoon siirtämällä huipun sijaintia yhdellä eteenpäin ja asettamalla alkio päällimmäiseksi Myös tämä algoritmi toimii vakioajassa (1). Alkion poistaminen pinosta tapahtuu puolestaan seuraavasti: POISTA_PINOSTA(S) 1 IF PINO_TYHJÄ?(S) THEN virheilmoitus ”Pinon alivuoto” 3 ELSE huippu[S] := huippu[S] – RETURN S[huippu[S] + 1] Pinosta poistetaan selvästikin päällimmäisin alkio. Poistamisyritys tyhjästä pinosta täytyy estää alivuodon välttämiseksi. Tämäkin pinoalgoritmi toimii vakioajassa (1).

10.1 Pinot ja jonot … JA SITTEN JONOISTA Samoin kuin pinot edellä, myös jonot toteutetaan seuraavassa vektorin avulla. Jonovektori Q on indeksoitu välille 1..n. Jonolla Q on olemassa seuraavat kaksi attribuuttia: alku[Q]  osoittaa jonoon ensimmäiseksi viedyn alkion indeksin jonovektorissa (ellei ole kyseessä tyhjä jono). loppu[Q]  osoittaa jonon ensimmäisen vapaan paikan, jonne alkion lisääminen tapahtuu. Mikäli alku[Q] = loppu[Q], tällöin jono on tyhjä. Lähtötilanteessa alku[Q] = loppu[Q] = 1. Jonon alkiot sijaitsevat paikoissa alku[Q], alku[Q] + 1, …, loppu[Q] – 1.  mikäli loppupään indeksit ovat jostain indeksiarvosta lähtien > n, pitää tätä seuraavien alkioiden sijaintipaikan määräämiseksi ottaa jakojäännnösoperaatio n:n suhteen (indeksi modulo n), sillä jono voi jatkua ”syklisesti” indeksistä 1.  vektorin alkukohta siirtyy yhdellä eteenpäin, kun jonosta poistetaan alkio, paitsi silloin, kun alku[Q] = n. Kun kyseinen alkio aikanaan poistetaan, asetetaan alku[Q] := 1.  on aivan mahdollista, että alku[Q] > loppu[Q]: tällöin jonon häntä jatkuu vektorin alusta. Jonoon voidaan sijoittaa maksimissaan n – 1 kappaletta alkioita. Indeksiin loppu[Q] ei koskaan sijoiteta mitään, jotta pystyttäisiin erottamaan toisistaan tilanteet, milloin jono on tyhjä ja milloin täysi.

10.1 Pinot ja jonot Esimerkki tilanteesta, jossa jonoa joudutaan jatkamaan vektorin alusta: Tilanne ennen alkioiden 11 ja 19 lisäämistä silloin, kun jonon alku sijaitsee paikassa 7 ja loppu paikassa 11: alku[Q] loppu[Q] Q = Alkio 11 voidaan sijoittaa nyt vektorin loppuun, mutta loppukohta siirtyy nyt indeksiin 1, … loppu[Q] alku[Q] Q = … jonne alkio 19 sijoitetaan alku[Q] loppu[Q] Seuraavassa esitetään neljä algoritmia jonojen käsittelyä varten. 13 7 5 10 6 13 7 5 10 6 11 19 13 7 5 10 6 11

10.1 Pinot ja jonot Seuraava algoritmi testaa, onko jono jo täyttynyt:
JONO_TÄYSI?(Q) IF alku[Q] = (loppu[Q] + 1) mod n THEN RETURN tosi ELSE RETURN epätosi Algoritmi toimii vakioajassa (1). Alkion lisääminen jonoon tapahtuu puolestaan seuraavasti: LISÄÄ_JONOON(Q, x) 1 IF JONO_TÄYSI?(Q) THEN virheilmoitus ”Jonon ylivuoto” 3 ELSE Q[loppu[Q]] := x IF loppu[Q] = pituus[Q] THEN loppu[Q] := ELSE loppu[Q] := loppu[Q] + 1 Alkion lisääminen jonoon toimii selvästikin vakioajassa (1). Algoritmi huomioi mahdollisen tarpeen jatkaa jonoa vektorin Q alusta. Lisäksi jo täynnä olevaan jonoon tapahtuva alkion lisäämisyritys estetään.

10.1 Pinot ja jonot Seuraavaksi esitellään jonon tyhjyyden testaamisalgoritmi: JONO_TYHJÄ?(Q) IF alku[Q] = loppu[Q] THEN RETURN tosi ELSE RETURN epätosi Algoritmi toimii vakioajassa (1). Lopuksi esitellään vielä, miten alkion poistaminen jonosta tapahtuu: POISTA_JONOSTA(Q) 1 IF JONO_TYHJÄ?(S) THEN virheilmoitus ”Jonon alivuoto” 3 ELSE x := Q[alku[Q]] IF alku[Q] = pituus[Q] THEN alku[Q] := ELSE alku[Q] := alku[Q] RETURN x Alkion poistaminenkin jonosta onnistuu vakioajassa (1). Algoritmi estää poistamisyrityksen tyhjästä jonosta. Lisäksi huomioidaan, pitääkö jonon alkukohta siirtää vektorin ensimmäiseen positioon.

10.2 Linkitetyt listat Linkitetyt listat soveltuvat hyvin ns. dynaamisten joukkojen esittämiseen. Tällaisen joukon koko voi kasvaa tai pienentyä, tai sen ominaisuudet voivat muuttua algoritmin suorituksen ollessa käynnissä. Tyypillisiä listoille ovat ns. sanakirja- eli hakemisto-operaatiot:  uuden tietueen lisääminen  olemassa olevan tietueen poistaminen  tallennettuihin tietoihin kohdistuvat kyselyoperaatiot Esimerkkejä: puhelinluettelo, sanakirja, kirjaston tietokanta yms. Dynaamisen joukon alkiot ovat objekteja, joilla on 1) avain- eli tunnistekenttä (objektin identifioiva tieto) 2) satelliittidataa (muuta tallennettua tietoa avainarvon ohella) 3) osoitinkenttiä (viittauksia edeltäjään/seuraajaan – yleisesti: toisiin objekteihin) Koneen keskusmuistissa jokaisella muistipaikalla on yksikäsitteinen osoite, jonka perusteella päästään käsiksi muistipaikkaan tallennettuun tietoon. Osoitintietoa sisältävä muistipaikka sisältää viittauksen siihen muistipaikkaan, mistä varsinaiset tiedot löytyvät. Osoitintiedon käsittelemisessä sallittavat operaatiot vaihtelevat ohjelmointikielittäin. Esimerkiksi Javassa ja Pythonissa osoittimien käsittely on rajoitetumpaa kuin C:ssä.

10.2 Linkitetyt listat Linkitetty lista on rakenne, johon voidaan sijoittaa samantyyppisiä tietoja peräkkäin.  tässä ominaisuudessaan linkitetty lista muistuttaa vektoria MUTTA: listan mielivaltaiseen eli i. alkioon ei päästä suoraan käsiksi, vaan sinne on edettävä selaamalla tätä ennen sijaitsevat i – 1 alkiota läpi, kun taas taulukosta voidaan osoittaa milloin tahansa mitä muistipaikkaa tahansa (esimerkiksi x := A[i]). Jokainen listan alkioista sisältää ainakin yhden tulevan linkin, jota pitkin alkio on saavutettavissa. Viimeistä alkiota lukuun ottamatta alkioilla on myös seuraaja. Viittauksia merkitään monisteessa nuolilla (). Linkitetylle listalle on tyypillistä dynaamisuus, eli sen koko voi muuttua tarpeen niin vaatiessa. Uuden alkion lisäys tai vanhan poistaminen eivät aiheuta paljoa työtä, sillä muutokset ovat hyvin paikallisia. Yhteen suuntaan linkitetty lista Listan L kukin yksittäinen alkio x sisältää attribuutit: avain[x]: ilmaisee lista-alkioon x tallennettu avainarvon seuraava[x]: osoittaa x:ää seuraavaan alkioon Tyhjää osoitinta kuvaa algoritmeissa merkintä NIL, esimerkeissä kauttaviiva (/) Jos seuraava[x] = NIL, on x listan viimeinen alkio Koko listalla L on lisäksi olemassa attribuutti alku[L], joka viittaa listan L ensimmäiseen alkioon. Seuraavassa esimerkki yhteen suuntaan linkitetystä listasta: avain[x] alku[L] x seuraava[x] 14 3 7 18 /

10.2 Linkitetyt listat / 14 3 7 18 / Kahteen suuntaan linkitetty lista
Kuten yhteen suuntaan linkitetty lista, mutta nyt listan kukin yksittäinen alkio x sisältää lisäksi attribuutin: edellinen[x]: osoittaa x:ää edeltävään alkioon Jos edellinen[x] = NIL, on x listan ensimmäinen alkio Seuraavassa esimerkki kahteen suuntaan linkitetystä listasta L: z alku[L] edellinen[z] avain[z] seuraava[z] Kannattaa huomioida, että linkitetyt listat ovat usein järjestämättömiä. Seuraavaksi lähdetään esittelemään linkitetyille listoille sovellettavia operaatioita. Aloitetaan alkion hakemisella linkitetystä listasta. HAE_LISTASTA(L, k) x := alku[L] WHILE x  NIL AND avain[x]  k DO x := seuraava[x] RETURN x / 14 3 7 18 /

10.2 Linkitetyt listat Algoritmi HAE_LISTASTA palauttaa viittauksen ensimmäiseen sellaiseen lista-alkioon x, jolle on voimassa avain[x] = k. Ellei etsittyä avainta k löydy listasta L, paluuarvoksi tulee tyhjä osoitin NIL. Algoritmin analyysi:  Pahimmassa tapauksessa suoritusaika on (n). Pahin tapaus esiintyy silloin, kun haettu alkio esiintyy yksistään listan viimeisenä alkiona tai sitä ei löydy listasta laisinkaan.  Keskimääräisessä tapauksessa noin puolet alkioista on käytävä läpi, joten tällöinkin kompleksisuus on suuruusluokkaa (n). Tutkitaan seuraavaksi alkion lisäämistä kahteen suuntaan linkitettyyn listaan, kun lisäys tapahtuu listan alkuun. Lisättävällä alkiolla on olemassa kaikki lista-alkion attribuuttikentät (edellinen, avain, seuraava). LISÄÄ_LISTAAN(L, x) 1 seuraava[x] := alku[L] 2 IF alku[L]  NIL /* Lista L ei alun perin ollut tyhjä. */ THEN edellinen[alku[L]] := x 4 alku[L] := x 5 edellinen[x] := NIL Algoritmin kompleksisuus on (1): lisäys tehdään aina listan alkuun (listan pituudella ei väliä). Esitetään luennolla esimerkki, kun edellisen kalvon kahteen suuntaan linkitettyyn listaan, jossa avainarvoina ovat 14, 3, 7 ja 18, lisätään alkio 22.

10.2 Linkitetyt listat Seuraavaksi esiteltävä algoritmi POISTA_LISTASTA poistaa listan L solmualkion x, johon oletetaan olevan suoraan osoitin käytettävissä (alkiota ei tarvitse enää erikseen lähteä hakemaan). POISTA_LISTASTA(L, x) 1 IF edellinen[x]  NIL /* Ei olla poistamassa listan L ensimmäistä alkiota. */ THEN seuraava[edellinen[x]] := seuraava[x] ELSE alku[L] := seuraava[x] 4 IF seuraava[x]  NIL /* Poistettava alkio ei ole listan viimeinen alkio. */ THEN edellinen[seuraava[x]] := edellinen[x] Algoritmin suoritusaika on vakio eli O(1). Ellei suoraa osoitinta poistettavaan alkioon x kuitenkaan ole käytettävissä, tulee algoritmin suoritusajaksi O(n), eli suoritusaikaa dominoi alkion x etsintään kuluva aika. Esitetään luennolla esimerkki, jossa alkiot 22, 14, 3, 7 ja 8 sisältävästä listasta poistetaan solmu, joka sisältää avainarvon 7. Kuten edellä havaittiin, listasta alkiota poistettaessa pitää huomioida linkkien viittaamien alkioiden olemassaolo (kts. rivit 1 ja 4).  ellei näitä rajatestejä tarvitsisi tehdä, algoritmi yksinkertaistuisi seuraavanlaiseksi: POISTA_LISTASTA_U(L, x) 1 seuraava[edellinen[x]] := seuraava[x] 2 edellinen[seuraava[x]] := edellinen[x]

10.2 Linkitetyt listat Lyhennettyä versiota päästäisiin käyttämään, mikäli listaan asetetaan alkuun ns. pysäytys- eli otsakealkio, josta käytetään tunnistetta nil[L]. Pysäytysalkio on muuten aivan lista-alkion kaltainen, mutta sen avainkenttää ei tarvita mihinkään – vain osoitinkentät ovat tarpeen. Pysäytysalkion tehtävänä on tunnistaa listan päättyminen. Viittaus seuraava[nil[L]] osoittaa listan ensimmäiseen alkioon. Vastaavasti viittaus edellinen[nil[L]] osoittaa listan viimeiseen alkioon.  listasta muodostuu kaksi silmukkaa. Koska seuraava[nil[L]] osoittaa listan L alkuun, ei myöskään erillistä attribuuttia alku[L] tarvita. Tyhjä lista koostuu pelkästä pysäytysalkiosta nil[L]. Tyhjä lista pysäytysalkion avulla esitettynä: nil[L] Esimerkki ei-tyhjästä kahteen suuntaan linkitetystä listasta pysäytysalkiolla: nil[L] ? ? 14 3 7 18

10.2 Linkitetyt listat Seuraavassa vielä uusitut haku- ja lisäysalgoritmit, jos listan pysäytysalkio on käytettävissä (poistoalgoritmi esitettiinkin jo edellä): HAE_LISTASTA_U(L, k) x := seuraava[nil[L]] WHILE x  nil[L] AND avain[x]  k DO x := seuraava[x] RETURN x LISÄÄ_LISTAAN_U(L, x) seuraava[x] := seuraava[nil[L]] edellinen[seuraava[nil[L]]] := x seuraava[nil[L]] := x edellinen[x] := nil[L] Pysäytysalkion käyttöönotto jonkin verran yksinkertaistaa lista-algoritmeja.

10.3 Juurrettujen puiden esittäminen
Matemaattisesti määriteltynä puu on yhdistetty, syklitön graafi.  Jokainen puun solmuista on saavutettavissa  Siirtymällä eteenpäin seuraajalinkkiä pitkin ei päästä enää takaisin kuin isäosoittimia pitkin. Ei-tyhjällä puulla P on yksikäsitteinen juuri.  Juuri on solmu josta alaspäin puu kasvaa. Binääripuulla tarkoitetaan puuta, jonka kullakin solmulla on enintään kaksi lasta. Yksittäinen binääripuun solmu x on kuvaukseltaan seuraavanlainen eli sisältää seuraavat attribuutit:  avain[x]: sisältää solmuun x tallennetun avainarvon  vasen[x]: sisältää osoittimen x:n vasempaan lapsisolmuun  oikea[x]: sisältää osoittimen x:n oikeaan lapsisolmuun  vanhempi[x]: sisältää osoittimen x:n isäsolmuun Seuraavassa on nähtävillä hahmotelma binääripuun solmun rakenteesta: isäosoitin avainarvo osoitin vasempaan lapseen osoitin oikeaan lapseen

Koko puulla on olemassa attribuutti juuri[P], joka on osoitin puun juurisolmuun. Juuri on solmuista ainoa, jonka isäosoitin on puuttuva eli arvoltaan NIL. Toisin sanoen, vanhempi[juuri[P]] = NIL NIL juuri[P] Erityisesti, jos juuri[P] = NIL, on kyseessä tyhjä puu. Seuraavalla sivulla on esitettynä esimerkki binääripuusta. Puuttuvaa osoitinta merkitään rakennekuvissa kauttaviivalla (/).

Seuraavassa pieni esimerkki binääripuun P esittämisestä (Huom! Puu on järjestämätön). juuri[P] / 19 3 41 / 31 / 25 28 / 6 / 29 / 51 /

Yleisessä puu-tietorakenteessa solmulla voi olla mielivaltainen määrä lapsisolmuja. Tällaisessa vapaassa (ei välttämättä binääri-)puussa solmulla on olemassa seuraavat attribuutit:  avain[x]: sisältää solmuun x liittyvän avainarvon  vasen_lapsi[x]: sisältää osoittimen solmun x vasemmanpuoleisimpaan lapsisolmuun  oikea_veli[x]: sisältää osoittimen solmun x oikeanpuoleiseen velisolmuun  vanhempi[x]: sisältää osoittimen solmun x isäsolmuun Vasen lapsiosoitin on NIL silloin, kun kyseessä on lehtisolmu Itse puulla on lisäksi attribuutti juuri[P], joka sisältää osoittimen puun juurisolmuun.

Seuraavassa vielä pieni esimerkki yleisen puun esittämisestä: juuri[P] / 3 45 / 25 29 / 51 / 76 /

11 Hajautustaulut (Hash-taulut)
Hajautustauluja käytetään (tieto)hakemistojen toteuttamiseen Yksittäisellä säilöttävällä tietoalkiolla eli objektilla on: 1) tunnistearvo avain[x] 2) tämän lisäksi muita mahdollisia tietokenttiä eli attribuutteja – ts. satelliittidataa Tietoalkioille pitää pystyä suorittamaan seuraavia operaatioita uuden alkion lisääminen hakemistoon hakemistoon kohdistuvia kyselyitä olemassa olevan alkion poistaminen Kyseiset operaatiot on ovat nopeita, sillä ne voidaan toteuttaa keskimäärin vakioajassa! 11.1 Suorasaantitaulut Seuraavassa oletetaan, että 1) Tallennettavat avainarvot kuuluvat joukkoon U = {0, 1, 2, …, m – 1}, missä m ei saa olla ”kohtuuttoman iso”. Toisin sanoen, avainten vaihteluväli ei saa olla ”liian pitkä”. 2) Kaikilla tallennettavilla arvoilla on eri avain keskenään (ei sallita duplikaatteja avaimelle). Mikäli nämä vaatimukset täyttyvät, voidaan käyttää hakurakenteena suorasaantitaulua T, joka on indeksoitu välille 0..m – 1.

11.1 Suorasaantitaulut Joukon U kaikille mahdollisille alkioille 1..m – 1 muodostettu suorasaantitaulu T on seuraavanlainen: objekteista koostuva taulukko taulun paikassa T[i] on osoitin objektiin, joka sisältää avainarvon i objekti voi sisältää myös satelliittidataa mikäli tietty avainarvo i ei tarkasteluhetkellä kuulu U:n alijoukkona olevaan avainten joukkoon K, on T[i] tällöin NIL. Esimerkki: Olkoon m = 12, jolloin U = {0, 1, 2, …, 11}, ja lisäksi K = {0, 1, 4, 7, 9, 10}. Tällöin suorasaantitaulu T on indeksoitu välille ja näyttää seuraavanlaiselta: T = / 1 4 7 9 10

11.1 Suorasaantitaulut Suorasaantitauluihin voi kohdistaa seuraavia operaatioita: 1) Tietyn avaimen sisältävän alkion etsiminen taulusta ETSI_SUORASAANTITAULUSTA(T, k) RETURN T[k] 2) Tietyn avaimen sisältävän alkion lisääminen tauluun LISÄÄ_SUORASAANTITAULUUN(T, x) T[avain[x]] := x 3) Taulussa olevan solmualkion x poistaminen sen avainarvon perusteella POISTA_SUORASAANTITAULUSTA(T, x) T[avain[x]] := NIL Kaikki edellä esitetyt operaatiot ovat vakioaikaisia ja siten hyvin nopeita.

11.2 Hajautustaulut Kuten edellä todettiin, kaikki suorasaantitauluihin kohdistuvat operaatiot ovat vakioaikaisia. Pulma syntyy kuitenkin silloin, kun joukon U koko alkaa kasvaa voimakkaasti.  tarvitaan enemmän ja enemmän tilaa suorasaantitaulun T tallentamiseksi muistiin  lisäksi suuri osa varatusta tilasta on käytännössä hyödytöntä, jos taulussa on kuitenkin vain vähän avaimia taulun kokoon nähden, eli taulun täyttösuhde on pieni. Pulman ratkaisuehdotus: yritetään suhteuttaa taulun T koko joukon K kokoon eli käytössä olevien avainten määrään koko sallitun arvoalueen pituuden asemesta.  Tämä voidaan toteuttaa määrittelemällä ns. hajautus- (eli hash-)funktio h siten, että se kuvaa kaikki joukon U mahdolliset avaimet käytössä olevien avainten joukon K alkioiden määrän mittaiselle vaihteluvälille seuraavasti: h: U  {0, 1, 2, …, |K| ̶ 1}, missä |K| edustaa avainten tämänhetkistä lukumäärää  Siten alkio, jonka alkuperäinen avainarvo on k, tallentuu taulukossa T paikkaan h(k). Määritellään vastedes, että hajautustaulu T indeksoidaan välille 0..m ̶ 1, missä m = |K|, eli tämä määrittely kumoaa termin m edellä käytetyn merkityksen suurimpana sallittuna alkuperäisenä avaimena + 1.  m edustaa kuitenkin edelleen taulun T kokoa. Syntyy kuitenkin uusi ongelma: koska funktio h on käytännössä aina kutistava kuvaus, käy ennen pitkää niin, että funktio h kuvaa kaksi tai useampia U:hun kuuluvia alkioehdokkaita samaan osoitteeseen, eli h(k1) = h(k2) ainakin joillakin k1 ja k2, kun k1  k2.  syntyy osoitetörmäys.

11.2 Hajautustaulut Mikäli osoitetörmäykset joudutaan hyväksymään, pitää löytää jokin menetelmä niiden hallitsemiseen tietoja menettämättä.  ratkaisu ei varmaankaan liene paikassa T[i] olevan aikaisemman alkion tuhoaminen …! Tarkastellaan seuraavaksi vaihtoehtoja, miten osoitetörmäysongelma voidaan ratkaista. 1) Ketjutus: muodostetaan samaan indeksipaikkaan päätyneistä alkioista lista  Hajautustaulun paikassa T[i] on osoitin ensimmäiseen sellaiseen alkioon, jonka hajautusfunktio h on kuvannut paikkaan i – toisin sanoen h(avain[x]) = i  Mikäli funktion h valinta on onnistunut, ja avainten jakautuma lähtöjoukossa on tasainen, T:n jokaiseen positioon tulee vain vähän alkioita keskimäärin  Toiminta-ajatus on käytännössä ihan sama kuin nippulajittelussakin  Seuraavassa pieni esimerkki: / 1 28 7 4 31

11.2 Hajautustaulut Ketjutusta käyttäviin hajautustauluihin voi kohdistaa seuraavia operaatioita: 1) Tietyn avaimen sisältävän alkion etsiminen taulusta ETSI_KETJUTETUSTA_HAJAUTUSTAULUSTA(T, k) /* Etsii listasta T[h(k)] alkiota, jolla on avaimena k. */ 2) Tietyn avaimen sisältävän alkion lisääminen tauluun LISÄÄ_KETJUTETTUUN_HAJAUTUSTAULUUN(T, x) /* Lisää alkion x listan T[h(avain[x])] alkuun. */ 3) Taulussa olevan solmualkion x poistaminen sen avainarvon perusteella POISTA_KETJUTETUSTA_HAJAUTUSTAULUSTA(T, x) /* Poistaa lista-alkion x listasta T[h(avain[x])]. */ Lisäysoperaation kustannus edelleen vakioaikainen kuten suorasaantitauluissakin. Sen sijaan alkion etsinnän ja poiston kustannus riippuu paikasta T[h(k)] (tai T[h(avain[x])) alkavan listan pituudesta.

11.2 Hajautustaulut Seuraavassa muutamia käsitteitä ja määritelmiä
n = hajautustauluun T tallennettujen alkioiden lukumäärä m = taulun T koko taulun täyttösuhde  määritellään seuraavasti:  = n / m Oletetaan seuraavaksi, että kyseessä on ns. yksinkertainen tasainen hajautus.  Tällöin hajautusfunktio jakaa kutakin arvoa väliltä 0, 1, 2, …, m – 1 samalla todennäköisyydellä 1 / m. Kannattaa huomioida, että täyttösuhde  on sama kuin kunkin listan keskimääräinen pituus. Tarkastellaan seuraavassa erikseen onnistuneen ja epäonnistuneen haun suoritusaikaa  Onnistunut haku: etsitään avainta, joka on tallennettuna hajautustauluun T.  Epäonnistunut haku: etsitään avainta, jota ei esiinny kyseisessä hajautustaulussa. Seuraavassa oletetaan edelleen, että arvon h(k) laskeminen tapahtuu vakioajassa eli sen kustannus on (1). Lause 11.1: Epäonnistuneen haun kustannus on keskimäärin (1 + ).  Todistus: Etsitään alkiota, jonka avaimena esiintyy k. Hajautusfunktion arvon h(k) laskemiseen kuluu aikaa (1). Paikasta T[h(k)] alkava lista joudutaan käymään kokonaan läpi, sillä ollaan etsimässä alkiota, jota listassa ei esiinny. Siten työmääräksi saadaan yhteensä (1) + () = (1 + ).

11.2 Hajautustaulut

11.2 Hajautustaulut 11.3 Hajautusfunktioista
Edellä esitettyjen analyysien perusteella voidaan todeta, että ketjutukseen perustuvaa osoitetörmäysten hallintaa käyttämällä kaikki hakemisto-operaatiot saadaan tehtyä keskimäärin vakioajassa (lisäyksen kompleksisuus on aina vakioaikainen, sillä uusi alkio lisätään aina paikasta T[h(avain[x])] alkavan listan alkuun). Jos esimerkiksi n  2700 ja m  900, saadaan täyttösuhteeksi  = m / n = 2700 / 900 = 3.  Hajautustauluun muodostuvat listat ovat keskimäärin kolmen mittaisia. 11.3 Hajautusfunktioista Hajautusfunktion tärkeimpänä ominaisuutena voidaan pitää, että se toteuttaa yksinkertaisen tasaisen hajautuksen periaatteen.  Tällöin hajautusfunktio antaa talletettavien alkioiden avaimille samalla todennäköisyydellä minkä tahansa arvon väliltä 0..m ̶ 1. Talletettavan avaimen sijoittamisen todennäköisyys paikkaan T[i] ei ole riippuvainen siitä, mihin aikaisemmin tauluun tallennetut avaimet ovat päätyneet. Kannattaa huomioida, että hajautusfunktion toimivuuden ihanteellisuutta ei usein pystytä tarpeeksi luotettavasti mittaamaan saati todistamaan. Esimerkki hajautusfunktiosta: Oletetaan, että talletettavat avaimet k ovat täysin satunnaisesti valittuja reaalilukuja väliltä {0  k < 1}. Valitaan nyt hajautusfunktioksi h(k) = km  Tällöin saadaan aikaan selvästikin yksinkertainen tasainen hajautus

11.3.1 Jakojäännösmenetelmä
11.3 Hajautusfunktioista Esimerkiksi merkkijonot (sanat) voitaisiin tulkita ”128-järjestelmän” luvuiksi.  7-bittisessä ASCII-koodissa eri merkit kuvataan numeroarvoiksi Mikäli 7-bitin ASCII-koodin mukaisista merkeistä koostuvat sanat haluttaisiin muuntaa 10-järjestelmän luvuiksi, voidaan koodaus suorittaa merkeittäin. Esimerkki: Sanan ”Hauki” koodaaminen merkeittäin 10-järjestelmään:  Tarvittavat ASCII-merkkien koodiarvot: ’H’ = 72, ’a’ = 97, ’u’ = 117, ’k’ = 107 ja ’i’ = Siten sanaa ”Hauki” vastaisi 10-järjestelmän kokonaisluku k k = (72 * 1284) + (97 * 1283) + (117 * 1282) + (107 * 1281) + (105 * 1280) = = Jakojäännösmenetelmä Jakojäännösmenetelmässä hajautusfunktio on muotoa: h(k) = k mod m Esimerkki: Jos m = 12 ja k = 59  h(k) = 11, sillä 59 = 4 * Jakojäännösmenetelmää käyttämällä saadaan aikaan tasainen hajautus, jos talletettavat avaimet ovat jakautuneet tasaisesti.

Kertolaskumenetelmä

11.4 Avoin osoitteenanto Edellä tarkasteltiin osoitetörmäysten hallitsemista ketjutusta käyttämällä, jolloin tallennettavat objektit sijoitettiin hajautustaulun T paikoista 0..m – 1 alkaviin listoihin. Seuraavaksi selvitetään avainten (yhtä lailla koko objektien) tallentamista itse tauluun T. Mikäli taulun johonkin indeksiin ei ole sijoitettuna yhtään objektia, paikassa on NIL-osoitin. Jos samaan osoitteeseen yritetään tallentaa useampia kuin yksi alkio, eli ajaudutaan osoitetörmäykseen, joudutaan etsimään vaihtoehtoista paikkaa uuden alkion lisäämiseksi.  Sille, miten hakua uuden paikan tallennuspaikan löytämiseksi jatketaan, on olemassa vaihtoehtoisia menetelmiä.  Samaa menettelyä sovelletaan myös avainta etsittäessä tai alkiota poistettaessa. Avointa osoitteenantoa käytettäessä on vaatimuksena, että   1. Muutoin kaikki alkiot eivät mahdu käytössä olevaan hajautustauluun. Jatko-osoitteen hakumenettely:  Asetetaan hajautusfunktiolle toinen parametri i, joka ilmaisee jatko-osoitteen järjestysnumeron: 0, 1, 2, …, m – 1.  Hajautusfunktio on siis kuvaus laillisten avainarvojen joukon U ja kokeilun järjestysnumeroiden tulojoukolta hajautustaulun indekseille, eli se on muotoa h: U x {0, 1, 2, …, m – 1}  {0, 1, 2, …, m – 1}  Hajautustaulua T tutkitaan siten järjestyksessä h(k, 0), h(k, 1), h(k, 2), …, h(k, m – 1), joka on yksi taulun T indekseistä koostuvan jonon (0, 1, 2, …, m – 1) permutaatioista.

11.4 Avoin osoitteenanto Seuraavaksi esitellään avointa osoitteenantoa käyttävää hajautustaulua käsitteleviä algoritmeja. Tarkastellaan ensiksi alkion lisäämistä tauluun T … LISÄÄ_HAJAUTUSTAULUUN(T, k) 1 i := REPEAT j := h(k, i) IF T[j] = NIL THEN T[j] := k RETURN j ELSE i := i UNTIL i = m 11 Virheilmoitus ”Hajautustaulu on täynnä – ei voida lisätä.”  Algoritmi sijoittaa avaimen k tauluun T ensimmäiseen vapaaseen paikkaan, joka tulee hajautusfunktion palauttamana vastaan matkan varrella.  Ellei yhtään paikkaa ole tyhjänä, tulostetaan asiasta kertova virheilmoitus.

11.4 Avoin osoitteenanto ... ja sitten avaimen k etsimistä taulusta T. ETSI_HAJAUTUSTAULUSTA(T, k) 1 i := REPEAT j := h(k, i) IF T[j] = k THEN RETURN j i := i UNTIL T[j] = NIL OR i = m 9 RETURN NIL  Algoritmi etsii avainta k taulusta T hajautusfunktion arvojen määräämässä kokeilujärjestyksessä.  Suoritus päättyy joko ) Avaimen löytymiseen jostakin indeksistä kokeilulla i. Jos i > 0 kaikki edellä tutkitut taulun positiot ovat olleet ei-tyhjiä ) Osuttaessa vektorin T johonkin tyhjään positioon. Tällöin tiedetään haun epäonnistuneen, sillä avaimen k talletuspaikan etsintäketju on jo katkennut ) Laskurin i saavuttaessa arvon m: taulu T täynnä, mutta etsittyä avainta ei löytynyt.

11.4 Avoin osoitteenanto Alkioiden poistaminen osoittautuu lisäystä ja hakua selvästi hankalammaksi. Pitää taata, ettei avaimen tallennus-/hakuketju pääse katkeamaan.  siten poistettavan alkion korvaaminen arvolla NIL ei tule kyseeseen Ratkaisuehdotus: käytetään erityistä arvoa TUHOTTU arvon NIL asemesta, kun poistetaan alkioita.  Tällöin pitää myös lisäysalgoritmia muuttaa sellaiseksi, että se tallettaa uuden avaimen kohdatessaan joko tyhjän indeksipaikan tai vaihtoehtoisesti tuhotuksi merkityn alkion.  Sen sijaan hakualgoritmille ei tarvitse tehdä mitään, sillä se ei reagoi mitenkään tuhottuihin arvoihin, vaan tunnistaa niiden olevan erisuuria kuin etsitty avain.  Uusi pulma: Taulun täyttösuhde ei välttämättä pidä enää paikkaansa, sillä tuhotuiksi merkityt arvot pidentävät hakuketjuja. TASAINEN HAJAUTUS Hajautuksen sanotaan olevan tasainen, jos jokaiselle avaimelle kaikki m! erilaista lukujonon (0, 1, 2, …, m – 1) permutaatiota ovat yhtä todennäköisiä tutkittavia osoitejonoja. Kannattaa huomioida, että edellä tarkasteltu yksinkertainen tasainen hajautus merkitsi sitä, että mikä tahansa arvo 0, 1, 2, …, m – 1 on yhtä todennäköinen hajautusfunktion arvo (yhteen kertaan määrättynä). Sen sijaan tasaisessa hajautuksessa oletetaan, että kukin permutaatio – joita on m! kappaletta – on yhtä todennäköinen tutkittavien osoitteiden järjestys. Tasainen hajautus on lähes mahdoton toteuttaa käytännössä.  Esiteltävissä menetelmissä tämä ei toteudu.  Tällä kurssilla tarkasteltavalla parhaalla menetelmällä on vain m2 erilaista osoitejonoa (kaksoishajautus)

11.4 Avoin osoitteenanto LINEAARINEN JATKO-OSOITTEEN LASKUMENETTELY
Oletetaan, että h’: U  {0, 1, 2, …, m – 1} on jokin hajautusfunktio, ja määritellään h(k, i) = (h’(k) + i) mod m Idea: osoitteiden kokeilujärjestys hakua, tallennusta ja poistoa varten on T[h’(k)], T[h’(k) + 1], T[h’(k) + 2], …, T[m – 1], T[0], T[1], …, T[h’(k) – 1]  Tässä menetelmässä h’(k) eli ensimmäinen hajautustaulun tutkimiskohta määrää täysin jatko-osoitejonon!  Jos vaikkapa ensiksi kokeillaan paikkaa 6, yritetään tämän jälkeen tarvittaessa aina heti seuraavasta paikasta 7 (tai vaihtoehtoisesti paikasta 0, jos m = 7). Mahdollisia jatko-osoitejonoja vain m kappaletta. Kyseessä ei siis ole tasainen hajautus. Menetelmän etu: yksinkertainen toteuttaa. Menetelmän haitta: hajautustaulun ryvästyminen eli klusteroituminen  Hajautustauluun syntyy helposti pitkiä varattujen lokeroiden jonoja  hakuajat pitenevät

11.4 Avoin osoitteenanto KAKSOISHAJAUTUS
Kaksoishajautus on suositeltava menetelmä, jolla saadaan aikaan lähes satunnainen permutaatio h(k, i) = (h1(k) + i  h2(k)) mod m, missä h1 ja h2 ovat joitain hajautusfunktioita Idea: Tutkitaan ensimmäisellä kierroksella paikasta T[h1(k)]. Seuraavat osoitteet sijaitsevat puolestaan h2:n etäisyydellä toisistaan. Siten h2 esittää hypyn pituutta etsittäessä paikkaa avaimelle k. Erilaisia osoitejonoja muodostuu m2 kappaletta. Jotta koko hajautustaulu tulisi tarpeen vaatiessa käytyä läpi, on oltava voimassa syt(m, h2(k)) = 1.  Muutoin yritettäisiin palata liian aikaisin takaisin jo kertaalleen tutkittuihin osoitteisiin samalla, kun toisaalla taulussa on vielä tutkimattomia paikkoja. Esimerkki: Oletetaan, että m = 13, k = 14, h1(k) = k mod 13 ja h2(k)) = 1 + (k mod 11)  Nyt k = 14  1 (mod 13) ja k = 14  3 (mod 11)  Täten h1(14) = 1 ja h2(14) = = 4.  Tallennettaessa avainta k = 14 testataan ensiksi paikkaa 1. Jos se on varattu, jatketaan kokeiluja tästä eteenpäin seuraavassa järjestyksessä: , 9, 0, 4, 8, 12, 3, 7, 11, 2, 6,  Ellei avainta 14 löydetä viimeistään paikasta 10 (tai tallennettaessa kyseistä avainta ei siihen mennessä ole kohdattu tyhjää paikkaa tai tuhotuksi merkittyä arvoa), haku (lisäys) epäonnistui.

11.4 Avoin osoitteenanto

11.4 Avoin osoitteenanto Voiton suuruus Arpojen lukumäärä 100 000 € 5
Tarkastellaan toisena esimerkkinä Ässä-arvan voitonjakoa. Yhden arvan hinta on 4 euroa. Arpoja on painettu yhteensä kappaletta, joista sisältää jonkin voiton. Minkä tahansa voiton osumisen todennäköisyys on siten /   Hieman harvempi kuin joka 4. arpa voittaa (tai antaa ainakin panoksen takaisin). Voiton suuruus Arpojen lukumäärä € 5 2 000 € 40 1 000 € 100 500 € 2 000 30 € 30 000 20 € 10 000 10 € 60 000 7 € 4 € Voittojen yhteissumma: Voittavia arpoja yhteensä:

11.4 Avoin osoitteenanto

Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth.

Samankaltaiset esitykset

Esitys aiheesta: "Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth."— Esityksen transkriptio:

Samankaltaiset esitykset

Projektista

Palaute

Kirjaudu sisään

Kirjaudu sisään sosiaaliverkostojen kautta:

Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth.

Samankaltaiset esitykset

Esitys aiheesta: "Tietorakenteet ja algoritmit I Turun yliopisto, Informaatioteknologian laitos, periodi 2 / 2012 Lasse Bergroth."— Esityksen transkriptio:

Samankaltaiset esitykset

Projektista

Palaute