3 Lajittelualgoritmeista

Transkriptio

1 3 Lajittelualgoritmeista Tässä osassa käsitellään edistyneempiä lajittelualgoritmeja, erityisesti keko- ja pikalajitteluja. Lisäksi perehdytään hieman lajittelualgoritmien suorituskyvyn rajoihin. Materiaali perustuu pääasiassa kirjan [1] lukuihin 6-8. Liitteeksi on lisätty asiasta kiinnostuneille pikalajittelun matemaattinen analyysi, jonka voi huoletta sivuuttaa, jos ei halua perehtyä asiaan. 3.1 Pikalajittelu Aluksi tutustutaan kenties tavallisimmin käytettyyn yleislajittelualgoritmiin eli pikalajitteluun Pikalajittelu: Johdanto Pikalajittelu (Quicksort) on yleinen lajittelualgoritmi, joka on keskimäärin tehokas ja siten hyvä valinta monessa käytännän tapauksessa. Keskimäärin pikalajittelun suoritusaika on Θ(n lg n) Huonoimmillaan suoritusaika on Θ(n 2 ) Eli vaikka pahimmassa tapauksessa suoritusaika on pitkä, niin keskimääräinen suoritusaika on nopea. Pikalajittelun lisäetu on, että se voidaan toteuttaa siten, että se käsittelee datan paikallaan (in place) Suoritusta varten ei siis tarvitse varata ylimääräistä tilaa muistista. Seuraavissa alaluvuissa käydään läpi pikalajittelun suoritusperiaate Pikalajittelun kuvaus Pikalajittelu perustuu hajota ja hallitse -menetelmään. Lajittelun lähtäkohtana on sarana-alkio (engl. pivot). Muita alkioita verrataan sarana-alkioon. Saranaalkion avulla syöte lajitellaan kahteen osaan: 1. Saranaa suurempiin alkioihin ja 1

2 Kuva 3.1.1: Pikalajittelu: osajonon lajittelussa syntyvät lokerot. 2. Saranaa pienempiin alkioihin Lajittelun jälkeen taulukko sisältää ensin sarana-alkiota pienemmät alkiot sitten sarana-alkion ja lopuksi sarana-alkiota suuremmat alkiot Mutta pienemmät alkiot eivät ole vielä oikeassa järjestyksessa keskenään - eivätkä suuremmatkaan. Nämä järjestetään kutsumalla algoritmia rekursiivisesti. Sarana-alkioon ei tarvitse enää koskea, se on lopullisella paikallaan taulukossa. Lajiteltavat osajonot lyhenevät siis koko ajan - ja sarana-alkiot tulevat oikeille paikoille. Kun kahden alkion osajonot on lajiteltu, koko lajittelu on valmis. Kun osajonoa lajitellaan sarana-alkion perusteella, muodostuu neljä lokeroa kuten kuvassa Kun lajittelu alkaa, on vain lokerot käsittelemätön ja pivot (siis sarana-alkio). Käsittelemätöntä lokeroa käydään läpi vasemmalta oikealle, muuttujaa j kasvattamalla. Muuttuja j kertoo 1. käsittelemättömän alkion sijainnin. Se siis määrittää >pivot ja käsittelemätön -lokerojen välisen rajan. Tästä seuraa, että kun läytyy sarana-alkiota suurempi arvo, sen siirtämiseksi oikeaan lokeroon tarvitsee vain kasvattaa j:n arvoa yhdellä Muuttuja i kertoo lokeron <=pivot viimeisen alkion sijainnin. Kun löytyy sarana-alkiota pienempi alkio, niin lokeroon <=pivot tehdään tilaa muuttujjaa i kasvattamalla.

3 tila otetaan lokerolta >pivot, joten tämän lokeron alkio pitää siirtää talteen Tämä käy helposti: löytynyt sarana-alkiota pienempi alkio sijaitsee juuri >pivot -lokeron oikealla puolella, joten alkiot saadaan oikeisiin lokeroihin vaihtamalla ne keskenään ja kasvattamalla j:n arvoa yhdellä Muuttujan j arvo siis kasvaa yhdellä joka kierroksella, mutta muuttujan i arvo vain silloin, kun löydetään sarana-alkiota pienempi arvo. Lopuksi alkio pivot ja lokeron >pivot 1. alkio vaihdetaan keskenään. Jäljellä on kolme lokeroa, <=pivot, pivot ja >pivot- tässä järjestyksessä Alkiot ovat siis osittain oikeassa järjestyksessä sarana-alkio oikealla paikallaan kaikki sitä pienemmät alkiot sitä ennen kaikki sitä suuremmat alkiot sen jälkeen Seuraavassa vaiheessa suoritetaan sama lajittelu kaksi kertaa: sarana-alkiota pienemmille alkioille ja suuremmille alkioille, jolloin saadaan neljä osajonoa oikeassa järjestyksessä. Näin jatketaan kunnes osajonojen pituus on kaksi alkiota ja nämäkin on lajiteltu.

4 Allaolevassa listauksessa on esitelty pikalajittelu pseudokoodina Input: Taulukon osa A[first,..,last] Output: A[first,..,last] lajiteltuna järjestykseen pienimmästä suurimpaan quicksort(a,first,last) 1. if first < last 2. middle = partition(a,first,last) 3. quicksort(a,first,middle-1) 4. quicksort(a,middle+1,last) 5. return A partition(a,first,last) 8. pivot = A[last] 9. i = first for j = first to last if A[j] <= pivot 12. i = i exchange A[i] with A[j] exchange A[i+1] with A[last] return i Pikalajittelun silmukkainvariantti Ennen silmukkainvariantin tutkimista se on tunnistettava algoritmin toiminnasta. Pikalajittelun tapauksessa partition-funktiossa valitaan sarana-alkio, jonka eri puolille alitaulukon A[first.. last-1] alkiot jaetaan. Partition-funktion ajon aikana taulukko jaetaan neljään eri osioon, joista osa voi olla myäs tyhjiä. Osiot täyttävät tietyt ehdot jokaisen iteraation alussa nämä ehdot ovat pikalajittelun silmukkainvariantti (silmukan kierroksen aikana muuttumaton ominaisuus): 1. Jos first <= k <= i, niin A[k] <= pivot 2. Jos i + 1 <= k <= j 1, niin A[k] > pivot 3. Jos k = last, niin A[k] == pivot Taulukon loppupää, eli osio j:stä last-1:een ei ole missään järjestyksessä, eli sitä ei ole käsitelty.

