Kierros 2: Järjestämisalgoritmeja

Transkriptio

1 Kierros : Järjestämisalgoritmeja Tommi Junttila Aalto University School of Science Department of Computer Science CS-A4 Data Structures and Algorithms Autumn 7 Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

2 Materiaali Kirjassa Introduction to Algorithms, rd ed. (online via Aalto lib): Lisäysjärjestäminen: kappaleet. ja. Lomitusjärjestäminen: kappale. Pikajärjestäminen: luku 7 Asymptoottisia alarajoja: kappale 8. Laskemis- ja kantalukujärjestäminen: kappaleet Huom. Tällä kierroksella esitetään muutama yleisin järjestämisalgoritmi. Näiden lisäksi on olemassa useita muitakin; esimerkiksi tälle wikipedia-sivulle on koottu eri algoritmeja ja niiden välinen vertailu ajoajan, vaaditun työmuistin jne suhteen. Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

3 Osittain vastaavia tekstejä muualla: Luku kirjassa Algorithms, 4th ed. OpenDSA Joitain netistä löytyviä videoluentoja ja visualisoiteja: MIT 6.6 OCW video on insertion and merge sorts MIT 6.6 OCW video on counting sort, radix sort and lower bounds for sorting and searching MIT OCW video on Quicksort, Randomized Algorithms MIT 6.46J 5 OCW video on Randomized Select and Randomized Quicksort 5 Sorting Algorithms in 6 Minutes video visualizations of comparison based sorting algorithms Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

4 Motivointi Datan järjestäminen on hyvin yleinen tehtävä: opintosuoritusten järjestäminen opiskelijanumeron perusteella, serverin lokitietojen läpikäynti aikajärjestyksessä,... Järjestämistä käytetään myös alirutiinina monessa muussa algoritmissa puolitushaku duplikaattialkioiden poistaminen datasta verkkojen läpikäyntialgoritmeissa... Järjestämiseen on onneksi hyvin tehokkaita algoritmeja Järjestäminen on melkein yhtä nopeaa kuin pelkkä datan sisäänlukeminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

5 Asetelma Tarkastellaan sekvenssejä (yleensä taulukko) alkioita Alkioiden välillä on jokin järjestysrelaatio Jos alkiot ovat rakenteellisia olioita, sekvenssi sisältää Scalassa/Javassa viittauksia alkioihin. Tällöin kahden alkion paikan vaihtaminen (engl. swap) on tehokasta olion koosta riippumatta Array[String] Array[String] String String String String CS-A CS-A CS-A4 CS-A4 String String String String CS-A CS-A CS-A4 CS-A4 Rakenteellisten olioiden vertailu voi olla ei-vakioaikaista Tehokkuusmittareita järjestämisalgoritmeille: kokonaisajoaika, taulukon luku/kirjoitusoperaatioiden määrä, vaihtojen määrä, vertailujen määrä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

6 Rakenteellisia olioita voidaan järjestää myös tietyn kentän/alirakenteen eli avaimen (engl. key) mukaan Esimerkiksi alla työntekijät on järjestetty iän mukaan huomaa, että kaksi erillistä oliota voivat olla avaimen osalta yhtä suuria Array[Employee] Employee Employee Employee Employee name age salary name age salary name age salary name age salary String String String String St. Artup J. Smith P. Space B. Tree Tarkastellaan jatkossa selkeyden vuoksi yleensä vain kokonaislukutaulukkoja yleistäminen rakenteellisille olioille ja avaimille melko suoraviivaista Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 6 / 6

7 Paikallaan järjestäminen Määritelmä Järjestämisalgoritmi toimii paikallaan (engl. in place) jos sen ajon aikana kunakin ajanhetkenä vain jokin vakiomäärä alkioita on talletettu järjestettävän taulukon ulkopuolelle. Täten paikallaan järjestävät algoritmit eivät tarvitse suurta määrää ylimääräistä muistia tämä voi olla tärkeää kun järjestetään suuria datamääriä tai kun käytössä on vain suhteellisen pieni määrä muistia (sulautetut järjestelmät jne) Monet järjestämisalgoritmit, jotka eivät toimi paikallaan, käyttävät tyypillisesti aputaulukkoa, jonka koko on Θ(n), missä n on järjestettävän taulukon koko Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 7 / 6

8 Yllä oleva määritelmä on suhteellisen salliva eli se sallii esimerkiksi lineaarisen määrän indeksejä käytettävän rekursiivisessa kutsupinossa myös tiukempia versioita määrittelystä löytyy, ks. esimerkiksi tältä wikipedia-sivulta Yleisemmin voidaan puhua algoritmin vaatimasta työmuistin (tai lisämuistin) määrästä, eli siitä määrästä muistia, jonka algoritmi tarvitsee syötteen lisäksi. Tällä kierroksella oletetaan, että syötteen päälle pystyy kirjoittamaan, eli että tuloksena syntyvälle järjestetylle taulukolle ei välttämättä tarvitse varata uutta taulukkoa muistista Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 8 / 6

