Tämä on helpompi ymmärtää, kun tulkitaan keko täydellisesti tasapainotetuksi binääripuuksi, jonka juuri on talletettu taulukon paikkaan

Transkriptio

1 TIE Tietorakenteet ja algoritmit 178 Keko Taulukko A[1... n] on keko, jos A[i] A[2i] ja A[i] A[2i + 1] aina kun 1 i n 2 (ja 2i + 1 n). Tämä on helpompi ymmärtää, kun tulkitaan keko täydellisesti tasapainotetuksi binääripuuksi, jonka juuri on talletettu taulukon paikkaan 1 paikkaan i talletetun solmun lapset (jos olemassa) on talletettu paikkoihin 2i ja 2i + 1 paikkaan i talletetun solmun isä on talletettu paikkaan i

2 TIE Tietorakenteet ja algoritmit 179 Tällöin jokaisen solmun arvo on suurempi tai yhtä suuri kuin sen lasten arvot. Kekopuun jokainen kerros on täysi, paitsi ehkä alin, joka on täytetty vasemmasta reunasta alkaen.

3 TIE Tietorakenteet ja algoritmit 180 Jotta kekoa olisi helpompi ajatella puuna, määrittelemme isäja lapsisolmut löytävät aliohjelmat. ne ovat toteutettavissa hyvin tehokkaasti bittisiirtoina kunkin suoritusaika on aina Θ(1) PARENT(i) return i/2 LEFT(i) return 2i RIGHT(i) return 2i + 1

4 TIE Tietorakenteet ja algoritmit 181 Nyt keko-ominaisuus voidaan lausua seuraavasti: A[PARENT(i)] A[i] aina kun 2 i A.heapsize A.heapsize kertoo keon koon (myöhemmin nähdään, ettei se aina ole välttämättä sama kuin taulukon koko) Keko-ominaisuudesta seuraa, että keon suurin alkio on aina keon juuressa, siis taulukon ensimmäisessa lokerossa. Jos keon korkeus on h, sen solmujen määrä on välillä 2 h... 2 h+1 1. Jos keossa n solmua, sen korkeus on Θ(lg n).

5 TIE Tietorakenteet ja algoritmit 182 Alkion lisääminen kekoon ylhäältä: oletetaan, että A[1... n] on muuten keko, mutta kekoominaisuus ei päde kekopuun juurelle toisin sanoen A[1] < A[2] tai A[1] < A[3] ongelma saadaan siirrettyä alemmas puussa valitsemalla juuren lapsista suurempi, ja vaihtamalla se juuren kanssa jotta keko-ominaisuus ei hajoaisi, pitää valita lapsista suurempi - siitähän tulee toisen lapsen uusi isä

6 TIE Tietorakenteet ja algoritmit 183 sama voidaan tehdä alipuulle, jonka juureen ongelma siirtyi, ja sen alipuulle jne. kunnes ongelma katoaa ongelma katoaa viimeistään kun saavutetaan lehti puu muuttuu keoksi

7 TIE Tietorakenteet ja algoritmit 184 Sama pseudokoodina: HEAPIFY( A, i ) (i kertoo paikan, jonka alkio saattaa olla liian pieni) 1 repeat (toistetaan, kunnes keko on ehjä) 2 old_i := i (otetaan i:n arvo talteen) 3 l := LEFT( i ) 4 r := RIGHT( i ) 5 if l A.heapsize and A[ l ] > A[ i ] then (vasen lapsi on suurempi kuin i) 6 i := l 7 if r A.heapsize and A[ r ] > A[ i ] then (oikea lapsi on vielä suurempi) 8 i := r 9 if i old_i then (jos suurempi lapsi löytyi...) 10 exchange A[ old_i ] A[ i ] (...siirretään rike alaspäin) 11 until i = old_i (jos keko oli jo ehjä, lopetetaan) Suoritus on vakioaikaista kun rivin 11 ehto toteutuu heti ensimmäisellä kerralla kun sinne päädytään: Ω(1). Pahimmassa tapauksessa uusi alkio joudutaan siirtämään lehteen asti koko korkeuden verran. Suoritusaika on O(h) = O(lg n).