5 3.1.4 Pikalajittelun silmukkainvariantin analyysi Tutkitaan, täyttyvätkö silmukkainvariantin kolmen osan oikeellisuusvaatimukset: Alustus For-silmukan alussa i = first 1 ja j = first Alkioiden first ja i välissä ei ole alkioita, kuten ei myöskään alkioiden i + 1 ja j 1. Tämän vuoksi silmukkainvariantin kaksi ensimmäistä ehtoa täyttyvät triviaalisti (k ei voi olla first:n ja i:n välissä) Sijoitus pivot = A[last] täyttää ehdon 3 Ylläpito Jos ehto A[j] <= pivot on epätosi, j:tä kasvatetaan, eikä muuta tapahdu Tälläin ehto 2 toteutuu A[j 1]:lle, ja muut ehdot täyttyvät edelleen Jos ehto A[j] <= pivot on tosi, i:tä kasvatetaan, A[i]:n ja A[j]:n paikat vaihdetaan, ja j:tä kasvatetaan Lopetus Huomaa, että i:tä kasvatetaan ennen paikkojen vaihtoa 1. ehto täyttyy, koska paikkojen vaihdon seurauksena A[i] <= pivot 2. ehto täyttyy, koska alkio A[j 1] (huomaa, j:tä on kasvatettu) on juuri paikkaa vaihtanut alkio, joka on aiemmin testattu suuremmaksi kuin sarana-alkio 3. ehto täyttyy, edelleen triviaalisti Nyt j = last, niin ehtojen 1 ja 2 kuvaamat osiot ja sarana-alkio kattavat koko taulukon; kaikki alkiot on siis jaettu invariantin kuvaamiin kolmeen osioon Pikalajittelun silmukkainvariantista on todistettu kaikki sen osa-alueet, joten voidaan todeta että lajittelu toimii oikein.

6 3.1.5 Pikalajitteluesimerkki Lajiteltava taulukko A on: [7, 2, 6, 1, 4, 5]. Taulukon Indeksointi aloitetaan ykkäsestä. Valitsemme sarana-alkioksi viimeisen alkion 5 Merkitään sarana-alkio _5_ Merkitään käsiteltävä alkio kaarisulkuihin () Tilanne: [ 7, 2, 6, 1, 4 _5_] i = 0, j = 1: [ (7), 2, 6, 1, 4 _5_] 7 > 5, joten ei vaihdeta i = 0, j = 2: [ 7 (2), 6, 1, 4 _5_] 2 <= 5, joten vaihdetaan A[i+1] ja A[j] i = 1, j = 3: [2 7 (6), 1, 4 _5_] 6 > 5, joten ei vaihdeta i = 1, j = 4: [2 7, 6 (1), 4 _5_] 1 <= 5, joten vaihdetaan A[i+1] ja A[j] i = 2, j = 5: [2, 1 6, 7 (4) _5_] 4 <= 5, joten vaihdetaan A[i+1] ja A[j] Tilanne [2, 1, 4 7, 6 _5_], i=3 Vaihdetaan lopuksi A[i+1] ja A[last] Tilanne [2, 1, 4, 5, 6, 7], middle=4 Kuten esimerkistä käy ilmi, pikalajittelu ei pyri suoraan sijoittamaan alkioita oikeille paikoille. Sarana-alkion avulla luodaan suurempien ja pienempien arvojen luokat Luokkien rekursiivinen jakaminen aliluokkiin johtaa täydelliseen suuruusjärjestykseen Pikalajittelun suorituskyky Pikalajittelun suorituskyky riippuu siitä, miten sarana-alkio (pivot) valitaan; tuottaako valinta

7 tasapainoisen (balanced) alkiojoukon vaiko epäsuhtaisen (unbalanced) alkiojoukon Sarana-alkion valinta vaikuttaa suoraan luokkien kokoon, joka puolestaan vaikuttaa pikalajittelun suoritusaikaan. Mitä tasaisemmin luokkajako toteutetaan, sitä parempi on pikalajittelun suorituskyky. Paras tapaus Luokat > pivot ja <= pivot ovat samansuuruisia Suoritusaika verrattavissa lomituslajitteluun Huonoin tapaus Toinen luokista on koko ajan tyhjä Suoritusaika verrattavissa lisäyslajitteluun Pikalajittelun huonoimman tapauksen jako Pahimmassa tapauksessa on kyse siitä, että sarana-alkio on valittu huonosti, eli sarana-alkio on valittu joko liian pieneksi tai liian suureksi. Luokkien koot eivät ole samansuuruiset, jolloin pikalajittelun teho heikkenee Pahimmassa tapauksessa joko > pivot- tai <= pivot-luokka on tyhjä jokaisella rekursion tasolla partition-funktion suoritusaika on Θ(n) tyhjän puolen suoritusaika on T (0) = Θ(1) Suoritusaikaa kuvaava toistuvuus saa muodon Intuitio kertoo, että T (n) = T (n 1) + T (0) + Θ(n) = T (n 1) + Θ(n) T (n) = T (n 1) + T (n 2) +... Muodostuu siis aritmeettinen sarja ja voimme arvata toiston ratkaisuksi Θ(n 2 ) ja käyttää sijoitusmenetelmää todistamiseen.