9 Vakaus (t. stabiilius) Määritelmä Järjestämisalgoritmi on vakaa (tai stabiili) (engl. stable) jos se pitää yhtäsuurten alkioiden keskinäisen järjestyksen ennallaan Scalan..8 metodit sorted ja sortwith toteuttavat stabiilin järjestämisalgoritmin. Myös sorted metodilla toteutettu sortby on stabiili. Esimerkiksi parit val l = L i s t ( ( c, ), ( b, ), ( e, ), ( a, ), ( b, ), ( a, ) ) voidaan järjestää sanakirjajärjestykseen (ensimmäinen kenttä merkitsevämpi) järjestämällä ensin toisen kentän mukaan scala> val tmp = l. sortby (. ) tmp = L i s t ( ( c, ), ( e, ), ( b, ), ( a, ), ( b, ), ( a, ) ) ja sitten (stabiililla algoritmilla) ensimmäisen mukaan scala> val r e s u l t = tmp. sortby (. ) r e s u l t = L i s t ( ( a, ), ( a, ), ( b, ), ( b, ), ( c, ), ( e, ) ) koska stabiili algoritmi ei vaihda esimerkiksi alkioiden (a,) ja (a,) keskinäistä järjestystä vaikka niiden ensimmäiset kentät ovat samat Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

10 C++-kielen (C++) algorithm-kirjasto sisältää eri funktiot stabiiliin järjestämiseen (stable sort-funktio) ja ei-välttämättä-stabiiliin järjestämiseen (sort-funktio) Jälkimmäisellä on hieman pienempi asymptoottinen pahimman tapauksen aikavaativuus silloin kun saatavilla ei ole tarpeeksi muistia aputaulukon varaamiseksi Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

11 Lisäysjärjestäminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

12 Erittäin yksinkertainen järjestämisalgoritmi, (engl. insertion sort) Tehokas vain hyvin pienille taulukoille Idea: Esimerkki Oletetaan, että taulukon i ensimmäistä alkiota ovat jo järjestyksessä; ensimmäisellä kierroksella i = Otetaan alkio i + ja etsitään mihin kohtaan j se kuuluisi jo järjestetyssä taulukon alkuosassa Siirretään alkioita j +,..., i yksi askel oikealle Lisätään alkio kohtaan j Nyt ensimmäiset i + alkiota ovat järjestyksessä Toistetaan, kunnes koko taulukko on järjestyksessä Taulukko alussa a = [a,a,a,a ] a Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

13 Erittäin yksinkertainen järjestämisalgoritmi, (engl. insertion sort) Tehokas vain hyvin pienille taulukoille Idea: Oletetaan, että taulukon i ensimmäistä alkiota ovat jo järjestyksessä; ensimmäisellä kierroksella i = Otetaan alkio i + ja etsitään mihin kohtaan j se kuuluisi jo järjestetyssä taulukon alkuosassa Siirretään alkioita j +,..., i yksi askel oikealle Lisätään alkio kohtaan j Nyt ensimmäiset i + alkiota ovat järjestyksessä Toistetaan, kunnes koko taulukko on järjestyksessä Esimerkki Ensimmäisen kierroksen alussa osataulukko [a ], sinisellä, on järjestyksessä Siirretään seuraavaa alkiota 7 vasemmalle kunnes se on oikeassa kohdassa Tässä siis siirretään kohtaan koska > 7 ja 7 kohtaan a Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

14 Erittäin yksinkertainen järjestämisalgoritmi, (engl. insertion sort) Tehokas vain hyvin pienille taulukoille Idea: Esimerkki Oletetaan, että taulukon i ensimmäistä alkiota ovat jo järjestyksessä; ensimmäisellä kierroksella i = Otetaan alkio i + ja etsitään mihin kohtaan j se kuuluisi jo järjestetyssä taulukon alkuosassa Siirretään alkioita j +,..., i yksi askel oikealle Lisätään alkio kohtaan j Nyt ensimmäiset i + alkiota ovat järjestyksessä Toistetaan, kunnes koko taulukko on järjestyksessä Toiden kierroksen alussa osataulukko [a,a ] on järjestyksessä Siirretään alkiota 5 vasemmalle kunnes se on oikeassa kohdassa Eli ei tehdä mitään koska 5 a Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

15 Erittäin yksinkertainen järjestämisalgoritmi, (engl. insertion sort) Tehokas vain hyvin pienille taulukoille Idea: Esimerkki Oletetaan, että taulukon i ensimmäistä alkiota ovat jo järjestyksessä; ensimmäisellä kierroksella i = Otetaan alkio i + ja etsitään mihin kohtaan j se kuuluisi jo järjestetyssä taulukon alkuosassa Siirretään alkioita j +,..., i yksi askel oikealle Lisätään alkio kohtaan j Nyt ensimmäiset i + alkiota ovat järjestyksessä Toistetaan, kunnes koko taulukko on järjestyksessä Nyt osataulukko [a,a,a ] on järjestyksessä Siirretään 8 vasemmalle kunnes se on oikeassa kohdassa Eli siirretään 5 kohtaan koska 5 > 8, kohtaan koska > 8 ja 8 kohtaan a Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

16 Erittäin yksinkertainen järjestämisalgoritmi, (engl. insertion sort) Tehokas vain hyvin pienille taulukoille Idea: Esimerkki Oletetaan, että taulukon i ensimmäistä alkiota ovat jo järjestyksessä; ensimmäisellä kierroksella i = Otetaan alkio i + ja etsitään mihin kohtaan j se kuuluisi jo järjestetyssä taulukon alkuosassa Siirretään alkioita j +,..., i yksi askel oikealle Lisätään alkio kohtaan j Nyt ensimmäiset i + alkiota ovat järjestyksessä Toistetaan, kunnes koko taulukko on järjestyksessä Koko taulukko on nyt järjestyksessä a Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