8 TIE Tietorakenteet ja algoritmit 185 Keon rakentaminen seuraava algoritmi järjestää taulukon uudelleen niin, että siitä tulee keko: BUILD-HEAP(A) 1 A.heapsize := A.length (koko taulukosta tehdään keko) 2 for i := A.length/2 downto 1 do (käydään taulukon alkupuolisko läpi) 3 HEAPIFY(A, i) (kutsutaan Heapifyta) Lähdetään käymään taulukkoa läpi lopusta käsin ja kutsutaan HEAPIFYTA kaikille alkioille. ennen HEAPIFY-funktion kutsua keko-ominaisuus pätee aina i:n määräämälle alipuulle, paitsi että paikan i alkio on mahdollisesti liian pieni yhden kokoisia alipuita ei tarvitse korjata, koska niissä keko-ominaisuus pätee triviaalisti HEAPIFY(A, i):n jälkeen i:n määräämä alipuu on keko HEAPIFY(A, 1):n jälkeen koko taulukko on keko

9 TIE Tietorakenteet ja algoritmit 186 BUILD-HEAP ajaa for-silmukan n 2 kertaa ja HEAPIFY on Ω(1) ja O(lg n), joten nopein suoritusaika on n 2 Ω(1) + Θ(n) = Ω(n) ohjelma ei voi koskaan käyttää enempää aikaa kuin n 2 O(lg n) + Θ(n) = O(n lg n) Näin saamamme hitaimman tapauksen suoritusaika on kuitenkin liian pessimistinen:

10 TIE Tietorakenteet ja algoritmit 187 HEAPIFY on O(h), missä h on kekopuun korkeus i:n muuttuessa myös puun korkeus vaihtelee kerros h HEAPIFY-suoritusten määrä alin 0 0 toinen 1 n 4 kolmas 2 n ylin lg n 1 siis pahimman tapauksen suoritusaika onkin n n n = n 2 i=1 i = n 2 i 2 2 = n O(n) BUILD-HEAPIN suoritusaika on aina Θ(n)

11 TIE Tietorakenteet ja algoritmit Järjestäminen keon avulla Taulukon alkioiden ärjestäminen voidaan toteuttaa tehokkaasti kekoa hyödyntäen: HEAPSORT( A ) 1 BUILD-HEAP( A ) (muutetaan taulukko keoksi) 2 for i := A.length downto 2 do (käydään taulukko läpi lopusta alkuun) 3 exchange A[ 1 ] A[ i ] (siirretään keon suurin alkio keon viimeiseksi) 4 A.heapsize := A.heapsize 1 (siirretään suurin alkio keon ulkopuolelle) 5 HEAPIFY( A, 1 ) (korjataan keko, joka on muuten kunnossa, mutta...) (... sen ensimmäinen alkio saattaa olla liian pieni) Esitetäänpä sama kuvien avulla: ensin taulukko muutetaan keoksi esimerkistä on helppo havaita, ettei operaatio ole kovin raskas keko-ominaisuus on selvästi järjestystä heikompi

12 TIE Tietorakenteet ja algoritmit 189 kuvassa voi nähdä kuinka järjestetyn loppuosan koko kasvaa, kunnes koko taulukko on järjestyksessä kasvatusten välillä keko-osuus korjataan korjaus näyttää tällaisessa pienessä esimerkissä tarpeettoman monimutkaiselta korjaukseen ei suurillakaan taulukoilla kulu kovin montaa askelta, ainoastaan logaritminen määrä

13 TIE Tietorakenteet ja algoritmit 190 HEAPSORTIN suoritusaika koostuu seuraavista osista. BUILD-HEAP rivillä 1 suoritetaan kerran: Θ(n) for-silmukan sisältö suoritetaan n - 1 kertaa rivien 3 ja 4 operaatiot ovat vakioaikaisia HEAPIFY käyttää aikaa Ω(1) ja O(lg n) Saadaan yhteensä Ω(n) ja O(n lg n) alaraja on tarkka jos kaikki alkiot ovat samanarvoisia, keon korjaustoimenpiteitä ei tarvita koskaan ja HEAPIFY on aina vakioaikainen myös yläraja on tarkka tämän osoittaminen on hieman hankalampaa ja tyydymmekin myöhemmin saatavaan tulokseen vertailuun perustuvan järjestämisen nopeudesta