8 3.1.8 Pikalajittelun parhaan tapauksen jako Parhaan tapauksen luokkajaossa valitaan sarana-alkioksi keskimmäinen, eli mediaani alkio. Koska valitaan mediaani, niin luokat > pivot ja <= pivot ovat samansuuruisia, jolloin saavutetaan paras suoritusaika. Parhaassa tapauksessa on kyse siis tasapainotetusta alkiojoukosta. partition-funktio tuottaa aina kaksi samansuuruita alkiojoukkoa Toistuvuus on tässä tapauksessa muotoa: T (n) 2T (n/2) + Θ(n), missä Θ(n) sisältää partition-funktion käyttämän ajan. Pääteoreeman ( Master Theorem ) avulla parhaan tapauksen suoritusajaksi saadaan Θ(n lg n). Tämä on asymptoottisesti parempi kuin huonoimman tapauksen aika Tasainen luokkajako Pikalajittelun keskimääräinen asymptoottinen suoritusaika on paljon lähempänä parasta tapausta Θ(n lg n) kuin huonointa tapausta Θ(n 2 ). Jakamista ei välttämättä tarvitse suorittaa tasan, jotta saadaan Θ(n lg n) asymptoottiseksi suoritusajaksi. Sama asymptoottinen suoritusaika saadaan, vaikka jako toteutettaisiin suhteessa 1:99! Tämän käytäksen syyn ymmärtäminen on avain pikalajittelun ymmärtämiseen. Seuraavassa tutkimme, miten luokkajaon tasaisuus näkyy toistuvuudessa. Oletetaan, että partition-funktio tuottaa aina 9:1 -luokkajaon, joka vaikuttaa aika huonolta. Tämä voidaan kuvata toistuvuudella T (n) T (9n/10) + T (n/10) + cn. Tässä c on otettu esiin, vrt. yllä, missä se on Θ(n):ssä piilossa. Piirtämällä tämä rekursiopuu (vrt. luento 4 ja kirjan sivu 71, 2nd ed.), voidaan todeta, että toistuvuus päättyy syvyydellä log 10/9 (n). Vastaavasti 1:99- jaon tapauksessa syvyys olisi log 100/99 (n). Esimerkiksi, kun n = 100, olisivat puiden syvyydet siis log 10/9 (100) = 43 ja log 100/99 (100) = 458. Kun taas parhaassa tapauksessa log 2 (100) 7 Jokaisen puun tason suoritusaika on cn (partition-funktio). Tämän lisäksi muistamme, että logaritmin kantaluvun vaihtaminen muuttaa sen suuruutta vakiokertoimella. Vaikka suhde siis olisi kuinka epätasainen, niin epäsuhta vaikuttaa suoritusaikaan vakiokertoimella. Vakiokerroin ei vaikuta asymptoottiseen käyttäytymiseen. Voimme todeta, että mikä tahansa kaikilla tasoilla vakio jakosuhde tuottaa saman Θ(n log n) asymptoottisen käyttäytymisen.

9 Satunnaistettu pikalajittelu Jotta pikalajittelu toimisi keskimäärin hyvin, voidaan se satunnaistaa. Eräässä menetelmässä partition-funktio valitsee sarana-alkion saamastaan aineistosta satunnaisesti ja muuten lajittelu toimii kuten aiemmin on esitetty.

10 3.2 Kekolajittelu (Heapsort) Tässä kappaleessa esitellään kekolajittelu. Lajittelu perustuu keko (heap) - nimisten tietorakenteiden muokkaukseen ja ylläpitoon. Tietorakenteella on siis keskeinen rooli algoritmin suorituksessa. Kekolajittelulle pätee: Suoritusaika T (n) O(n lg n), kuten lomituslajittelussa. In-place lajittelu eli vakiomääräinen muistinkäyttö, kuten lisäyslajittelussa. Kekolajittelulla on siis molempien aiemmin esiteltyjen algorimien hyvät ominaisuudet. Jotta ymmärrämme kekolajittelun toiminnan, tutustumme ensin binääripuuhun ja määrittelemme keon sen avulla. Näytämme, miten keko voidaan toteuttaa taulukolla ja esittelemme keon käsittelyyn ja ylläpitoon tarvittavat algoritmit. Tämän jälkeen meillä on kaikki tarvittava kekolajittelun toteuttamiseen ja analysoimiseen. Myöhemmin tutustumme myös toiseen kekojen sovellutukseen, prioriteettijonoihin Binääripuu ja keon määritelmä Binääripuu määritellään seuraavasti: Yksi juurisolmu (root node). Jokaisen solmun lapsisolmujen (child node) määrä on korkeintaan kaksi. Tämä solmu on näiden lapsisolmujen vanhempi (parent). Sivu eli väli (engl. edge) yhdistää vanhemman sen lapsisolmuun. Lapsisolmuista käytetään nimityksiä vasen lapsi(solmu) (left child), sekä oikea lapsi(solmu) (right child). Lehtisolmu (leaf node) on (binääri)puun solmu, jolla ei ole lapsisolmuja. Täydellinen binääripuu sisältää joka tasolla aina joko nolla tai kaksi lapsisolmua, ja puu on kokonaisuudessaan täytetty lehtisolmujen tasolla. Binäärinen maksimikeko seuraavilla rajoituksilla: voidaan määritellä lähes täydellisenä binääripuuna Vanhempi on aina suurempi kuin sen lapset.

11 Lehtisolmuja saa puuttua, kunhan ne puuttuvat puun oikeasta reunasta Vastaavasti minimikeossa vanhempi on aina pienempi kuin sen lapset. Käytämme tässä luvussa kekoa ja binääristä maksimikekoa synonyymeina ja mainitsemme erikseen kun on kyse minimikeosta. Kuvassa vasemmalla on esitetty kokonaislukuja sisältävä keko binääripuuna. Kuva 3.2.1: Vasemmalla keon puuesitys ja oikealla puuta vastaava taulukko Keon toteuttaminen taulukolla Koska keko on lähes täydellinen binääripuu, se voidaan toteuttaa kompaktisti ja tehokkaasti taulukolla, kuten kuvassa oikealla. Taulukossa indeksillä i sijaitsevan solmun lapset ovat indekseillä 2i ja 2i + 1. Huom! Tässä oletetaan että taulukon ensimmäinen indeksi on 1! Seuraavassa listauksessa alla on esitetty keon alustamiseen ja keossa navigoitiin tarvittavat rutiinit.

12 1. init(aheap, array=none) 2. if array == None: 3. array = [] 4. aheap.data = array 5. aheap.size = array.length getparent(i) 8. return i / getLeftChild(i) 11. return 2*i getRightChild(i): 14. return (2*i + 1) Kekomuuttuja aheap alustetaan rutiinissa aheap. Taulukon kopioimisen lisäksi alustetaan muuttuja aheap.size, joka on kekoon kuuluvien alkioiden määrän taulukossa aheap.data. Todellisuudessa tässä vaiheessa aheap ei vielä ole keko, sillä se ei toteuta aiemmin kerrottua keon määritelmää. Seuraavaksi täytyy määritellä algoritmi, jolla taulukosta saadaan luotua keko. Lisäksi haluamme että keosta voi poistaa ja siihen voi lisätä alkioita, niin että määritelmän mukaiset ominaisuudet säilyvät. Maksimikeon tulee toteuttaa siis aheap.data[getparent(i)] >= aheap.data[i] kaikilla i, 1 < i <= aheap.size. Vastaavasti minimikeolle pätee aheap.data[getparent(i)] <= aheap.data[i]. Kun jompi kumpi ehto ylläolevista on voimassa, sanotaan että taulukko toteuttaa keko-ominaisuuden Binääripuun korkeus Binääripuun korkeus (height) määritellään seuraavasti: Puun pisimmän lehtisolmusta juurisolmuun johtavan reitin sivujen lukumäärä. Lehtisolmujen korkeus on 0. Muille solmuille korkeus voidaan laskea kuten koko puulle: solmusta lehtisolmuun johtavan reitin sivujen lukumäärä laskemalla. n alkiota sisältävän keon korkeudelle pätee aina: height = Θ(log 2 n) = O(lg n)