17 Pseudokoodina: Insertion-sort(A): for i until A.length: e A[i] // element to be moved j i while j > and A[j ] > e: A[j] A[j ] j j A[j] e Huom: toisin kuin kirjassa Introduction to Algorithms, rd ed. (online via Aalto lib), tässä taulukon indeksointi on alkaa indeksistä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

18 Toteutus kokonaislukutaulukoille Scala-kielellä: def i n s e r t i o n S o r t ( a : Array [ I n t ] ) : Unit = { var i = while ( i < a. length ) { val key = a ( i ) var j = i ; while ( j > && a ( j ) > key ) { a ( j ) = a ( j ) j = } a ( j ) = key i += } } Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

19 Algoritmin ominaisuuksia: Toimii paikallaan koska vain kulloinkin siirrettävä ja oikealle siirtyvä alkio on talletettu taulukon ulkopuoliseen muistiin Stabiili koska siirrettävä alkio siirretään aina viimeisimpään mahdolliseen kohtaan eli se ei hyppää samanarvoisten alkioiden ohi Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

20 Analyysiä Parhaan tapauksen ajoaika on Θ(n): taulukoilla, jotka ovat jo järjestyksessä, yhtään alkiota ei siirretä ja n alkion kohdalla tehdään yksi vertailu edeltävän alkion kanssa Pahimman tapauksen ajoaika on Θ(n ): Tarkastellaan taulukkoa, joka on alussa käänteisessä järjestyksessä toista alkiota siirretään askel kolmatta alkiota askelta... n:ttä alkiota siirretään n askelta Jokainen i askeleen siirto aiheuttaa i:n muun alkion siirtämisen oikealle kierros i suorittaa Θ(i) vertailua ja taulukon luku/kirjoitusoperaatiota T (n) = Θ(n) + T (n ) = Θ(n ) Samat parhaan ja pahimman tapauksen rajat koskevat myös tehtyjen vertailujen ja muistioperaatioiden määrää Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 6 / 6

21 Entäpä keskimääräinen ajoaika? Tarkastellaan taulukkoa, jossa n erisuurta satunnaisesti valittua alkiota Jokaisella kierroksella i, siirrettäessä alkiota a i oikealle paikalleen, osataulukko [a,...,a i ] sisältää keskimäärin i/ alkiota, jotka ovat pienempiä kuin a i keskimääräinen ajoaika on n i= i/ = Θ(n ) Näissä analyyseissa on siis oletettu, että kahden alkion vertailu sekä alkion luku taulukosta ja kirjoitus taulukkoon ovat vakioaikaisia operaatioita Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 7 / 6

22 Entäpä suorituskyky jossain sovelluksessa? Riippuu sovelluksen tuottamista syötetaulukoista Jos syötetaulukko on aina melkein järjestetty, lisäysjärjestäminen saatta toimia hyvinkin käytännössä Jos syötetaulukot ovat satunnaisesti järjestettyjä tai sellaisia, joissa monia alkioita täytyy siirtää pitkiä matkoja, kannattaa varmaan käyttää jotain muuta algoritmia Huom: lisäysjärjestämisalgoritmin koodi on hyvin kompakti eli siinä olevat vakiot ovat pieniä ja lisäksi peräkkäiset muistiviittaukset viittaavat yleensä lähellä olevaan kohtaan taulukossa lisäysjärjestäminen voi olla kilpailukykyinen (hyvin) pienille taulukoille Eräs mahdollinen optimointi: jos alkioiden vertailu onkin aikaavievempää, voitaisiin käyttää puolitushakua oikean siirtokohdan löytämiseksi Vertailujen lukumäärä pahimmassakin tapauksessa tippuu O(n log n) Mutta kokonaisajoaika säilyy Θ(n ) koska siirrot oikealle täytyy edelleen tehdä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 8 / 6

23 Yleiset tyypit Geneerinen versio lisäysjärjestämisestä mielivaltaisille vertailtaville alkiotyypeille: def i n s e r t i o n S o r t [ A <% Ordered [ A ] ] ( a : Array [ A ] ) = { var i = while ( i < a. length ) { val key = a ( i ) var j = i ; while ( j > && a ( j ) > key ) { a ( j ) = a ( j ) j = } a ( j ) = key i += } } Valitettavasti nykyisellä Scala-kääntäjällä yllä olevan yleistetyn koodin ajoaika on huomattavasti huonompi (ks seuraava kalvo) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

24 Lisäysjärjestäminen taulukoille, joissa satunnaisia kokonaislukuja Jotta voidaan käyttää Ordered-piirteen vertailuoperaatiota, jokainen taulukosta haettu kokonaisluku muutetaan olioksi ( boxing ), mikä aiheuttaa muistin varaamista ja myöhemmin vastaavasti roskankeruualgoritmin ajon Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

25 Lomitusjärjestäminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