14 TIE Tietorakenteet ja algoritmit 191 Huom! Edelliset suoritusaikalaskelmat olettavat, että keon pohjana käytettävällä tietorakenteella on vakioaikainen indeksointi. Kekoa kannattaa käyttää ainoastaan silloin! HEAPSORTIN etuja ja haittoja Etuja: järjestää taulukon paikallaan ei koskaan käytä enempää kuin Θ(n lg n) aikaa Haittoja: suoritusajan vakiokerroin on suurehko epävakaus samanarvoisten alkioiden keskinäinen järjestys ei säily

15 TIE Tietorakenteet ja algoritmit Prioriteettijono Prioriteettijono (priority queue) on tietorakenne, joka pitää yllä joukkoa S alkioita, joista jokaiseen liittyy avain (key), ja sallii seuraavat operaatiot: INSERT(S, x) lisää alkion x joukkoon S MAXIMUM(S) palauttaa sen alkion, jonka avain on suurin jos monella eri alkiolla on sama, suurin avain, valitsee vapaasti minkä tahansa niistä EXTRACT-MAX(S) poistaa ja palauttaa sen alkion, jonka avain on suurin vaihtoehtoisesti voidaan toteuttaa operaatiot MINIMUM(S) ja EXTRACT-MIN(S) samassa jonossa on joko vain maksimi- tai vain minimioperaatiot!

16 TIE Tietorakenteet ja algoritmit 193 Prioriteettijonoilla on monia käyttökohteita tehtävien ajoitus käyttöjärjestelmässä uusia tehtäviä lisätään komennolla INSERT kun edellinen tehtävä valmistuu tai keskeytetään, seuraava valitaan komennolla EXTRACT-MAX tapahtumapohjainen simulointi jono tallettaa tulevia (= vielä simuloimattomia) tapahtumia avain on tapahtuman tapahtumisaika tapahtuma voi aiheuttaa uusia tapahtumia lisätään jonoon operaatiolla INSERT EXTRACT-MIN antaa seuraavan simuloitavan tapahtuman lyhimmän reitin etsintä kartalta simuloidaan vakionopeudella ajavia, eri reitit valitsevia autoja, kunnes ensimmäinen perillä prioriteettijonoa tarvitaan käytännössä myöhemmin esiteltävässä lyhimpien polkujen etsintäalgoritmissa

17 TIE Tietorakenteet ja algoritmit 194 Prioriteettijonon voisi käytännössä toteuttaa järjestämättömänä tai järjestettynä taulukkona, mutta se olisi tehotonta. järjestämättömässä taulukossa MAXIMUM ja EXTRACT-MAX ovat hitaita järjestetyssä taulukossa INSERT on hidas Sen sijaan keon avulla prioriteettijonon voi toteuttaa tehokkaasti. Joukon S alkiot talletetaan kekoon A. MAXIMUM( S ) on hyvin helppo, ja toimii ajassa Θ(1). HEAP-MAXIMUM( A ) 1 if A.heapsize < 1 then (tyhjästä keosta ei löydy maksimia) 2 error heap underflow 3 return A[ 1 ] (muuten palautetaan taulukon ensimmäinen alkio)

18 TIE Tietorakenteet ja algoritmit 195 EXTRACT-MAX(S) voidaan toteuttaa korjaamalla keko poiston jälkeen HEAPIFYN avulla. HEAPIFY dominoi algoritmin ajoaikaa: O(lg n). HEAP-EXTRACT-MAX( A ) 1 if A.heapsize < 1 then (tyhjästä keosta ei löydy maksimia) 2 error heap underflow 3 max := A[ 1 ] (suurin alkio löytyy taulukon alusta) 4 A[ 1 ] := A[ A.heapsize ] (siirretään viimeinen alkio juureen) 5 A.heapsize := A.heapsize 1 (pienennetään keon kokoa) 6 HEAPIFY( A, 1 ) (korjataan keko) 7 return max