13 Tämä nähdään suoraan täydellisen binääripuun kuvasta: tasoilla on solmuja 1, 2, 4, 8, 16, 32,... Luennon myähemmissä osissa nähdään, että keoille tehtävien perusoperaatioiden suoritusaika on aina suhteessa keon korkeuteen : Asymptoottisesti rajoitettuja koon suhteen. O(lg n) Keko-ominaisuuden ylläpito Annetun n-mittaisen taulukon A muokkaaminen maksimikeoksi perustuu kahteen havaintoon: Alkiot A[( n/2 +1)...n] ovat lehtisolmuja. Jokainen lehtisolmu on triviaali maksimikeko. Osa taulukosta toteuttaa siis aina maksimikeko-ominaisuuden! Määritellään nyt algoritmi maxheapify(aheap, i), jonka avulla voimme ylläpitää kekoominaisuutta. Algoritmi olettaa, että alipuut, joiden juurisolmuina ovat aheap.data[getleftchild(i)] ja aheap.data[getrightchild(i)], ovat jo valmiiksi maksimikekoja. Tarkasteltavana olevan puun juuri on alkio i - tämä alkio saattaa rikkoa keko-ominaisuuden. Tarkoituksena on pudottaa alkio i oikealle paikalleen alipuussa - jonka juurena se aluksi on. Pudottaminen tapahtuu vaihtamalla alkio i suuremman lapsensa kanssa ja toistamalla tätä rekursiivisesti, kunnes alkion lapset ovat pienempiä kuin alkio itse.

14 Input: Keko aheap ja indeksi i, jonka alipuut ovat maksimikekoja Output: Puu, jonka juuri on indeksi i, kekojärjestyksessä maxheapify(aheap, i) 1. left = getleftchild(i) 2. right = getrightchild(i) if (left <= aheap.size and 5. aheap.data[left] > aheap.data[i]) 6. largest = left 7. else 8. largest = i if (right <= aheap.size and 11. aheap.data[right] > aheap.data[largest]) 12. largest = right if largest!= i 15. exchange aheap.data[i] with aheap.data[largest] 16. maxheapify(aheap, largest) Taulukon alkiot ovat siis puun solmuja, taulukon indeksi ilmaisee solmun sijainnin puussa aheap on viittaus muokattavaan puuhun, joka mahdollisesti ei ole keko, ts. tällä puulla ei välttämättä ole keko-ominaisuutta. i on taulukon sisälle viittaava indeksi, jolle pätee i <= aheap.size. Solmun i alipuilla on keko-ominaisuus ennen jokaista maxheapify:n kutsua. Mutta miten koko puusta saadaan maksimikeko, algoritmihan laittaa vain yhden solmun paikalleen? Vastaus: Käymällä koko puu tällä algoritmilla läpi lehdistä juureen päin, kukin solmu vuorollaan algoritmille välitettävänä solmuna i Puuta järjestetään lehdistä juureen päin, koska algoritmin toiminta perustuu siihen, että käsiteltävän solmun alipuut ovat kekoja

15 3.2.5 maxheapify:n toiminta Kuva havainnollistaa maxheapify -algoritmin toimintaa aiemmin esitellylle esimerkkikeolle aheap.size = 10, jossa nyt indeksillä 2 oleva alkio rikkoo maksimikeko-ominaisuuden. Algoritmia kutsutaan maxheapify(aheap, 2) Indeksistä 1 ei voi aloittaa, koska algoritmi olettaa, että vasen ja oikea lapsisolmu toteuttavat jo valmiiksi maksimikeko-ominaisuuden. Kuva 3.2.2: Kutsusta maxheapify(aheap, 2) seuraava toiminta vaiheittain: (a) Alkuperäinen keko, jossa alkio indeksillä 2 rikkoo maksimikekoominaisuuden. (b) Maksimikeko-ominaisuus on palautettu indeksille 2, mutta indeksillä 4 oleva alikeko on vielä järjestettävä, tämä voidaan tehdä kutsumalla algoritmia rekursiivisesti. (c) Maksimikeko-ominaisuus on nyt palautettu indeksille 4, ja seuraava rekursiivinen kutsu algoritmiin ei enää tuota muutoksia, koska aheap.size -rajoitus rikkoutuu.

16 Riveillä 5-11 haetaan muuttujan largest arvoksi vanhemman ja kahden lapsen joukosta suurimman alkion indeksi Riveillä pudotetaan alkio i alaspäin yhden tason verran (lapsien tasolle), jos se ei ollut suurin. Rivillä 15 kutsutaan algortimia rekursiivisesti, alkion pudottamiseksi vielä alaspäin (jos tarpeen) maxheapify:n suoritusaika maxheapify -algoritmin suoritusaika kokoa n olevalle keolle (juurisolmu indeksillä i) koostuu kahdesta osasta: 1. Vakiosuoritus Θ(1) joka kuluu alkioiden aheap[i], aheap[aheap.getleftchild(i)] sekä aheap[aheap.getrightchild(i)] keskinäiseen järjestelyyn (huomaa ettei rekursion sisällä ole silmukoita). 2. Rekursiivinen kutsu alikeolle, jonka juurisolmu on jompikumpi indeksin i lapsista. Tälläin uuden alikeon suurin mahdollinen koko suhteessa edelliseen kekoon on 2n/3. Suoritukselle saadaan: T (n) T (2n/3) + Θ(1), joka kuuluu pääteoreeman (master theorem) toiseen luokkaan, jolloin asymptoottiseksi tehokuudeksi saadaan T (n) O(lg n). Vaihtoehtoisesti alkiolle joka sijaitsee korkeudella h, saadaan maxheapify -suoritusaika T (h) O(h), joka viittaa aiemmin esitettyyn keon korkeuden ja operaatioiden suoritusaikojen vastaavuuteen.