26 Lomitusjärjestäminen on yksi käytetyimmistä järjestämisalgoritmeista Pahimman tapauksen ajoaika on O(n log n) Idea: Kahden jo järjestetyn taulukun yhdistäminen eli lomittaminen yhdeksi kummankin alkiot sisältäväksi järjestetyksi taulukoksi on helppoa Niinpä voidaan rekursiivisesti jakaa syötetaulukko pienemmiksi peräkkäisiksi osataulukoiksi kunnes ne on helppoa/triviaalia järjestää (esim. kunnes osataulukkossa on vain yksi alkio) ja sitten lomittaa saadut järjestetyt osataulukot pidemmiksi ja pidemmiksi kunnes koko taulukko on järjestetty Lomitusjärjestäminen on täten hajauta ja hallitse-tyyppinen algoritmi. Niissä on yleensä vaihetta: hajoita (engl. divide): ongelma hajoitetaan rekursiivisesti pienempiin osaongelmiin kunnes niistä tulee helppoja hallitse (engl. conquer): pienet osaongelmat ratkaistaan yhdistä (engl. combine): osaongelmien ratkaisut yhdistetään niin, että saadaan ratkaisu koko alkuperäiseen ongelmaan Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

27 Esimerkki Pienehkön taulukon järjestäminen lomitusjärjestämisellä, idea korkealla tasolla: original divide divide divide divide divide divide divide merge merge merge merge merge merge merge sorted Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

28 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Oletetaan, että ollaan jo järjestetty peräkkäiset osataulukot [start,mid-]=[,] ja [mid,end]=[,] original aux start mid end Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6 i dest j

29 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Verrataan alkioita 7 ja Alkio kopioidaan aputaulukkoon original aux start mid end Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6 i dest j

30 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Verrataan alkioita 7 ja 9 Alkio 7 kopioidaan aputaulukkoon original start mid end i j aux Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6 dest

31 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Verrataan alkioita ja 9 Alkio 9 kopioidaan aputaulukkoon original start mid end i j aux 7 Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6 dest

32 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Oikean osataulukon indeksi j on nyt osataulukon ulkopuolella Kopioidaan vasemman osataulukon loput alkiot aputaulukkoon original aux start mid end i 7 9 Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6 dest j

33 Lomitusoperaation toteuttaminen Hajoita-vaihe hajoittaa taulukon pienempiin peräkkäisiin osataulukoihin. Huom: näitä osataulukkoja ei tarvitse erikseen tallettaa vaan riittää pitää kirjaa niiden alku- ja loppuindekseistä. Lomitusvaiheessa kulloinkin yhdistettävät osataulukkoa ovat myös peräkkäisiä Yhdistetty osataulukko muodostetaan yleensä ylimääräiseen aputaulukkoon ja kopioidaan sieltä sitten takaisin alkuperäiseen Lomitusalgoritmi pitää yllä kahta indeksiä, i ja j, yhdistettävien osataulukkojen alusta alkaen ja jokaisella askeleella kopioi näiden viittaamista alkioista pienemmän aputaulukkoon ja lisää kyseistä indeksiä yhdellä Esimerkki: Kahden peräkkäisen järjestetyn osataulukon yhdistäminen Lopuksi järjestetty osataulukko kopioidaan aputaulukosta takaisin alkuperäiseen original aux start mid end Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

34 Lomitusalgoritmin toteutus Scala-kielellä: def merge ( a : Array [ I n t ], aux : Array [ I n t ], s t a r t : I n t, mid : I n t, end : I n t ) : Unit = { var ( i, j, dest ) = ( s t a r t, mid, s t a r t ) while ( i < mid && j <= end ) { / / Merge to aux, s m a l l e st f i r s t i f ( a ( i ) <= a ( j ) ) { aux ( dest ) = a ( i ) ; i += } else { aux ( dest ) = a ( j ) ; j += } dest += } while ( i < mid ) { aux ( dest ) = a ( i ) ; i += ; dest += } / / Copy r e s t while ( j <= end ) { aux ( dest ) = a ( j ) ; j += ; dest += } / / Copy r e s t dest = s t a r t / / Copy from aux back to a while ( dest <= end ) { a ( dest ) = aux ( dest ) ; dest += } } Algoritmin ajoaika on selvästikin Θ(k), missä k on kahden yhdistettävän osataulukon yhteenlaskettu koko Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

35 Lomitusoperaatiota alifunktiona käyttäen itse rekursiivinen lomitusjärjestämisalgoritmi on varsin yksinkertainen ja elegantti: def mergesort ( a : Array [ I n t ] ) : Unit = { i f ( a. length <= ) return / / A u x i l i a r y memory f o r doing merges val aux = new Array [ I n t ] ( a. length ) / / The r e c u r s i v e main a l g o r i t h m def mergesort ( s t a r t : I n t, end : I n t ) : Unit = { i f ( s t a r t >= end ) return / / One or zero elements, do nothing val l e f t E n d = s t a r t + ( end s t a r t ) / / / The midpoint mergesort ( s t a r t, l e f t E n d ) / / Sort the l e f t h a l f mergesort ( l e f t E n d +, end ) / / Sort the r i g h t h a l f merge ( a, aux, s t a r t, l e f t E n d +, end ) / / Merge the r e s u l t s } mergesort (, a. length ) } Algoritmi yllä jälleen kokonaislukutaulukoille, yleistäminen muille ja yleisille Ordered-piirteen toteuttaville tyypeille helppoa Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 6 / 6