19 TIE Tietorakenteet ja algoritmit 196 INSERT(S, x) lisää uuden alkion kekoon asettamalla sen uudeksi lehdeksi, ja nostamalla sen suuruutensa mukaiselle paikalle. se toimii kuten HEAPIFY, mutta alhaalta ylöspäin lehti joudutaan nostamaan pahimmassa tapauksessa juureen asti: ajoaika O(lg n) HEAP-INSERT( A, key ) 1 A.heapsize := A.heapsize + 1 (kasvatetaan keon kokoa) 2 i := A.heapsize (lähdetään liikkeelle taulukon lopusta) 3 while i > 1 and A[ PARENT(i) ] < key do (edetään kunnes ollaan juuressa tai...) (...kohdassa jonka isä on avainta suurempi) 4 A[ i ] := A[ PARENT(i) ] (siirretään isää alas päin) 5 i := PARENT(i) (siirrytään ylöspäin) 6 A[ i ] := key (asetetaan avain oikealle paikalleen) Keon avulla saadaan jokainen prioriteettijonon operaatio toimimaan ajassa O(lg n).

20 TIE Tietorakenteet ja algoritmit 197 Prioriteettijonoa voidaan ajatella abstraktina tietotyyppinä, johon kuuluu talletettu data (joukko S) ja operaatiot (INSERT, MAXIMUM,EXTRACT-MAX. käyttäjälle kerrotaan ainoastaan operaatioiden nimet ja merkitykset, muttei toteutusta toteutus kapseloidaan esimerkiksi pakkaukseksi (Ada), luokaksi (C++) tai itsenäiseksi tiedostoksi (C) Toteutusta on helppo ylläpitää, korjata ja tarvittaessa vaihtaa toiseen, ilman että käyttäjien koodiin tarvitsee koskea.

21 TIE Tietorakenteet ja algoritmit Erilaisia tapoja järjestää Käsitellään seuraavaksi järjestämisalgoritmeja, jotka perustuvat muihin kuin vertailuun alkioiden oikean järjestyksen saamiseksi. Lisäksi tutkitaan vertailuun perustuvien algoritmien parasta mahdollista tehokkuutta. Lopuksi mietitään hieman algoritmin valintaan vaikuttavia tekijöitä.

22 TIE Tietorakenteet ja algoritmit Muita järjestämisalgoritmeja Kaikki tähän mennessä käsitellyt järjestämisalgoritmit perustuvat vertailemiseen. Ne hankkivat tietoa oikeasta järjestyksestä vain vertaamalla alkioita keskenään. Järjestämisen apuna on kuitenkin toisinaan mahdollista käyttää muutakin informaatiota kuin vertailun tuottamaa.

23 TIE Tietorakenteet ja algoritmit 200 Järjestäminen laskemalla Oletetaan, että alkioiden avainten arvoalue on pieni, enintään alkioiden määrän suuruusluokkaa. Yksinkertaisuuden vuoksi oletamme, että järjestettävien alkioiden avaimet ovat peräisin joukosta {1, 2,..., k}, ja k = O(n). Kullekin avaimelle lasketaan, kuinka monella alkiolla on kyseinen avain. Tuloksen perusteella siirretään alkiot suoraan lopullisille paikoilleen.

24 TIE Tietorakenteet ja algoritmit 201 COUNTING-SORT(A, B, k) 1 for i := 1 to k do 2 C[ i ] := 0 (alustetaan aputaulukko C nollilla) 3 for j := 1 to A.length do 4 C[ A[ j ].key ] := C[ A[ j ].key ] + 1 (lasketaan monenko alkion avain = i) 5 for i := 2 to k do 6 C[ i ] := C[ i ] + C[ i 1 ] (lasketaan monenko alkion avain i) 7 for j := A.length downto 1 do (käydään taulukko läpi lopusta alkuun) 8 B[ C[ A[ j ].key ] ] := A[ j ] (sijoitetaan alkio paikalleen tulostaulukkoon) 9 C[ A[ j ].key ] := C[ A[ j ].key ] 1(seuraava oikea paikka on pykälän vasemmalla) Algoritmi asettelee alkiot oikeille paikoilleen käänteisessä järjestyksessä vakauden varmistamiseksi.

25 TIE Tietorakenteet ja algoritmit 202 Suoritusaika: Ensimmäinen ja kolmas for-silmukka kuluttavat aikaa Θ(k). Toinen ja viimeinen for-silmukka kuluttavat aikaa Θ(n). Ajoaika on Θ(n + k). Jos k = O(n), ajoaika on Θ(n). Kaikki perusoperaatiot ovat yksinkertaisia, ja niitä on kussakin silmukassa vähän, joten ajoajan vakiokerroin on pieni. COUNTING-SORTIA ei kannata käyttää, jos k n. Algoritmin muistinkulutus on Θ(k). Tavallisesti k n. esimerkiksi: kaikki mahdolliset henkilötunnukset TTY:n henkilökunnan henkilötunnukset

26 TIE Tietorakenteet ja algoritmit 203 Järjestäminen moniosaisella avaimella Toisinaan järjestettävä avain on moniosainen tenttituloslista ensin koulutusohjelmittain, sitten aakkosjärjestyksessä sukunimen mukaan. päiväykset ensin vuoden, sitten kuukauden ja sitten päivän mukaan. korttipakka ensin maan, sitten numeron mukaan. Kirjan hakemisto ensin hakusanoittain aakkosjärjestykseen, sitten hakusanojen alakäsitteet sivujärjestyksessä.

27 TIE Tietorakenteet ja algoritmit 204 Eriarvoiset kriteerit huomioidaan siten, että: eniten merkitsevä kriteeri, jonka mukaan alkiot ovat erilaiset, ratkaisee vertailun tuloksen. jos alkiot ovat kaikkien kriteerien mukaan yhtä suuret, ne katsotaan kokonaan yhtä suuriksi. Ongelma voidaan ratkaista vertailuun perustuvan algoritmin avulla käyttämällä tilanteeseen sopivaa vertailua, esimerkiksi päiväysten vertailu: DATE-COMPARE(x, y) 1 if x.year < y.year then return smaller 2 if x.year > y.year then return greater 3 if x.month < y.month then return smaller 4 if x.month > y.month then return greater 5 if x.day < y.day then return smaller 6 if x.day > y.day then return greater 7 return equal

28 TIE Tietorakenteet ja algoritmit 205 Toisinaan on kuitenkin tarkoituksenmukaista käsitellä aineisto kriteeri kerrallaan. Esimerkiksi korttipakka on helpointa lajitella ensin neljäksi kasaksi maittain, ja sitten jokainen kasa erikseen. Tällöin merkitsevien kriteerien arvoalue on usein pieni verrattuna alkioiden määrään COUNTING-SORT on käyttökelpoinen.

29 TIE Tietorakenteet ja algoritmit 206 Moniosaisen avaimen mukaan järjestämiseen on kaksi erilaista algoritmia. LSD-RADIX-SORT järjestetään taulukko ensin vähiten merkitsevän numeron mukaan, sitten seuraavaksi vähiten merkitsevän mukaan jne. vaatii vakaan järjestelyalgoritmin - muutenhan taulukko olisi lopuksi järjestyksessä ainoastaan eniten merkitsevän kriteerin mukaan vertailuun perustuvia algoritmeja ei kannata käyttää, koska ne järjestäisivät taulukon suunnilleen samalla vaivalla kaikkien kriteerien mukaan kerralla sopiva järjestysalgoritmi on COUNTING-SORT LSD-RADIX-SORT(A, d) 1 for i := 1 to d do (käydään kriteerit läpi vähiten merkitsevästä lähtien) 2 järjestä A jollain vakaalla järjestämisalgoritmilla kriteerin i mukaan

30 TIE Tietorakenteet ja algoritmit 207 MSD-RADIX-SORT järjestetään taulukko ensin eniten merkitsevän numeron mukaan, ja samanarvoisten alkioiden osataulukot tarvittaessa seuraavaksi merkitsevän numeron mukaan jne. ei vaadi järjestysalgoritmilta vakautta käyttökelpoinen esimerkiksi mahdollisesti erimittaisia merkkijonoja järjestettäessä tarkastaa kriteerejä ainoastaan siihen asti kun järjestämisen vuoksi on tarpeen LSD-RADIX-SORTIA monimutkaisempi toteuttaa emme esitä sille algoritmia tässä

31 TIE Tietorakenteet ja algoritmit 208 RADIX-SORTIN ajankulutus, kun apuna on COUNTING-SORT: järjestäminen yhden kriteerin mukaan: Θ(n + k) kriteerejä on kaikkiaan d kpl kokonaisaika Θ(dn + dk) k on yleensä vakio kokonaisaika Θ(dn), tai Θ(n), jos d:kin vakio RADIX-SORT näyttäisi siis tietyin edellytyksin olevan O(n) järjestämisalgoritmi. Onko se yleisessä tapauksessa vertailuun perustuvia algoritmeja parempi?

32 TIE Tietorakenteet ja algoritmit 209 Järjestämisalgoritmin suorituskykyä tarkasteltaessa on järkevää olettaa, että kaikki (tai ainakin useimmat) alkiot ovat erisuuria. Esimerkiksi INSERTION-SORT on O(n), jos kaikki alkiot ovat saman suuruisia. Jos kaikki alkiot ovat erisuuria, ja yhden kriteerin arvoalueen koko on vakio k, niin k d n d log k n = Θ(lg n) RADIX-SORT on Θ(dn) = Θ(n lg n), jos oletetaan, että alkiot ovat enimmäkseen eri suuria. RADIX-SORT on asymptoottisesti yhtä hidas kuin muutkin hyvät järjestämisalgoritmit. Jos oletetaan vakio d, niin RADIX-SORT on Θ(n), mutta silloin isoilla n:n arvoilla useimmat alkiot ovat samoja.

33 TIE Tietorakenteet ja algoritmit 210 RADIX-SORTIN etuja ja haittoja Etuja: RADIX-SORT on nopeutensa puolesta kilpailukykyinen esimerkiksi QUICKSORTIN kanssa jos avaimet ovat esimerkiksi 32-bittisiä lukuja, ja taulukko järjestetään 8 bitin mukaan kerrallaan k = 2 8 ja d = 4 COUNTING-SORTia kutsutaan neljästi RADIX-SORT sopii hyvin moniosaisen avaimen mukaan järjestämiseen, kun avaimen osilla on pieni arvoalue. esim. tekstitiedoston järjestäminen annetuilla sarakkeilla olevien merkkien mukaan (vrt. Unix tai MS/DOS sort) Haittoja: COUNTING-SORT tarvitsee toisen n:n mittaisen taulukon B, johon se rakentaa lopputuloksensa sekä k:n kokoisen aputaulukon. Sen apumuistin tarve on siis Θ(n), eli merkittävästi suurempi kuin esimerkiksi QUICKSORTilla ja HEAPSORTilla.

34 TIE Tietorakenteet ja algoritmit 211 Bucket sort Oletetaan, että avaimet kuuluvat tunnetulle välille, ja avainten arvot ovat jakautuneet tasan. Jokainen avaimen arvo yhtä todennäköinen. Esimerkin vuoksi oletamme, että avainten arvot sijoittuvat nollan ja ykkösen välille. Otetaan käyttöön n ämpäriä (bucket) B[ 0 ]... B[ n 1 ]. BUCKET-SORT(A) 1 n := A.length 2 for i := 1 to n do (käydään kaikki alkiot läpi) 3 INSERT(B[ n A[i] ], A[i]) (heitetään alkio oikeaan ämpäriin) 4 k := 1 (aloitetaan taulukon täyttäminen kohdasta 1) 5 for i := 0 to n 1 do (käydään ämpärit läpi) 6 while B[ i ] ei ole tyhjä do (tyhjennetään epätyhjät ämpärit...) 7 A[ k ] := EXTRACT-MIN(B[ i ]) (... siirtämällä alkiot pienimmästä alkaen...) 8 k := k + 1 (... oikeaan kohtaan tulostaulukkoa)

35 TIE Tietorakenteet ja algoritmit 212 Ämpäreiden toteutus: Tarvitaan operaatiot INSERT ja EXTRACT-MIN. Ämpäri on itse asiassa prioriteettijono. Ämpärien koko vaihtelee suuresti. yleensä ämpärin alkioiden määrä 1 kuitenkin jopa kaikki alkiot voivat joutua samaan ämpäriin kekoon perustuvan toteutuksen tulisi varata muistia Θ(n) jokaiselle ämpärille, yhteensä Θ(n 2 ) Toisaalta toteutuksen ei tarvitse olla kovin nopea suurille ämpäreille, koska niitä syntyy harvoin. Käytännössä ämpärit kannattaa toteuttaa listoina. INSERT linkittää tulevan alkion oikealle paikalleen listaan, aikaa kuluu Θ(listan pituus) EXTRACT-MIN poistaa ja palauttaa listan ensimmäisen, aikaa kuluu Θ(1)

36 TIE Tietorakenteet ja algoritmit 213 BUCKET-SORTIN keskimääräinen suorituskyky: Oletimme, että avainten arvot ovat jakautuneet tasan. Yhteen ämpäriin tulee siis keskimäärin yksi alkio, ja hyvin harvoin paljoa enempää. Ensimmäinen for-silmukka käy kaikki alkiot läpi, Θ(n). Toinen for-silmukka käy kaikki ämpärit läpi, Θ(n). while-silmukka käy kaikilla kierroksillaan yhteensä kaikki alkiot läpi kerran, Θ(n). INSERT on keskimäärin vakioaikainen, koska ämpärissä on keskimäärin yksi alkio. EXTRACT-MIN on vakioaikainen. Kokonaisaika on keskimäärin Θ(n). Hitaimmassa tapauksessa kaikki alkiot joutuvat samaan ämpäriin ja tulevat suuruusjärjestyksessä. INSERT kuluttaa lineaarisesti aikaa Kokonaisaika on pahimmillaan Θ(n 2 ).

37 TIE Tietorakenteet ja algoritmit Kuinka nopeasti voi järjestää? Taulukon järjestäminen itse asiassa tuottaa sen permutaation, joka tekee alkuperäisestä taulukosta täysin järjestetyn taulukon. Jos taulukon kaikki alkiot ovat erisuuret, ko. permutaatio on yksikäsitteinen. Järjestäminen vastaa kyseisen permutaation etsintää kaikkien mahdollisten permutaatioiden joukosta Esimerkiksi INSERTION-SORT, MERGE-SORT, HEAPSORT ja QUICKSORT perustuvat vertailemiseen. Ne hankkivat tietoa oikeasta permutaatiosta vain vertaamalla alkioita keskenään. Mikä on pienin määrä vertailuja, joka riittää takaamaan oikean permutaation löytymisen?

38 TIE Tietorakenteet ja algoritmit 215 n:n erisuuren alkion taulukolla on n eli n! permutaatiota. Vertailuja on suoritettava niin monta, että ainut oikea vaihtoehto tulee poimituksi niiden joukosta. Jokainen vertailu A[ i ] A[ j ] (tai A[ i ] < A[ j ]) jakaa permutaatiot kahteen ryhmään: ne, joissa A[ i ]:n ja A[ j ]:n keskinäinen järjestys on vaihdettava, ja ne, joissa ei ole, joten... yksi vertailu riittää poimimaan ainoan oikean vaihtoehdon enintään kahdesta kaksi vertailua riittää poimimaan ainoan oikean vaihtoehdon enintään neljästä... k vertailua riittää poimimaan ainoan oikean vaihtoehdon enintään 2 k :stä oikean poimimiseen x:stä vaihtoehdosta tarvitaan ainakin lg x vertailua

39 TIE Tietorakenteet ja algoritmit 216 Jos taulukon koko on n, niin permutaatiota on n! Vertailuja on suoritettava ainakin lg n! kappaletta. vertailemiseen perustuva järjestämisalgoritmi joutuu käyttämään Ω( lg n! ) aikaa. Paljonko on lg n!? lg n! lg n! = n k=1 lg k n k= n 2 lg n 2 n 2 lg n 2 = 1 2 n lg n 1 2 n = Ω(n lg n) Ω(n) = Ω(n lg n) toisaalta lg n! < n lg n + 1 = O(n lg n) lg n! = Θ(n lg n)

40 TIE Tietorakenteet ja algoritmit 217 Jokainen vertailemiseen perustuva järjestämisalgoritmi joutuu siis käyttämään hitaimmassa tapauksessa Ω(n lg n) aikaa. Toisaalta HEAPSORT ja MERGE-SORT ovat hitaimmassakin tapauksessa O(n lg n). Vertailemiseen perustuva järjestäminen on mahdollista hitaimmassa tapauksessa ajassa Θ(n lg n), mutta ei yhtään nopeammin. HEAPSORT ja MERGE-SORT ovat hitaimman tapauksen ajan kulutukseltaan asymptoottisesti optimaalisia. Järjestäminen on aidosti asymptoottisesti työläämpää kuin esim. mediaanin etsintä, joka onnistuu hitaimmassakin tapauksessa ajassa O(n).