17 3.2.7 Kekojen rakentaminen Seuraavaksi tutkitaan, miten keosta aheap saadaan yleisessä tapauksessa rakennettua maksimikeko, eli binääripuu joka toteuttaa maksimikeko-ominaisuuden. Voidaan osoittaa: n alkiota sisältävän keon mallintavassa taulukossa alkiot aheap.data[floor(n/2)+1.. n+1] ovat kyseisen keon lehtisolmuja. Esimerkkitapauksessa keon koko on 10, jolloin ensimmäisen lehtisolmun indeksiksi saadaan 10/2 + 1 = 6. Jokainen näistä lehtisolmuista on omassa kontekstissaan atominen maksimikeko! Rakentaminen voidaan aloittaa indeksistä n/2 ja kutsua edellä esitettyä maxheapify-algoritmia kaikille taulukon lehtisolmuja edeltäville alkioille. Näin saadaan määriteltyä uusi algoritmi, buildmaxheap(aheap), joka on esitelty alla: Input: Keko aheap Output: Keosta maksimikeko buildmaxheap(aheap) 1. for i = aheap.size / 2 downto 1 2. maxheapify(aheap, i) Tämä algoritmi siis aloittaa taulukon viimeisestä lehtisolmuja edeltävästä solmusta ja peruuttaa kohti taulukon alkua. Toisin sanoen, algoritmi kiipeää alhaalta kohti puun juurisolmua buildmaxheap:in oikeellisuus buildmaxheap -algoritmin oikeellisuus voidaan tarkistaa sen silmukkainvariantin avulla, joka tässä tapauksessa on: For-silmukan jokaisen kierroksen alussa jokainen indeksien (i + 1) ja n välillä oleva taulukon aheap.data alkio on erään maksimikeon juurisolmu. Alustus: Ennen ensimmäistä for-silmukkaa indeksien n/2 + 1 ja n välillä olevat taulukon aheap.data alkiot ovat pelkkiä lehtisolmuja, joten ne ovat kaikki omassa kontekstissaan ns. atomisia maksimikekoja.

18 Ylläpito: Ennen jokaista for-silmukan toistoa: Kaikki indeksin i oikealla puolella taulukossa olevat alkiot ovat omien maksimikekojensa juurisolmuja (kuten silmukkainvariantissa on todettu). Myäs indeksin i alkion vasen ja oikea lapsisolmu ovat omien maksimikekojensa juurisolmut (ne sijaitsevat taulukossa indeksin i oikealla puolella). Tämä on perusvaatimus maxheapify -algoritmin suoritukselle! For-silmukan toiston jälkeen myäs indeksillä i oleva alkio on maksimikeon juurisolmu. Indeksin i pienentäminen ennen seuraava silmukkaa alustaa silmukainvariantin. Lopetus: for-silmukka lopettaa suorituksensa sen jälkeen, kun maxheapify(aheap, 1) on suoritettu taulukon 1. alkiolle. Tämä varmistaa, että taulukon aheap ensimmäinen alkio on sijoitettu omalle paikalleen keossa, jonka jälkeen koko taulukko on käyty läpi, ja taulukon kaikki alkiot toteuttavat maksimikeko-ominaisuuden buildmaxheap:in suoritusaika buildmaxheap -algoritmille voidaan suoraviivaisesti määrittää suoritusajan yläraja: Jokainen maxheapify -kutsu suorittuu ajassa O(lg n) Näitä suorituksia on O(n) kappaletta (vakiokerroin, tässä tapauksessa 1/2, voidaan jättää asymptoottisessa tarkastelussa pois). Näin ollen suoritusajalle saadaan: T (n) O(n lg n). Vaikka tämä tulos on eräs yläraja buildmaxheap-algoritmille, niin se ei ole asymptoottisesti tarkka! Koska tiedetään että maxheapify -algoritmin suoritusaika on aina riippuvainen järjestettävän alikeon korkeudesta, nyt voidaan todeta että suurin osa näistä alikeoista on korkeudeltaan suhteellisen matalia. Voidaan osoittaa että n alkiota sisältävän keon korkeus on aina lg n,

19 ja että korkeudella h keossa on enintään n 2 h+1 alkiota. Nyt asymptoottisesti tarkaksi ylärajaksi saadaan: T (n) lg n h=0 n O(h) = O n 2 h+1 lg n h=0 ( h = O n 2 h h=0 ) h = O(n), 2 h jossa on huomattu että äärettämän sarjan summa on suurempi kuin äärellisen ja tämän jälkeen käytetty tulosta h 1/2 h=0 =, joka voidaan johtaa 2 h (1 1/2) 2 (kokeile!) geometrisen sarjan derivaatan avulla. Tämän alaluvun tärkein viesti on siis: Maksimikeko voidaan rakentaa taulukosta lineaarisessa ajassa! Kekolajittelun algoritmi Ensimmäisenä kekojen sovellutuksena tässä kurssissa esitellään kekolajittelu. Kekolajittelu (heapsort(aheap)) -algoritmi rakentuu buildmaxheap(aheap) -algoritmin toiminnalle. Algoritmin järjestää annetun taulukon alkiot pienimmästä suurimpaan seuraavalla tavalla: 1. Järjestetään taulukko maksimikeoksi (init(aheap, array) ja buildmaxheap(aheap)). 2. Huomataan, että koska taulukon suurin alkio on nyt keon juurisolmu aheap.data[1], se voidaan asettaa oikealle paikalleen lajitellussa taulukossa vaihtamalla sen ja keon viimeisen alkion aheap.data[n] paikat keskenään. 3. Pienennetään keon kokoa yhdellä 4. Asetetaan uusi juurisolmu oikealle paikalleen keossa (maxheapify(aheap, 1)). 5. Jos keon koko on suurempi kuin yksi, palataan kohtaan 2. Kekolajittelun pseudokoodi on esitetty alla:

20 Input: Keko aheap Output: Taulukko aheap.data järjestyksessä heapsort(aheap) 1. buildmaxheap(aheap) 2. for i = aheap.size downto 2 3. exchange aheap.data[1] with aheap.data[i] 4. aheap.size = aheap.size maxheapify(aheap, 1) Kekolajittelun oikeellisuus heapsort(aheap) -algoritmin silmukkainvariantti määräytyy nyt seuraavasti: Alustus: For-silmukan jokaisen suorituskerran alussa alitaulukko aheap.data[1..i] on maksimikeko, joka sisältää taulukon i pienintä elementtiä. Alitaulukko aheap.data[(i + 1)..n] puolestaan sisältää taulukon (n - i) suurinta elementtiä lajitellussa järjestyksessä. Ennen ensimmäistä for-silmukkaa: Alitaulukko aheap.data[1..i] sisältää kaikki taulukon alkiot maksimikeossa. Toinen alitaulukko puolestaan sisältää (n - i) = 0 alkiota, eli se on tyhjä. Ylläpito: Koodin suorituksesta huomataan: Koska jokaisen for -silmukan aluksi alitaulukon päissä olevat alkiot vaihdetaan keskenään, jäljellä oleva keko ei välttämättä toteuta maksimikekoominaisuutta, jolloin sille ei voi ajaa maxheapify -algoritmia. for -silmukan sisällä keon kokoa aheap.size pienennetään, jolloin taulukon päähän vaihdettu alkio suljetaan pois keon rakenteesta. Uuden juurisolmun molemmat lapset toteuttavat maksimikeko-ominaisuuden, ja poistettu alkio siirtyy alitaulukkoon aheap.data[(i + 1)..n] joka on lajitellussa järjestyksessä, koska sitä täydennetään oikealta vasemmalle maksimikekojen juurisolmujen alkioilla. Pienennetylle keolle suoritettu maxheapify -algoritmi alustaa silmukan seuraavalle kierrokselle.

21 Lopetus: jälkeen for -silmukka suoritetaan viimeisen kerran, kun i = 2. Tämän alitaulukko aheap.data[2..n] sisältää yhtä vaille kaikki alkuperäisen taulukon alkiot lajitellussa järjestyksessä. Puuttuva alkio on aheap.data[1], joka on alkuperäisen taulukon pienin alkio. Koko taulukko on nyt lajitellussa järjestyksessä Kekolajittelun suoritusaika heapsort-algoritmin asymptoottinen suoritusaika voidaan suoraviivaisesti päätellä: Yksi buildmaxheap-algoritmin kutsu suorittuu O(n) ajassa, jonka lisäksi maxheapify-algoritmin rekursiivinen suorittaminen kestää (n 1)O(lg n). Koska O-notaatioiden summasta asymptoottiseksi ylärajaksi voidaan erottaa korkein termi, heapsort -algoritmille saadaan: T (n) O(n lg n) Kuten luennon alussa mainittiin, heapsort-algoritmin toiminta perustuu tietorakenteen (tässä tapauksessa keon) rakentamiseen ja hallintaan. Kuten seuraavissa luennoissa tullaan huomaamaan, tietorakenteen ja algoritmin yhteistoiminta on yksi tehokkaiden algoritmien perusominaisuuksista, ja algoritmin toimintaa voidaan usein tehostaa käyttämällä mahdollisimman hyvin suoritukseen soveltuvaa tietorakennetta (tai suunnittelemalla sellainen). 3.3 Lajittelualgoritmien suorituskyvyn rajoista Kun on n alkiota lajiteltavana, ne voivat alussa olla n! erilaisessa järjestyksessä. Vertailuun perustuvaa lajittelualgoritmia voidaan tarkastella binääripuuna, jossa solmut vastaavat vertailuja. Tällöin polku juuresta lehteen kuvaa lajittelussa tehtyjä vertailuja, jolloin lehti kertoo mihin järjestykseen juuri näillä vertailuilla ja niiden tuloksilla syöte päätyy. Kuva hahmottaa tilannetta:

22 Kuva 3.3.1: Päätöspuu eräälle kolmen alkion (a 1, a 2, a 3 ) lajitteluun tarkoitetulle algoritmille. Yllä merkintä a i? a j tarkoittaa vertailua alkioiden a i ja a j välillä. Puu haarautuu vertailun tuloksen mukaan. Puun lehti ilmaisee alkioiden järjestyksen, esimerkiksi a 3, a 1, a 2 tarkoittaa, että alkioiden suuruusjärjestys on a 3 a 1 a 2. Koska kolme alkiota voi olla 6 (= 3!) eri järjestyksessä, puussa on oltava vähintään kuusi lehteä. Olkoon taulukossa n alkiota ja olkoon A jokin vertailuun perustuva lajittelualgoritmi. Tällöin lajittelualgoritmia A vastaavassa puussa on oltava vähintään n! lehteä. Oletetaan, että puun syvyys on s: tällöin on olemassa sellainen taulukon alkujärjestys, että joudutaan tekemään s vertailua ennen kuin taulukko on järjestyksessä. Siten algoritmin kompleksisuus on huonoimmassa tapauksessa s. Koska kyseessä on binääripuu, siinä on korkeintaan 2 s lehteä. Siis, jotta jokaista alkujärjestystä vastaisi puun lehti, on oltava n! 2 s lg(n!) s. Koska luvun n kertomassa n! on vähintään n/2 lukua suuruudeltaan ainakin n/2, on selvää että joten n! (n/2) (n/2) lg(n!) (n/2) lg(n/2) = (1/2) nlg(n) (n/2). s (1/2) nlg(n) (n/2) Θ(nlg(n)). Näin ollen vertailuun perustuvan lajittelualgoritmin kompleksisuus on vähintään luokkaa Θ(nlg(n)). Siten lomituslajittelu ja pikalajittelu ovat kompleksisuudeltaan optimaalisia.