36 Ajoaika-analyysiä Lomitusjärjestämisen ajoaika saadaan rekursioyhtälöstä T (n) = T ( n/ ) + T ( n/ ) + cn missä c on jälleen vakio Jos n on kahden potenssi, voidaan tehdä sijoitus n = k ja saadaan T ( k ) = T ( k ) + T ( k ) + c k = c k + T ( k ) Laajentamalla rekursiyhtälöä saadaan T ( k ) = c k + (c k + T ( k )) = c k + c k + 4(c k + T ( k )) =... = kc k Koska k = log n, T (n) = cn log n = Θ(n log n) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 7 / 6

37 Ajoaikaa voidaan visualisoida myös graafisesti seuraavasti esittämällä arvon T (n) laskenta puuna: Total time at level T (n) cn nc log n levels T (n/) c n T (n/) c n T (n/4) c n 4 T (n/4) c n 4 T (n/4) c n 4 T (n/4) c n 4 nc nc T () c T () c T () c T () c T () c T () c T () c T () c nc Total in all levels: nc log n Tässä on abstrahoitu pois pyöristämiset ja käytetty rekursioyhtälöä T () = c ja T (n) = T (n/) + T (n/) + cn Punaiset tekstit kuvaavat solmussa ja tasolla kokonaisuudessaan tehtävää työmäärää Rekursio pysähtyy kun n eli kun i log i n; täten puussa on log n tasoa Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 8 / 6

38 Kokeellista analyysiä Suuremmille taulukoille lomitusjärjestäminen on huomattavasti nopeampi ja paremmin skaalautuva kuin lisäysjärjestäminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

39 Satunnaisia kokonaislukuja sisältävillä taulukoilla lisäysjärjestäminen on kilpailukykyinen ainoastaan erittäin pienillä taulukoilla Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

40 Pienten osataulukoiden käsitteleminen Jokainen rekursiokutsu aiheuttaa funktion kutsumisen... ja täten ylimääräisen koodin ajamista ja muistinvarausta (kutsukehyksen varaaminen ja alustus) Käytetään edellisessä vertailussa huomattua lisäysjärjestyksen suhteellista nopeutta pienillä taulukoilla hyväksi ja tehdään lomitusjärjestysalgoritmin pieni muunnos, joka ei tee rekursiota yhden kokoisiin taulukoihin asti vaan kutsuu lisäysjärjestysalgoritmia osataulukoille, jotka ovat jotain tiettyä alarajaa pienempiä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

41 Muunnos Scala-kielellä: def mergesort ( a : Array [ I n t ], t h r e s h o l d : I n t = 64) : Unit = { i f ( a. length <= ) return val aux = new Array [ I n t ] ( a. length ) def mergesort ( s t a r t : I n t, end : I n t ) : Unit = { i f ( end s t a r t < t h r e s h o l d ) i n s e r t i o n s o r t ( a, s t a r t, end ) / / Changed else { val l e f t E n d = ( s t a r t + end ) / mergesort ( s t a r t, l e f t E n d ) mergesort ( leftend +, end ) merge ( a, aux, s t a r t, l e f t E n d +, end ) } } mergesort (, a. length ) } Yllä insertionsort(a, start, end) järjestää osataulukon a[start, end] lisäysjärjestysalgoritmilla Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

42 Tuloksena kohtuullinen vakiokertoiminen parannus ajoaikaan Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 / 6

43 Pikajärjestäminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

44 Toinen erittäin yleisesti käytetty järjestämismenetelmä (engl. quicksort) Kuten lomitusjärjestäminen, pikajärjestäminen on hajoita ja hallitse-tyyppinen algoritmi Helppo saada toimimaan paikallaan Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

45 Idea osataulukon A[lo, hi], missä lo hi, järjestämiseksi: Perustapaus: jos lo = hi, osataulukossa A[lo, hi] on vain yksi alkio ja se on täten järjestetty Hajoita: valitaan jokin jakoalkio (engl. pivot element) p osataulukosta A[lo, hi] ja ositetaan A[lo, hi] kolmeen osataulukkoon A[lo, q ], A[q, q] ja A[q +,hi] siten, että kaikki A[lo,q ] alkiot ovat pienempiä tai yhtä suuria kuin p, A[q,q] = [p] ja kaikki A[q +,hi] alkiot ovat yhtä suuria tai suurempia kuin p Tämän askeleen jälkeen p on oikealla paikallaan Hallitse: järjestetään osataulukot A[lo, q ] ja A[q +, hi] rekursiivisesti samalla lailla Pääfunktio Scala-kielellä: def q u i c k s o r t ( a : Array [ I n t ] ) : Unit = { def q u i c k s o r t ( l o : I n t, h i : I n t ) : Unit = { val q = p a r t i t i o n ( a, lo, h i ) i f ( l o < q ) q u i c k s o r t ( lo, q ) i f ( q + < h i ) q u i c k s o r t ( q +, h i ) } i f ( a. length >= ) q u i c k s o r t (, a. length ) } Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 6 / 6

46 Esimerkki: taulukon järjestäminen pikajärjestämisellä Edellisen kalvon Scala-toteutus Rekursiiviset kutsut ja ositusten tulokset suoritusjärjestyksessä Vihreä: osataulukko A[lo, hi] Punainen: jakoalkio Sininen: vasen osataulukko osituksen jälkeen Syaani: oikea osataulukko osituksen jälkeen quicksort(,7) after partition(,7) quicksort(,4) after partition(,4) quicksort(,4) after partition(,4) quicksort(,) after partition(,) quicksort(6,7) after partition(6,7) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 7 / 6

