1. (a) Seuraava algoritmi tutkii, onko jokin luku taulukossa monta kertaa:

Transkriptio

1 Tietorakenteet, laskuharjoitus 10, ratkaisuja 1. (a) Seuraava algoritmi tutkii, onko jokin luku taulukossa monta kertaa: SamaLuku(T ) 2 for i = 1 to T.length 1 3 if T [i] == T [i + 1] 4 return True 5 return False Algoritmi järjestää ensin taulukon, minkä jälkeen mahdolliset toistuvat luvut ovat peräkkäin. Algoritmin aikavaativuus on O(n log n), koska taulukon järjestäminen on algoritmin työläin vaihe. (b) Seuraava algoritmi etsii taulukon useimmiten esiintyvän luvun: YleisinLuku(T ) 2 yluku = luku = T [1] 3 ymaara = maara = 1 4 for i = 2 to T.length 5 if T [i] == luku 6 maara = maara else 8 luku = T [i] 9 maara = 1 10 if maara > ymaara 11 yluku = luku 12 ymaara = maara 13 return yluku Algoritmi järjestää ensin taulukon, minkä jälkeen luvut ovat ryhmissä niiden suuruuden mukaan. Algoritmin aikavaativuus on O(n log n), koska taulukon järjestäminen on algoritmin työläin vaihe. (c) Seuraava algoritmi etsii taulukosta luvut, joiden ero on pienin: PieninEro(T ) 2 pienin = T [2] T [1] 3 for i = 2 to T.length 1 4 if T [i + 1] T [i] < pienin 5 pienin = T [i + 1] T [i] 6 return pienin 1

2 Algoritmi järjestää taulukon, minkä jälkeen luvut, joiden ero on pienin, ovat peräkkäin. Algoritmin aikavaativuus on O(n log n), koska taulukon järjestäminen on algoritmin työläin vaihe. 2. Seuraava algoritmi tutkii, onko kahden taulukon luvun summa k: KahdenSumma(T, k) 2 alku = 1 3 loppu = T.length 4 while alku < loppu 5 if T [alku] + T [loppu] == k 6 return True 7 if T [alku] + T [loppu] < k 8 alku = alku else 10 loppu = loppu 1 11 return False Algoritmi järjestää ensin taulukon ja yrittää sitten muodostaa summaa k. Algoritmi käy taulukon lukujen pareja läpi alusta ja lopusta kahden muuttujan avulla. Joka vaiheessa jos lukujen summa on liian pieni, algoritmi siirtää ensimmäistä kohtaa alku oikealle, ja jos lukujen summa on liian suuri, algoritmi siirtää toista kohtaa loppu vasemmalle. Algoritmin aikavaativuus on O(n log n), koska taulukon järjestäminen on algoritmin työläin vaihe. Seuraava algoritmi tutkii, onko kolmen taulukon luvun summa k: KolmenSumma(T, k) 2 for pohja = 1 to T.length 2 3 alku = pohja loppu = T.length 5 while alku < loppu 6 if T [pohja] + T [alku] + T [loppu] == k 7 return True 8 if T [pohja] + T [alku] + T [loppu] < k 9 alku = alku else 11 loppu = loppu 1 12 return False Algoritmi valitsee muuttujaan pohja ensimmäisen summaan kuuluvan luvun. Tämän jälkeen algoritmin toiminta vastaa kahden luvun summan hakua jäl- 2

3 jellä olevasta taulukon osasta. Nyt algoritmin työläin vaihe on sen loppuosa: muuttuja pohja saa O(n) eri arvoa ja kahden muun luvun etsiminen vie aikaa O(n), joten aikaa kuluu yhteensä O(n 2 ). Seuraava algoritmi tutkii, onko neljän taulukon luvun summa k: NeljanSumma(T, k) 2 for i = 1 to T.length 3 for j = i + 1 to T.length 4 lisää kolmikko (T [i] + T [j], i, j) taulukkoon T 5 järjestä taulukko T / kolmikoiden ensimmäisen eroavan luvun mukaan 6 alku = 1 7 loppu = T.length 8 while alku < loppu 9 if T [alku][1] + T [loppu][1] == k 10 if T [alku][3] < T [loppu][2] 11 return True 12 else 13 alku = alku loppu = loppu 1 15 if T [alku][1] + T [loppu][1] < k 16 alku = alku else 18 loppu = loppu 1 19 return False Algoritmi muodostaa taulukon T, joka sisältää kaikki taulukon T erilliset lukuparit sekä niitä vastaavien lukujen indeksit. Tämän jälkeen algoritmi etsii lukuparien pareja, joiden summa on k. Algoritmi hyväksyy lukuparien parin vain, jos ensimmäisen parin toisen luvun indeksi tulee ennen toisen parin ensimmäisen luvun indeksiä. Taulukko T sisältää O(n 2 ) alkiota, joten sen järjestäminen vie aikaa O(n 2 log(n 2 )) eli O(n 2 log n). Seuraavassa esimerkissä taulukossa T on 5 lukua ja taulukossa T on 10 lukuparia. Jos k = 16, algoritmi löytää taulukon T luvut 2, 4, 4 ja 6, koska taulukossa T ovat lukuparit 6,1,3 ja 10,4,5 (summa ja T :n indeksit). T T 5,1,2 6,1,3 6,1,4 7,2,3 7,2,4 8,1,5 8,3,4 9,2,5 10,3,5 10,4,5 3