23 On olemassa lajittelualgoritmeja, jotka toimivat nopeammin, esimerkiksi lineaarisessa ajassa. Edellä olevan tarkastelun mukaan ne perustuvat johonkin muuhun kuin pelkkään alkioiden vertailuun. Tällainen algoritmi on esimerkiksi laskentalajittelu, joka vaatii esitietona alkioiden ala- ja ylärajan (ks. [1], kappale 8.2). Tällöin voidaan laskemalla pitää tietoa siitä kuinka moni alkio on annettua alkiota pienempi ja saadaan taulukko järjestettyä lineaarisessa ajassa. Oletetaan, että luvut ovat väliltä [0,k], missä k on jokin positiivinen vakio. Seuraavassa laskentalajittelualgoritmi: Input: Taulukko A[1,..,n], n >= 1, luku k >= max(a) Output: Taulukko B[1,..,n], jossa A:n alkiot järjestyksessä LASKENTALAJITTELU(A,k) 1. varaa taulukko B[1,..,n] 2. varaa taulukko C[0,..k] // Väliaikainen työtaulukko 3. for i=0 to k 4. C[i] = 0 5. for j=1 to length(a) 6. C[A[j]] = C[A[j]]+1 7. // Taulukossa C[i] on niiden A:n alkioiden lukumäärä, jotka 8. // yhtäsuuria kuin i 9. for i=1 to k 10. C[i] = C[i]+C[i-1] 11.// Nyt taulukossa C[i] on niiden A:n alkioiden lukumäärä, 12.// jotka ovat pienempiä tai yhtäsuuria kuin i 13.// Seuraavaksi sijoitetaan A:n alkiot kerralla 14.// oikeaan kohtaan taulukossa B 15.for j = length(a) downto B[C[A[j]]] = A[j] 17. C[A[j]] = C[A[j]]-1 18.return B Esimerkki. Olkoon lajiteltava taulukko A: Silloin aputaulukon C indeksit ovat ja rivin 8 suorituksen jälkeen taulukon C paikalla i on arvon i esiintymien lukumäärä taulukossa A. Siis C: Tämän jälkeen lasketaan taulukossa C peräkkäiset arvot yhteen vasemmalta alkaen, minkä jälkeen taulukossa C indeksi i kertoo taulukossa A arvoa i pienempien tai yhtäsuurien arvojen lukumäärän. Siten C:

24 Täten taulukkoon B voidaan sijoittaa A:n alkiot heti oikealle paikalle, kun käydään taulukko A läpi. Riviltä 12 alkavan silmukan ensimmäisen kierroksen jälkeen (A[6] = 2, C[2] = 2) taulukko B: ja C: Nyt luku 2 on oikealla paikalla taulukossa B. Seuraavalla kierroksella (jolloin A[5] = 4, C[4] = 6) taulukko B: ja C: Näin jatkamalla saadaan kaikki taulukon A alkiot taulukkoon B oikealla paikalle. Lopussa taulukko B: ja C: Koska algoritmi käy taulukon A kahdesti läpi samoin kuin taulukon C, algoritmin kompleksisuus on luokkaa Θ(n + k), missä n on taulukon A koko ja k taulukon A suurin alkio (kun oletetaan että A ei sisällä negatiivisia lukuja).

25 Kirjallisuutta [1] Cormen, T.H., Leiserson, C.E., Rivest, R.L., Stein, C. Introduction to Algorithms, 2nd edition, The MIT Press Liite: Pikalajittelun matemaattinen analyysi Suoritusaika huonoimmassa tilanteessa: Olemme aiemmin olettaneet, että pikalajittelun luokkajaon valitseminen jokaisessa vaiheessa s.e. toinen luokista on tyhjä on huonoin mahdollinen jako. Pahimmassa tapauksessa pikalajittelun suoritusaika vaikuttaisi olevan O(n 2 ). Perustellaan näitä hieman. Pikalajittelun suoritusaika voidaan kirjoittaa T (n) = T (q) + T (n q 1) + Θ(n) (3.3.1) Tässä q vaihtelee 0:n ja n 1:n välillä, koska partition-funktio tuottaa kaksi aliongelmaa joiden yhteinen koko on n 1 (siis ilman sarana-alkiota). Arvaamme nyt, että T (n) cn 2 jollakin vakiolla c. Jos sijoitamme tämän yhtälään (3.3.1), saamme T (n) cq 2 + c(n q 1) 2 + Θ(n) = c[q 2 + (n q 1) 2 ] + Θ(n). (3.3.2) Koska olemme nyt etsimässä huonointa suoritusaikaa, tarkastellaan tämän funktion maksimia q:n suhteen (eli aliongelmien koon suhteen): max T (n) max 0 q n 1 0 q n 1 [cq2 + c(n q 1) 2 + Θ(n)] (3.3.3) Yhtälässä (3.3.3) Lauseke q 2 + (n q 1) 2 on yläspäin aukeava paraabeli q:lle. Se saavuttaa siis suurimman arvonsa alueen 0 q n 1 päätepisteessä. Kokeilemalla huomataan että lauseke saa saman arvon sekä sijoituksella q = 0 että q = n 1. Saadaan siis max 0 q n 1 (q2 + (n q 1) 2 ) = (n 1) 2 = n 2 2n

26 Sijoitetaan tämä välitulos takaisin epäyhtälään (3.3.3), jolloin saadaan max T (n) 0 q n 1 cn2 c(2n 1) + Θ(n) cn 2 (3.3.4) Viimeinen epäyhtälä (3.3.4) voidaan osoittaa tarkasti induktiolla. Huomaa, että voimme valita riittävän suuren c:n, jotta c(2n 1) on paljon suurempi kuin Θ(n). Näin saamme max T (n) 0 q n 1 O(n2 ), mikä oletettiin aiemmin. Vastaavalla käsittelyllä voidaan etsiä pikalajittelun huonoimman tapauksen alaraja. Pikalajittelun keskimääräinen suoritusaika Oletamme nyt että meillä on käytässä satunnaistettu pikalajittelu (randomized quicksort). Olemme aiemmin arvioineet, että keskimääräinen suoritusaika on O(n lg n). Tutkimalla tarkemmin pikalajittelun toimintaa näemme, että rekursion syvyys on Θ(lg n) ja jokaisen tason suoritus kestää O(n) luokkaa. Sama asymptoottinen suoritusaika saavutetaan, vaikka osa tasoista (jaoista) olisi täysin epätasapainoisia. Voimme täsmällisemmin analysoida satunnaisen pikalajittelun, kun ymmärrämme paremmin kuinka algoritmi jakaa aineistoa osiin. Toiveenamme on johtaa keskimääräiselle suoritusajalle asymptoottinen yläraja O(n lg n). Tiedämme parhaan tapauksen perusteella että alaraja on Ω(n lg n) ja tälläin olemme osoittaneet keskimääräisen tapauksen suoritusajalle T (n) Θ(n lg n). Pikalajittelun suoritusajasta leijonaosa menee aineiston jakamisessa osiin (partition-funktio). Joka kerta kun aineisto jaetaan, valitaan sarana-alkio, jota ei koskaan käytetä myähemmissä rekursioissa. Koko pikalajittelun aikana suoritetaan korkeintaan n kappaletta partition-funktion kutsua Yksi aineiston jakaminen kestää O(1) ja ajan joka menee (for j = first to last-1)-lohkon suorittamiseen. Jokainen iteraatio suorittaa ainakin vertailuoperaation, jossa se vertaa alkiota sarana-elementtiin. Jos voimme laskea kuinka monta kertaa yhteensä tämä vertailu suoritetaan, voimme myäs antaa rajoituksen sille kuinka kauan aikaa vietetään for-silmukassa pikalajittelun suoritusajasta. Teemme ensin kaksi oletusta:

27 Lemma 7.1: Olkoon X aineiston jakamisessa suoritettava vertailujen määrä n:n alkion kokoisessa pikalajittelussa. Tässä tapauksessa pikalajittelun suoritusaika on O(n + X) Todistus: Kuten ylhäällä tekstissä on todettu, aineiston lajittelussa partitionfunktiota kutsutaan n kertaa, joista jokainen kutsu tekee saman määrän muita tehtäviä ja suorittaa sitten jonkin kertamäärän for = first to lastlohkoa. Jokainen iteraatio suorittaa vertailuoperaation. Meidän täytyy siis laskea X, eli vertailujen kokonaismäärä. Emme yritä analysoida kuinka monta vertailua tehdään kussakin alikutsussa (kun aineistoa jaetaan osiin), vaan yritämme saada kokonaismäärän kaikista vertailuoperaatioista. Tämän saavuttamiseksi täytyy ymmärtää milloin algoritmi vertailee kahta arvoa ja milloin ei. Analyysin helpottamiseksi nimeämme taulun arvot z 1, z 2,..., z n Määrittelemme myäs että Z ij = {z i, z i+1,..., z j } ovat elementtien arvot välillä z i ja z j Voimmeko siis tietää missä tapauksissa algoritmi vertailee arvoja z i ja z j? Vastauksen läytämiseksi voimme todeta, että kutakin paria arvoja vertaillaan vain kerran. Tämä siksi, että arvoja vertaillaan vain sarana-alkioon, eikä samaa sarana-alkiota enää käytetä muissa partition-kutsuissa Määrittelemme: X ij = I{z i verrataan z j }. X ij saa arvon 1 kun vertailu tehdään ja arvon 0 kun vertailua ei tehdä Arvioimmme nyt vertailuja missä tahansa vaiheessa suoritusta, ei pelkästään kun aineistoa jaetaan osiin. Koska jokainen pari vertaillaan korkeintaan kerran, voimme luonnehtia vertailuoperaatioiden kokonaismäärää pikalajittelussa: X = n 1 n X ij i=1 j=i+1 Tämä lauseke saadaan partition-funktion ja sen for-silmukan suoritusmääristä. Ottamalla tästä odotusarvot molemmilta puolilta, pääsemme seuraavaan muotoon. n 1 E[X] = E[ n i=1 j=i+1 X ij ]

28 = = n 1 n i=1 j=i+1 n 1 n i=1 j=i+1 E[X ij ] P r{z i verrataan z j } (3.3.5) Nyt jää jäljelle termin P r{z i verrataan z j } laskeminen. Analyysimme olettaa, että sarana-alkio on valittu satunnaisesti ja riippumattomasti. On hyädyllistä miettiä mitä kahta termiä ei vertailla keskenään. Ajatellaan, että pikalajittelija lajittelee numerot 1-10 välillä (missä tahansa järjestyksessä) ja oletetaan että ensimmäinen sarana-alkio on numero 7. Tässä tapauksessa ensimmäinen aineiston jakaminen jakaa numerot kahteen eri joukkoon: {1,2,3,4,5,6} ja {8,9,10}. Nyt ensimmäistä jakajaa on verrattu kaikkiin muihin alkioihin, mutta mitään numeroa ensimmäisestä joukosta (kuten numeroa 2) ei koskaan verrata mihinkään numeroon toisesta joukosta (kuten numero 9). Yleisesti ottaen, kun jakaja x on valittu siten että z i < x < z j, tiedämme että z i ja z j alkioita ei vertailla enää jatkossa. Jos toisaalta z i valitaan saranaalkioksi ennen mitään muuta joukosta Z ij, niin z i :tä verrataan kaikkiin alkioihin Z ij :ssä (paitsi itseensä). Edellä kuvatussa esimerkissä arvoja 7 ja 9 verrataan toisiinsa koska 7 on ensimmäinen sarana-alkio Z 7,9 :stä. Numeroita 2 ja 9 ei koskaan vertailla keskenään koska ensimmäinen sarana-alkio Z 2,9 :stä on 7. Tästä voimme päätellä, että arvoja z i ja z j vertaillaan vain jos ensimmäiseksi jakajaksi Z ij :sta valitaan joko z i tai z j. Voimme nyt laskea todennäkäisyyden sille kuinka usein tämä tapahtuu. Ennen hetkeä jolloin alkio Z ij :stä on valittu jakajaksi, koko Z ij ovat samassa osiossa (partitiossa). Tässä tapauksessa mikä tahansa alkio Z ij :stä on yhtä todennäkäinen ensimmäiseksi sarana-alkioksi. Koska joukossa Z ij on j i + 1 alkiota, todennäkäisyys sille että joku alkio valitaan ensimmäiseksi saranaalkioksi on 1 per j i + 1. Joten, P r{z i verrataan z j } = P r{z i tai z j on ensimmainen valittu sarana-alkioz ij :stä} = P r{z i on ensimmäinen valittu sarana-alkio Z ij :stä} = = +P r{z j on ensimmäinen valittu sarana-alkio Z ij :stä} 1 j i j i (3.3.6) j i + 1 Yhdistämällä tämän aiemmin johtamaamme odotusarvon lausekkeeseen (3.3.5),

29 saamme E[X] = n 1 n i=1 j=i+1 2 j i + 1 Nyt hieman manipulointia: käytämme ensin sijoitusta k = j i: E[X] = < n 1 n i=1 j=i+1 n 1 n i=1 k=1 2 k n 1 2 j = n i i=1 k=1 2 k + 1 ja sitten harmonisen sarjan yhtälää jolloin pääsemme muotoon H n = E[X] = n k=1 n 1 i=1 1 k = ln n + O(1), O(lg n) = O(n lg n). Lemman 7.1 perusteella pikalajittelun suoritusajan ylärajaksi saadaan siis O(n + X) = O(n + n lg n) = O(n lg n). (3.3.7)