47 Sama puumuodossa esitettynä; toisin kuin lomitusjärjestämisessä, kutsupuu ei ole kovinkaan tasapainoinen input partition(,7) quicksort(,4) quicksort(6,7) partition(,4) partition(6,7) quicksort(,4) partition(,4) quicksort(,) 7 7 partition(,) 7 7 sorted Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 8 / 6

48 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Aloitustilanne Jakoalkio p (punaisella) on osataulukon lopussa lo hi i j >, lisätään j yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

49 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Syaanit alkiot kohdissa i,...,j ovat suurempia kuin jakoalkio 7, vaihdetaan alkiot kohdissa i ja j lo hi i j Lisätään i ja j yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

50 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Siniset alkiot kohdissa lo,...,i ovat korkeintaan yhtä suuria kuin p 9, vaihdetaan alkiot kohdissa i ja j lo hi i j Lisätään i ja j yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

51 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Siniset alkiot kohdissa lo,...,i ovat korkeintaan yhtä suuria kuin p, vaihdetaan alkiot kohdissa i ja j lo hi i j Lisätään i ja j yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

52 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Jatketaan kunnes j = r Siniset alkiot kohdissa lo,...,i ovat korkeintaan yhtä suuria kuin p Syaanit alkiot kohdissa i,...,j ovat suurempia kuin jakoalkio lo i hi j Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

53 Eräs osoitusalgoritmi kirjasta Introduction to Algorithms, rd ed. (online via Aalto lib): Syötteenä osataulukko A[lo, hi] Valitaan jokin jakoalkio p osataulukosta Vaihdetaan jakoalkio osataulukon viimeisen alkion kanssa Alkaen indeksistä lo, käytetään indeksimuuttujia i ja j s.e. osataulukon alkiot i:n vasemmalla puolella ovat korkeintaan p alkiot i,...,j ovat suurempia kuin p Siirretään indeksiä j oikealle ja jos siinä oleva alkio on korkeintaan p, vaihdetaan alkiot kohdissa i ja j sekä lisätään indeksiä i yhdellä Lopuksi vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Esimerkki Vaihdetaan viimeinen alkio (jakoalkio) ja alkio kohdassa i Lopetetaan lo i hi j Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 9 / 6

54 Toteutus Scala-kielellä: def swap ( a : Array [ I n t ], i : I n t, j : I n t ) : Unit = { val t = a ( i ) ; a ( i ) = a ( j ) ; a ( j ) = t } def p a r t i t i o n ( a : Array [ I n t ], l o : I n t, h i : I n t ) : I n t = { val p i v o t = a ( h i ) / / Very simple p i v o t s e l e c t i o n! var i = l o var j = l o while ( j < h i ) { i f ( a ( j ) <= p i v o t ) { i += ; swap ( a, i, j ) } j += } swap ( a, i +, h i ) i + } Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

55 Kokeellinen vertailu Lomitus- ja pikajärjestäminen taulukoilla, joissa satunnaisia kokonaislukuja: Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

56 Lisäksi vielä Scala-standardikirjaston Array[Int].sorted ja java.util.arrays.sort Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

57 Tässä käytetty funktion java.util.arrays.sort toteutus on eräs pikajärjestämisalgoritmin versio (ks. erään Java-toteutuksen lähdekoodi) Tämänhetkinen toteutus Array[Int].sorted-metodissa muuntaa kokonaislukutaulukon taulukoksi olioita ja kutsuu java.util.arrays.sort-funktiota oliotaulukoille; tämä taas toteuttaa TimSort -algoritmin (ks. erään Java-toteutuksen lähdekoodi) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 4 / 6

58 Ajoaikavaativuus Edellisten kokeellisten tulosten perusteella pikajärjestämisen ajoaika on varmaankin O(n log n)? Esitetyllä perusversiolla asia ei kuitenkaan ole näin vaan pahimman tapauksen ajoaika on Θ(n ) Ositusfunktion ajoaika on Θ(k), missä k on tarkasteltavan osataulukon koko Perusversiossa (Scala-koodi) valittiin aina osataulukon viimeinen alkio jakoalkioksi Neliöllinen pahimman tapauksen ajoaika realisoituu kun taulukko on jo alunperin järjestyksessä Jakoalkio ei liiku mihinkään ja vasemmanpuoleinen k alkion osataulukko on sama kuin ennen ositusta Rekursioyhtälöllä saadaan T (n) = Θ(n) + T (n ) = Θ(n ) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 44 / 6

59 Jakoalkion valinta Neliöllinen ajoaika jo järjestetyillä taulukoilla ei ole hyvä asia: käytännössä datamme voi usein olla jo (melkein) järjestyksessä Täten jakoalkion valinta on tärkeä asia O(n log n) saadaan kun valitaan jakoalkio niin, että syntyvät vasen ja oikea osataulukko ovat mahdollisimman samankokoisia Eli jakoalkioksi kannattaisi valita osataulukon mediaani Periaatteessa mediaani voidaan laskea lineaarisessa ajassa (ks. luku 9. kirjassa Introduction to Algorithms, rd ed. (online via Aalto lib)) mutta tähän liittyvät vakiot ovat melko suuria Käytännöllisempi approksimaatio on ottaa jakoalkioksi osataulukon satunnaisesti valitun alkion mediaani Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 45 / 6