4 3. Tiedosto JVertailu.java sisältää Java-toteutukset seuraavista algoritmeista: lisäysjärjestäminen: toteutus kuten luentomateriaalissa kuplajärjestäminen: toteutus kuten luentomateriaalissa, paitsi että järjestäminen päättyy heti, kun sisemmässä silmukassa ei tule muutoksia kekojärjestäminen: toteutus kuten luentomateriaalissa lomitusjärjestäminen: toteutus kuten luentomateriaalissa pikajärjestäminen: toteutus kuten luentomateriaalissa, paitsi että jakoarvona on ensimmäisen ja viimeisen alkion keskiarvo Lisäksi mukana vertailussa on Javan valmis järjestämismetodi (Arrays.sort). Seuraavassa ovat algoritmien suoritusajat erikokoisilla taulukoilla mitattuna TKTL:n tietokoneluokassa. Jokaiseen testiin liittyy kolme tapausta: ensin taulukon luvut ovat valmiiksi nousevassa järjestyksessä, sitten laskevassa järjestyksessä ja lopuksi satunnaisessa järjestyksessä. taulukon koko: (10 4 ) lukua lisäysjärjestäminen kuplajärjestäminen kekojärjestäminen lomitusjärjestäminen pikajärjestäminen Javan järjestäminen taulukon koko: (10 5 ) lukua lisäysjärjestäminen kuplajärjestäminen kekojärjestäminen lomitusjärjestäminen pikajärjestäminen Javan järjestäminen taulukon koko: (10 6 ) lukua kekojärjestäminen lomitusjärjestäminen pikajärjestäminen Javan järjestäminen

5 taulukon koko: (10 7 ) lukua kekojärjestäminen lomitusjärjestäminen pikajärjestäminen Javan järjestäminen Lisäysjärjestäminen ja kuplajärjestäminen vievät aikaa O(n 2 ), kun taas muut toteutetut algoritmit vievät aikaa O(n log n). Tämä näkyy tuloksissa siinä, että kun lukujen määrä kymmenkertaistuu, lisäysjärjestämisen ja kuplajärjestämisen suoritusaika kasvaa satakertaiseksi, mutta muiden algoritmien suoritusaika kasvaa vain hieman yli kymmenkertaiseksi. Kaikki vertaillut algoritmit toimivat salamannopeasti, jos taulukossa on vähän lukuja (alle tuhat). Tämän jälkeen lisäysjärjestäminen ja kuplajärjestäminen alkavat hidastua selvästi, paitsi jos taulukon luvut ovat valmiiksi kasvavassa järjestyksessä, jolloin algoritmit ovat vertailun nopeimpia. Suurilla satunnaissyötteillä pikajärjestäminen on noin kaksi kertaa nopeampi kuin lomitusjärjestäminen, joka taas on noin kaksi kertaa nopeampi kuin kekojärjestäminen. Javan valmis järjestämismetodi on suunnilleen yhtä nopea kuin itse toteutettu pikajärjestäminen. 4. Seuraava algoritmi sekoittaa taulukon: Sekoitus(T ) 1 for i = T.length downto 2 2 s = Random(1, i) 3 vaihda T [s] ja T [i] Algoritmi käy taulukon läpi lopusta alkuun ja vaihtaa joka vaiheessa keskenään satunnaisen alkion taulukon alkuosasta sekä käsiteltävän alkion. Seuraavassa on esimerkki algoritmin suorituksesta, kun sekoitettava taulukko sisältää aluksi luvut järjestyksessä: lähtötilanne arvonta lopputulos Random(1, 5) = Random(1, 4) = Random(1, 3) = Random(1, 2) =

6 Algoritmi käy taulukon kerran läpi, joten sen aikavaativuus on O(n), ja vaatii vain vakiomäärän lisätilaa, joten sen tilavaativuus on O(1). Kaikki järjestykset ovat yhtä todennäköisiä, koska aluksi jokaisella alkiolla on yhtä suuri todennäköisyys päätyä taulukon viimeiseksi alkioksi, minkä jälkeen jäljelle jää yhtä alkiota pienempi taulukko, johon soveltuu sama päättely. 5. Seuraava algoritmi muodostaa verkon transpoosin: Transpoosi(G) 1 for jokaiselle solmulle u V 2 for jokaiselle solmulle v Adj[u] 3 lisää u listaan Adj T [v] 4 return Ajd T Algoritmi käy läpi kaikkien solmujen vieruslistat ja muodostaa uudet vieruslistat käänteisistä kaarista. Algoritmin aikavaativuus on O( V + E ), koska se käy läpi kerran kaikki solmut ja kaikki kaaret. 6. Tiedostossa Labyrintti.java on Javalla toteutettu labyrintin ratkaisija. Ideana on etsiä reitti ulos labyrintista leveyshaulla. Jos labyrinttia ajettelee verkkona, solmuja ovat labyrintin lattiaruudut ja kaaria ovat mahdollisuudet liikkua vierekkäisten lattiaruutujen välillä. Leveyshaku käy läpi labyrintin lattiaruutuja aloituskohdasta lähtien ja löytää lyhimmän reitin ulos. Esimerkissä reitin etsintä tapahtuu seuraavasti: ####.##.# ####.##.# ####.##.#...#...#...#...#...#...# #.#.###.# ==> #.#.###.# ==> #.#.###.# ==> #...X..# #...1X1.# #..21X12# ######### ######### ######### ####.##.# ####.##.# ####.##5#...#...#...#...4#...#..54# #.#3###3# ==> #.#3###3# ==> #5#3###3# #.321X12# #4321X12# #4321X12# ######### ######### ######### Yllä olevissa labyrinteissa on merkitty ruudut, joihin pääsee 1 5 askeleella. Ensimmäinen labyrintin reunalla oleva ruutu tulee vastaan 5 askeleen jälkeen, minkä jälkeen leveyshaun voi lopettaa. 6