60 Toinen yleinen ja helppo strategia on valita jakoalkio satunnaisesti tarkasteltavasta osataulukosta Taulukoille, joissa on n erisuuruista alkiota, pikalajittelun odotettu ajoaika on O(n log n) kun valitaan satunnainen jakoalkio (kappale 7.4 kirjassa Introduction to Algorithms, rd ed. (online via Aalto lib)) Vastaavaa tapahtui kokeellisissa tuloksissa aiemmin: niissä ei valittu satunnaista jakoalkiota mutta alkiot olivat satunnaisia ja siksi tilanne oli käytännössä sama ja ajoaika skaalautui kuten O(n log n) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 46 / 6

61 Yhtäsuuret alkiot Toinen ongelma pikajärjestämisalgoritmin perusversiolle muodostuu yhtäsuurista alkioista Tarkastellaan taulukkoa, jossa on n alkiota ja kaikki alkiot ovat samoja Riippumatta jakoalkion valinnasta, k-alkioisen osataulukon ositus tuottaa jakoalkion sekä yhden uuden alitaulukon, jonka koko on k Tällöin kokonaisajoaika on taas Θ(n ) Tämä ongelma voidaan ratkaista paremmalla ositusalgoritmilla, joka tuottaa uutta osataulukkoa: ensimmäisen alkiot ovat pienempiä kuin jakoalkio, toisen, sisältäen jakoalkion, ovat yhtä suuria ja kolmannen ovat suurempia yhtäsuuria alkiota sisältävä osataulukko on nyt järjestetty eikä sitä tarvitse enää käsitellä jatkossa toteutus ohjelmointitehtävässä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 47 / 6

62 Asymptoottisia alarajoja Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 48 / 6

63 Kuinka kaukana optimaalisesta esimerkiksi lomitusjärjestäminen on? Jotta tähän voidaan vastata, täytyy määrittää käytetty laskennan malli Oletataan normaali random access machine -malli, missä muistiosoitteisiin voidaan viitata vakioajassa ja missä muistiosoitteisiin ja rekistereihin mahtuu tietty kiinteä määrä bittejä (, 64 tms) Yksittäinen laskennan askel voi käsitellä vain jotain vakiomäärää bittejä Oletetaan lisäksi vain vertailuja -rajoitus, missä kahta alkiota voidaan vertailla operaatioilla =, <,, > ja mutta alkioista ei voida käyttää muuta tietoa, kuten esimerkiksi niiden bittitason koodausta Esimerkiksi järjestämisalgoritmitoteutukset, jotka käyttävät alkioiden vertailuun vain Scala-kielen Ordered-piirrettä, kuuluvat tähän luokkaan Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 49 / 6

64 Tällaisessa vain vertailuja -mallissa voidaan todistaa asymptoottiset alarajat sille, kuinka monta vertailua mikä tahansa algoritmi joutuu pahimmassa tapauksessa suorittamaan Alkion hakeminen järjestetystä taulukosta vaatii Ω(log n) vertailua pahimmassa tapauksessa Täten puolitushakualgoritmi on, asymptoottisessa mielessä, optimaalinen n-alkioisen taulukon järjestäminen vaatii Ω(n log n) vertailua pahimassa tapauksessa Täten lomitusjärjestäminen on asymptoottisessa mielessä optimaalinen Todistukset: kappale 8. kirjassa Introduction to Algorithms, rd ed. (online via Aalto lib) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

65 Laskemis- ja kantalukujärjestäminen Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

66 Useille alkiotyypeille voidaan tehdä järjestämisalgoritmeja, jotka eivät pohjaudu alkioiden suoraan vertailuun Toisin sanoen voidaan käyttää alkioiden ominaisuuksia hyväksi ja saada aikaan nopeampia järjestämisalgoritmeja Seuraavassa tarkastellaan laskemisjärjestämistä (engl. counting sort), jota voidaan käyttää pienille kokonaisluvuille kuvautuville alkiojoukoille, sekä kantalukujärjestämistä, joka käyttää hyväkseen alkioiden binääri-, merkkijono-, tms esitystä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

67 Laskemisjärjestäminen Oletetaan, että esiintyvät alkiot ovat lukuja {,..., k } jollekin kohtuullisen pienelle arvolle k (tai helposti kuvattavissa tälle joukolle) Esimerkiksi jos tahdotaan järjestää taulukollinen tavuja, niin k = 56 Laskemisjärjestämisen ideana on ensin laskea jokaisen alkion esiintymismäärä taulukossa ja sitten käyttää esiintymismäärien kumulatiivista määrää siirrettäessä jokainen alkio yksi kerrallaan oikealle paikalle Käyttää lisämuistia määrän Θ(n + k) eli ei toimi paikallaan: Θ(k) tavua taulukolle, johon esiintymismäärät lasketaan Θ(n) tavua tulostaulukolle Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 5 / 6

68 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += 4 7 original count result 4 5 Kohta Varataan apu- ja tulostaulukot Alustetaan aputaulukko count arvoilla Vie ajan Θ(k) Tässä k = Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

69 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += Kohta original result count Lasketaan n askeleella jokaiseen alkioon count[j] kuinka monta kertaa alkio j esiintyy syötetaulukossa Vie ajan Θ(n) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

70 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += Kohta original result count index Jokaiselle arvolle j lasketaan luku index[j] = j l= count[l], joka kertoo ensimmäisen arvon j esiintymiskohdan järjestetyssä tulostaulukossa Huom: pseudokoodissa tämä lasketaan taulukkoon count tilan säästämiseksi Vie ajan Θ(k) Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 /

71 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += 4 7 original result count index Kohta 4, ensimmäinen iteraatio Kopioidaan alkio e syötetaulukon kohdasta tulostaulukon result kohtaan index[e ] Lisätään arvoa index[e ] yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

72 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += original 6 result Kohta 4, toinen iteraatio count index Kopioidaan alkio e syötetaulukon kohdasta tulostaulukon result kohtaan index[e ] Lisätään arvoa index[e ] yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

73 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += original 6 result Kohta 4, kolmas iteraatio count index Kopioidaan alkio e syötetaulukon kohdasta tulostaulukon result kohtaan index[e ] Lisätään arvoa index[e ] yhdellä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

74 Esimerkki: Oktaalijärjestelmän numeroita sisältävän taulukon järjestäminen counting-sort(a): // : Allocate and init arrays count int-array of length k result int-array of length A.length for v in until k: count[v] // : Count occurrences for i in until A.length: count[a[i]] += // : Cumulative occurrences cumu for v in until k: current count[v] count[v] cumu cumu += current // 4: Make the result for i in until A.length: result[count[a[i]]] A[i] count[a[i]] += 4 4 Kohta 4 original result count index Jatketaan, kunnes ollaan taulukon lopussa Kopioidaan tulostaulukko result takaisin alkuperäiseen jos tahdotaan Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 54 / 6

75 Laskemisjärjestämisen ominaisuuksia: Vakaa Tarvitsee lisämuistia määrän Θ(k + n) Toimii ajassa Θ(k + n) Erittäin hyvä algoritmi jos k on pieni ja n k Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 55 / 6

76 Eniten merkitsevä numero ensin -kantalukujärjestäminen (engl. most-significant-digit-first radix sorting, MSD radix sorting) Oletetaan, että järjestettävät alkiot ovat sekvenssejä numeroita (engl. digit) joukosta,..., k ja tahdotaan järjestää ne sanakirjajärjestykseen Esimerkiksi -bittiset kokonaisluvut ovat sekvenssejä, jotka koostuvat 4 kpl 8-bittisiä tavuja (numeroita välillä 55) ASCII-merkkijonot ovat sekvenssejä ASCII-merkkejä (numeroita välillä 7) Eniten merkitsevä numero ensin -kantalukujärjestäminen järjestää alkiot ensin ensimmäisen numeron mukaan käyttäen laskemisjärjestämistä ja sen jälkeen rekursiivisesti järjestää kunkin osataulukon, joka alkaa samalla numerolla, samalla tavalla mutta jättäen huomiotta eniten merkitsevän numeron Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 56 / 6

77 Ominaisuuksia: Vakaa Tarvitsee määrän Θ(k + n) lisämuistia Toimii ajassa O((k + n)d), missä d on tarkasteltavien alkioiden numeroesityksen maksimipituus Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 57 / 6

78 Vähiten merkitsevä numero ensin -kantalukujärjestäminen (engl. least-significant-digit-first radix sorting, LSD radix sorting) Oletetaan jälleen, että alkiot ovat sekvenssejä numeroita joukosta {,..., k } ja ne tahdotaan järjestää leksikograafiseen järjestykseen Nyt oletetaan lisäksi, että kaikki alkiot ovat saman mittaisia koostuen d numerosta Alkiot voisivat siis olla esimerkiksi -bittisiä kokonaislukuja, jotka koostuvat 4 kpl 8-bittisiä tavuja tai samanpituisia ASCII-merkkijonoja kuten vaikkapa suomalaisia sosiaaliturvatunnuksia Vähiten merkitsevä numero ensin -kantalukujärjestäminen järjestää ensin alkiot viimeisimmän (vähiten merkitsevä) numeron mukaan käyttäen vakaata laskemisjärjestämistä ja sen jälkeen iteratiivisesti järjestää alkiot samalla lailla vakaalla laskemisjärjestämisellä toiseksi vähiten merkitsevän numeron mukaan jne Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 58 / 6

79 Ominaisuuksia: Esimerkki vakaa tarvitsee lisätilaa määrän Θ(k + n) toimii ajassa O((k + n)d) 6-bittisten etumerkittömien lukujen järjestäminen vähiten merkitsevä numero ensin -kantalukujärjestämisellä 4-bittiä kerrallaan f a8 e f6 e a8 a8 f f f6 f f stable sort with the last digit as the key 4 e 5 6 stable sort with the second last digit as the key stable sort with the third last digit as the key a8 6 e stable sort with the fourth last digit as the key 4 fff fff 7 7 f6 7 f 7 e a8 8 f fff 9 fff 9 fff 9 4 Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 59 / 6

80 Toteutus ja kokeellinen tarkastelu Ohjelmointitehtävänä Tommi Junttila (Aalto University) Kierros CS-A4 / Autumn 7 6 / 6