9/18/02 1. Tietorakenteet ja algoritmit Y. Syksy Dipoli T

Transkriptio

1 T Tietorakenteet ja algoritmit Y Syksy Dipoli 9/18/02 1

2 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1. Kurssikuvaus 1.1 Esitiedot 1.2 Tavoitteet 1.3 Opetuksen järjestelyt 1.4 Oppimateriaali 1.5 Ilmoittautuminen 1.6 Suorittaminen 1.7 Palaute 1.8 Yhteystiedot 9/18/02 2

3 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.1 Esitiedot Kyky ymmärtää yksinkertaista lausekielistä ohjelmakoodia: muuttujat, sijoitus-, ehto- ja toistolauseet, lohkot, iteraatio, rekursio, jne. Kyky ymmärtää alkeistyypeillä toteutettuja yksinkertaisia rakenteita, joissa käytetään tallennusrakenteina taulukoita, tietueita ja tarvittaessa osoittimia Esimerkkiohjelmissa käytetään jotakin lausekieltä, kuten C:tä, Javaa, Pascalia tai jälkimmäistä muistuttavaa vapaampaa pseudokieltä Algoritmien täsmällinen implementointi tietyllä kielellä ei ole kurssin sisällön kannalta keskeistä Unix-koneiden sähköpostijärjestelmän käyttö, uutisryhmien ja WWW:n lukeminen 9/18/02 3

4 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.2 Tavoitteet Oppia tuntemaan tärkeimmät tietorakenteet ja niiden käsittelyssä käytettävät algoritmit Oppia valitsemaan esiin tulevissa ongelmissa järkevä ratkaisumenetelmä ja soveltamaan sitä käytäntöön Oppia algoritmianalyysin perusteet Keskeisiä aihepiirejä ovat lineaariset rakenteet, puurakenteet, verkot perustietorakenteet (jono, pino, lista) prioriteettijonot hakurakenteet lajittelu yksinkertaiset optimointiongelmat 9/18/02 4

5 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.2 Tavoitteet... Suunnittelutaito Kyky perustella valintansa Kirjallisen esittämisen taito Kyky opiskella itsenäisesti Ryhmätyötaidot 9/18/02 5

6 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.3 Opetusmuodot Intensiivitapaamiset: Harjoitukset, ryhmätyöt, luennot Itsenäinen opiskelu Perustehtävät ns. TRAKLA-tehtävät Tentti Sähköinen neuvonta 9/18/02 6

7 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.3 Opetusmuodot / Intensiivitapaamiset Päivämäärät: : kurssikuvaus, orientoituminen : I puolikurssin purku : II puolikurssin purku Johdatus lyhyesti kurssin keskeisiin asioihin ITSENÄISELLÄ OPISKELULLA ON SUURI MERKITYS Kysymykset, jotka nousseet esille itseopiskelun aikana Esimerkkejä, niiden analysointia (ryhmissä) ja uusien algoritmien suunnittelua Luentoharjoitukset, kotona ratkottavia lisätehtäviä 9/18/02 7

8 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.3 Opetusmuodot / Itseopiskelu Aikataulu: : I puolikurssi : II puolikurssi : kertaus : tentti Luentomoniste, kirjallisuutta, TRAKLA-tehtävät Materiaali ei seuraa mitään tiettyä oppikirjaa Osa asioista jää omien muistiinpanojen varaan. 9/18/02 8

9 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.3 Opetusmuodot / Perustehtävät Pakollinen osasuoritus Perustehtävissä tavoitteena on perusaineiston oppiminen Simulaatiotehtäviä ( ) 4 kierrosta - kaikkia voi tehdä nyt jo! määräajat: ke ke ke ke Perustehtävät vain osittain riittäviä, myös itsenäisesti tehtäviä harjoituksia ja lukemistoa tarvitaan 9/18/02 9

10 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.3 Opetusmuodot / Tentti Pakollinen osasuoritus Kokonaisuuden hahmottaminen ks /k2002/tenttivaatimukset.k2002.html Tenttipäivä: Mahdollisuus tenttiä myös päiväkoulun puolella ( , helmikuussa) 9/18/02 10

11 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.4 Oppimateriaali Oppikirja: Virallista oppikirjaa ei ole. Esim. seuraavia kirjoja voi käyttää: Mark Allen Weiss: Data Structures and Algorithm Analysis in C / Java / C++ Mark Allen Weiss: Data Structures and Problem Solving in Java T.H. Cormen, C.E. Leiserson, R.L. Rivest: Introduction to algorithms. R. Sedgewick: Algorithms in C Opetusmonisteet ovat tarpeelliset, koska niiden kautta jaetaan materiaalia, mikä puuttuu oppikirjasta 9/18/02 11

12 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.5 Ilmoittautuminen Kurssille ilmoittaudutaan kurssin kotisivulla olevien ohjeiden mukaisesti Perustehtäviä varten ilmoittautuminen (rekisteröityminen) TRAKLA-järjestelmään on pakollista Suunnittelutehtävän ryhmät muodostetaan myös Otuksessa Ilmoittautuminen viimeistään perjantaihin mennessä 9/18/02 12

13 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.6 Suorittaminen 1. Perustehtävät ja Tentti arvioidaan asteikolla Kurssin kokonaisarvosana määräytyy seuraavasti: as = min{1, P, T}*round( 0.5*P + 0.5*T ) 9/18/02 13

14 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.8 Palaute 1. Rakentava palaute kurssin järjestelyistä on tervetullutta koko kurssin ajan 2. Perustehtävien (TRAKLA) osalta erillinen WWWlomake (toimivuus, käytettävyys, jne.) 3. Kurssin lopuksi järjestetään lomakepohjainen palautekysely (WWW) 9/18/02 14

15 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1.9 Yhteystiedot Ma prof. Ari Korhonen Teknillinen korkeakoulu archie@cs.hut.fi Puh (työ) (mob) 9/18/02 15

16 Sisällys I PUOLIKURSSI 1 Johdanto 2 Kertau - lausekielinen ohjelmointi 3 Algoritmiteorian perusajatuksi - määritelmiä, terminologiaa 4 Lineaariset perustietorakenteet - taulukko, lista, pino, jono, pakka 5 Algoritmianalyysin perusteet - kertaluokkamerkinnät, rekursioyhtälöt 6 Puurakenteet - binääripuu, puiden läpikäyntialgoritmit 7 Prioriteettijonot - keko 8 Järjestäminen - lomitus(järjestäminen), quicksort, valikointi, kantalukujärj. II PUOLIKURSSI 9 Hakurakenteet - binäärinen hakupuu, tasapainotetut hakupuut, trierakenteet 10 Hajautus - hajautusfunktio, yhteentörmäyksien käsittelymekanismit 11 Verkot - verkon läpikäyntialgoritmit, pienin virityspuu, lyhin reitti 9/18/02 16

17 1. JOHDANTO 1.1 Määritelmiä 1.2 Tietorakenteen ja algoritmin valinta 1.3 Algoritmit ja tiedon määrä 1.4 Tietorakenteet ja toiminnot 1.5 Esimerkki: lineaarinen vs. eksponentiaalinen toteutus 1.6 Ensi kerraksi... 9/18/02 17

18 1.1 Määritelmiä Algoritmi: Epäformaalisti: täsmällinen menettelytapa, joka ratkaisee jonkin hyvin määritellyn laskennallisen ongelman. Määritelmä: Algoritmi on äärellinen jono yksikäsitteisiä, äärellisellä työllä suoritettavissa olevia käskyjä, jotka laskevat funktion ƒ: I Æ O I on syötejoukko O on tulosjoukko kaikilla i Œ I, algoritmi pysähtyy s.e., o = ƒ(i) Œ O Tietorakenne: Funktion ƒ tehokas laskenta edellyttää, että syötejoukko I on hyvin organisoitu Päteekö sama tulosjoukolle O? Voidaan kuvata tietotyyppeinä Alkeistyypit, perustietotyypit, abstraktit tietotyypit Määritelmä: Tietorakenne on joukko tietyn tyyppisiä muuttujia, joilla on jokin määrätty rakenne. Tietotyypin toteutus 9/18/02 18

19 1.2 Tietorakenteen ja algoritmin valinta Sama asia tai toiminto voidaan toteuttaa lukemattoman monella eri tavalla tietokoneohjelmana Eri toteutusten paremmuutta voidaan verrata monessa suhteessa, mm. : toimintojen nopeus (algoritmit) vaadittu muistitila (tietorakenteet) ohjelmakoodin laatu ja ylläpidettävyys toteutuksen avoimuus laajennuksille Tällä kurssilla keskitytään kahteen ensimmäiseen näkökulmaan ÄLÄ OPTIMOI KOODIA - VALITSE PAREMPI ALGORITMI 9/18/02 19

20 Usein valitsemalla sopiva tiedon esitysrakenne voidaan merkittävästi vaikuttaa jonkin algoritmin tehokkuuteen Esimerkki 1: Haku linkitetystä listasta tai haku tasapainotetusta binääripuusta Edellisessä hakuaika on suoraan suhteessa talletettujen alkioiden lukumäärään Jälkimmäisessä hakuaika on suhteessa talletettujen alkioiden lukumäärän logaritmiin N log 2 N /18/02 20

21 Esimerkki 2: Miten tallentaa maantieverkko? Seuraajalistana, eli luetellaan jokaiselle solmulle ne solmut, joihin kyseisestä solmusta pääsee Vierusmatriisina (2-ulotteisena taulukkona), jolloin jokaiselle solmuparille merkitään, onko niiden välillä yhteyttä (1) vai ei (0) Seuraajalista vaatii tilaa sen verran kuin yhteyksiä on olemassa Vierusmatriisi vaatii tilaa suhteessa solmujen lukumäärän neliöön riippumatta yhteyksien määrästä Vierusmatriisi voi olla tehokkaampi, jos verkko on tiheä 9/18/02 21

22 1.3 Algoritmit ja tiedon määrä Algoritmin nopeus riippuu tiedon määrästä (syötteen pituus) Esimerkki 3: Taulukon lajittelu Valintalajittelu on hyvin helppo ymmärtää ja toteuttaa Quicksort on paljon mutkikkaampi Valintalajittelun tehokkuus on suhteessa alkioiden lukumäärän N neliöön Quicksortin tehokkuus vastaavasti lukuun N log N N N*log 2 (N) N * * /18/02 22

23 Esimerkki 4: Alkioiden (N kpl) talletus listaan Jos kukin alkio talletetaan listan alkuun, eikä listaa pidetä järjestyksessä, alkioiden talletus käy lineaarisessa ajassa (yksittäisen alkion talletus vie vakioajan) Jos kukin alkio talletetaan listan loppuun ja paikka haetaan aina listan alusta lähtien, alkioiden talletus käy ajassa, joka on suhteessa listan pituuden neliöön Jos kukin alkio talletetaan listan loppuun ja samalla ylläpidetään osoitinta listan viimeiseen alkioon, alkioiden talletus käy taas lineaarisessa ajassa 9/18/02 23

24 1.4 Tietorakenteet ja toiminnot Tietorakenteen tehokkuus riippuu siihen kohdistuvista toiminnoista (oikea abstraktio, frekvenssit, jne.) Esimerkki 5: Haetaan tiettyä tietuetta suuresta määrästä tietueita Jos tiedot ovat staattisia, ne voidaan tallentaa taulukkoon suuruusjärjestyksessä ja hakea sieltä vaikka binääri- eli puolitushaulla Hakuaika on silloin suhteessa taulukon koon logaritmiin Jos lisätään uusia tietueita tai poistetaan vanhoja, taulukko pitää järjestää kokonaan uudelleen. Tässä vaiheessa aikaa kuluu lineaarisesti suhteessa taulukon kokoon. Jos tiedot talletetaan tasapainotettuun binääriseen hakupuuhun, tieto voidaan edelleen hakea logaritmisessa ajassa, mutta myös lisäykset ja poistot voidaan tehdä logaritmisessa ajassa 9/18/02 24

25 1.5 Esimerkki: lineaarinen vs. eksponentiaalinen toteutus Esimerkki 6: Fibonacci-luvut F(0) = F(1) = 1 F(i) = F(i-1) + F(i-2) Lineaarinen menetelmä, käytetään muuttujia x, y ja z ja pyöritetään niitä seuraavassa luupissa z = y + x; x = y; y = z suoritusaika verrannollinen N:ään 9/18/02 25

26 F1 F2 Exponentiaalinen menetelmä, sovelletaan suoraan määritelmää rekursiivisesti F6 F5 F4 Laskettaessa F6:n arvoa, lasketaan: F3 F4 F3 F3 F2 F2 F1 F2 F1 F2 F1 F0 F5 1 kerran F4 2 kertaa F3 3 kertaa F2 5 kertaa F1 8 kertaa F1 F1 F0 F1 F0 F1 F0 F0 Koska pätee, että F100 F 100, missä F 1.618, seuraa, että F100:n laskemiseen tarvitaan luokkaa operaatiota... 9/18/02 26

27 2. OHJELMOINNIN PERUSTEIDEN LYHYT KERTAUS 2.1 Yleistä 2.2 Taulukko 2.3 Linkitetyn listan (linked list) toteutus 2.4 Tapausesimerkki Polynomi 2.5 Rekursio 9/18/02 27

28 2.1 Yleistä Esitiedot: kyky ymmärtää yksinkertaista lausekielistä ohjelmakoodia sekä alkeistyypeillä toteutettuja yksinkertaisia rakenteita Erityisesti: lineaaristen tietorakenteiden toteutus Tietorakenne on lineaarinen, jos kaikki sen alkiot on ryhmitetty peräkkäin. Tällaista rakennetta voidaan käyttää esim. yksinkertaisena hakurakenteena, tilapäisenä tallennusrakenteena. 9/18/02 28

29 2.2 Taulukko Kuuluu yleisimpien ohjelmointikielten perusrakenteisiin Taulukon määrittely C-kielessä: < type > < name >[<number of elements>] esim. int numbers[10]; numbers[5] = 1; indeksointi alkaa nollasta (0 - N-1) Moniulotteiset taulukot Dynaaminen taulukko 9/18/02 29

30 2.3 Linkitetyn listan (linked list) toteutus Lista toteutetaan tyypillisesti osoitinmuuttujien ja dynaamisen muistinvarauksen avulla. Voidaan toteuttaa myös taulukon avulla Tyypillinen määrittely C-kielessä: struct node { int data; struct node * next; }; typedef struct node * List_t; List_t p, q, r; Esimerkkilista: p K2.1 9/18/02 30 q r

31 Eräs määrittelytapa Java-kielessä: class ListNode { private Object data; private ListNode next; } ListNode(Object element) { data = element; next = null; } Listnode p, q, r; 9/18/02 31

32 Alkion poistaminen käy helposti, kun on käsillä osoitin poistettavaa alkiota edeltävään alkioon: (C) (Java) r = q->next; r = q.next; q->next = r->next; q.next = r.next; free(r); p K2.2 q r Ensimmäisen alkion poistaminen on erikoistapaus: r = p; r = p; p = p->next; p = p.next; free(r); 9/18/02 32

33 Kuinka hoitaa myös ensimmäinen alkio samalla koodinpätkällä kuin muutkin? => Määritellään yksi ylimääräinen header- alkio, jonka tarkoitus on aloittaa lista p head K2.4 Samasta syystä (erikoistapausten välttäminen) toisinaan määritellään listan loppuun ylimääräinen alkio z, josta on viittaus itseensä (Sedgewick: Algorithms) p head z K2.5 9/18/02 33

34 class LinkedList { private ListNode header; private static ListNode z = new ListNode(null); LinkedList () { header = new ListNode(null); header.next = z; } } public AddFirst(Object element) { private ListNode temp = new Listnode(element); temp.next = header.next; header.next = temp; } 9/18/02 34

35 Useampi lista voi käyttää samaa z-alkiota Listan loppumisen tarkastaminen: if (q == q->next)...; TAI if (q == z)... Alkion lisääminen on helppoa, kun käsillä on osoitin siihen alkioon, jonka jälkeen uusi alkio sijoitetaan p r = malloc(sizeof(node)); r->data = 99; r->next = q->next; q->next = r; r q 99 9/18/02 35 K2.3

36 Esimerkkejä listan käsittelyfunktioiden toteuttamisesta: TULOSTA : void print_list(list_t head) { List_t temp; temp = head->next; if (temp == z) printf("list is empty\n"); else { while (temp!= z) { printf("%d ",temp->data); temp = temp->next; } printf("\n"); } } /* print_list */ 9/18/02 36

37 Esimerkkejä listan käsittelyfunktioiden toteuttamisesta: TULOSTA : Public void print_list(linkedlist head){ ListNode temp; } temp = head.next; if (temp == z) System.out.print("List is empty"); else { while (temp!= z) { System.out.print(temp.data+ ); temp = temp.next; } } 9/18/02 37

38 LISÄÄ ALKIO LISTAN ALKUUN : List_t insert(list_t head, int key) { List_t temp; temp = get_node(); temp->data = key; temp->next = head->next; head->next = temp; return (temp); } /* insert */ 9/18/02 38

39 HAE ALKIO : List_t search(list_t head, int key) { List_t temp; z->data = key; temp = head->next; while (temp->data!= key) temp = temp->next; return (temp); } /* search */ 9/18/02 39

40 POISTA ALKIO : Boolean delete(list_t head, int key){ List_t temp, previous; z->data = key; previous = head; temp = head->next; while (temp->data!= key) { temp = temp->next; previous = previous->next; } if (temp!= z) { previous->next = temp->next; free (temp); return (TRUE); } else return (FALSE); } /* delete */ 9/18/02 40

41 Lista voidaan toteuttaa myös taulukon avulla Tarvitaan 2 taulukkoa; data[0..n] arvot next[0..n] osoittimet data next 0 head 4 1 z 1 2 T 6 3 I 5 4 L 3 5 S 2 6 A 1 p h L I S T A z e a d 9/18/02 41 K2.7

42 Useat listat voivat käyttää samaa taulukkoa. Kaksisuuntainen linkitetty lista on nopeampi käsitellä, mutta vaatii enemmän muistitilaa. p E E S T A A S K2.8 struct node { char data; struct node *next, *previous; }; typedef struct node * Dlist_t; 9/18/02 42

43 2.4 Tapausesimerkki POLYNOMI Â A i X i i=0...n Jos polynomi on tiheä l. suurin osa kertoimista poikkeaa nollasta => Esitetään kertoimet taulukossa #define MAX 1000 struct polynomi { int kerroin[max+1]; int asteluku; }; typedef struct polynomi Polynomi; 9/18/02 43

44 Jos polynomi on harva => Esitetään kertoimet järjestettynä listana struct polynomi { int kerroin, eksponentti; struct polynomi * next; }; typedef struct polynomi * Polynomi; Ei rajaa polynomin asteluvulle! 9/18/02 44

45 Toteutetaan polynomeille operaatio: void A_kertaa_B_on_C(Polynomi a,b,c) { /* Toteutus riippuu valitusta tietorakenteesta */... } => käsitellään polynomia abstraktiona!!! Kutsuvan ohjelman ei tarvitse tietää miten kertoimet on talletettu, toteutustapaa voidaan vaihtaa tarpeen mukaan!! 9/18/02 45

46 2.5 REKURSIO Rekursiivinen ohjelma Kutsuu itseään Rekursiivinen funktio On määritelty itsensä avulla Esim. Fibonacci-luvut: X(i) = X(i-1) + X(i-2), X(0) = X(1) = 1 9/18/02 46

47 Rekursio ei voi jatkua loputtomiin Täytyy löytyä päätösehto jonka toteutuminen lopettaa rekursion Esim. Kertoma: Rekursio: N! = N (N-1)! Päätösehto: 0! = 1 9/18/02 47

48 Rekursion neljä kultaista sääntöä: 1. Perustapaukset (ratkaistavissa ilman rekursiota) 2. Edistyminen (liikutaan perustapausta kohti) 3. Oletus (kaikki rekursiiviset kutsut toimivat) 4. Vältä turhaa työtä (jokainen tapaus ratkaistaan vain kerran) 9/18/02 48

49 Esim. Kertoma rekursiivisena: int factorial(int n) { if (n==0) return 1; else return n*factorial(n-1); } Esim. Kertoma ei-rekursiivisena: int factorial(int n) { int i,fact; fact = 1; for (i=2; i<=n; i++) fact= fact*i; return fact; } 9/18/02 49

50 Esim. Fibonacci-luvut: int fibonacci(int n) { if (n<=1) return 1; else return fibonacci(n-1)+fibonacci(n-2); } F6 F5 F4 {Rikkoo neljättä sääntöä} F4 F3 F3 F2 Parempi toteuttaa eirekursiivisena F3 F2 F2 F1 F2 F1 F1 F0 F2 F1 F1 F0 F1 F0 F1 F0 F1 9/18/02 50 F0

51 Esim. Hanoin tornit: Siirrä renkaat toiseen tappiin yksi kerrallaan niin, että isompi rengas ei koskaan ole pienemmän päällä: Mistä Minne Vi a K2.17 9/18/02 51

52 void hanoi(int N, int mista, int minne, int via) { if (N==1) printf( Siirrä rengas tapista %d tappiin %d, kiitos\n, mista, minne); else { hanoi(n-1, mista, via, minne); printf( Siirrä rengas tapista %d tappiin %d, kiitos\n, mista, minne); } } hanoi(n-1, via, minne, mista); Mistä Minne Vi a 9/18/02 52 K2.17

53 Hajota ja hallitse menetelmä algoritmisuunnittelussa Tehdään kaksi rekursiivista kutsua, toinen datan yhteen puolikkaaseen ja toinen jäljelle jääneeseen osaa. Eräs hyvin keskeinen periaate algoritmisuunnittelussa. 9/18/02 53

54 3. ALGORITMITEORIAN PERUSAJATUKSIA 3.1 Algoritmit suhteessa tietorakenteisiin 3.2 Algoritmien vertailu 3.3 Algoritmien toteutus 3.4 Abstraktit tietotyypit 9/18/02 54

55 3.1 Algoritmit suhteessa tietorakenteisiin Useimmat algoritmit käsittelevät jotain tietorakennetta, eikä atomista dataa Käsiteltävä data on siten joukko data-alkioita, jotka muodostavat jonkin kokonaisuuden. Algoritmi käsittelee tätä kokonaisuutta eli tietorakennetta. Esimerkiksi: Lajitellaan tieto suuruusjärjestykseen Etsitään jotain yksittäistä tietoa suuresta tietojoukosta Tietojoukon yksittäisten alkioiden välillä voi olla yhteyksiä, jotka yksilöivät alkion suhteen muihin alkioihin (verkot) Data esittää jotain kokonaisuutta koordinaattiavaruudessa 9/18/02 55

56 Algoritmi Implementaatio: - method, function, procedure, pvm_spawn,...? Syöte I Tulos O Toimenpiteet, joilla annetulla laillisella syötteellä tulos O voidaan laskea Toimenpide? Laskettavissa äärellisellä määrällä resursseja Äärellinen kestoaika Pysähtyy, s.e. O = f(i) (laskenta päättyy, oikeellisuus) 9/18/02 56

57 Mitkä seuraavista ovat algoritmeja? 1) // eräs C-kielen pääohjelma main() { printf( Input two real numbers ); scanf( %f%f,&x, &y); if (x>y) { float temp; temp=x; x=y; y=temp; } ; printf( input a number ); scanf( %f,&z); if ( z>x && z<y? 1 : 0) printf( %f is between %f and %f\n,z,x,y); else printf( %f is not between %f and %f\n,z,x,y); } 2) // eräs Java metodi; A on luokkamuuttuja public void togglea() { A =!A; } 9/18/02 57

58 Mitkä seuraavista ovat algoritmeja? 3) // eräs C++ pääohjelma #include <fstream> int main() { using namespace std; int intvalue; float realvalue; ifstream indata; ofstream outdata; indata.open( input.dat ); outdata.open( output.dat ); indata >> intvalue; indata >> realvalue; outdata << The input values are << intvalue << and << realvalue << endl; return 0; } 9/18/02 58

59 3.1.2 Tietorakenteiden käsitteellinen luokittelu Luokitteluun on erilaisia lähestymistapoja: Mitkä seuraavista ovat tietorakenteita? Bitti Boolean Integer Taulukko Tuple Double Verkko 9/18/02 59

60 1) Atominen tieto vs. rakenteinen tieto Riippuu abstraktiotasosta 2) Staattinen vs. dynaaminen tietorakenne Mikä seuraavista on staattinen, mikä dynaaminen tietorakenne? Taulukko Tietue Dynaaminen taulukko Linkitetty lista Verkko Binääripuu Muistinvaraus kiinteä tai dynaaminen 9/18/02 60

61 Alkion saavutettavuus: Mitä eroa? Taulukko Tietue Linkitetty lista Binääripuu Verkko Alkion paikka voidaan laskea vakioajassa tai sitten ei. 9/18/02 61

62 Abstraktiotaso Mitä eroa? Binääripuu Jäsennyspuu 1 Binäärinen hakupuu * A D B G C Taulukko Hajautustaulukko Talletusrakenne vai semanttinen rakenne: Rakenne voi olla puhdas talletusrakenne tai abstrakti tietotyyppi, jolla on jokin semantiikka 9/18/02 62

63 3.2 Algoritmien vertailu Jos sama asia voidaan toteuttaa eri tavoin, täytyy jotenkin pystyä arvioimaan, mikä toteutus on kulloinkin hyvä Vertailukriteereitä on monia: Algoritmin askelmäärä suhteessa käsiteltävän tiedon määrään Pahin mahdollinen askelmäärä Keskimääräinen askelmäärä Tasattu askelmäärä Algoritmin kuluttama todellinen cpu-aika (usein ongelmallinen arvioitava) Algoritmin/tietorakenteen vaatima muistitila suhteessa käsiteltävän tiedon määrään => ALGORITMIANALYYSI Algoritmin toteutuksen monimutkaisuus (kannattaako optimointi?) 9/18/02 63

64 3.3 Algoritmien toteutus Ohjelman ylläpidettävyyden kannalta on ehdottomasti järkevää toteuttaa tärkeä algoritmi siten, että sen mahdollinen vaihtaminen tehokkaampaan vaikuttaa mahdollisimman vähän muuhun ohjelmaan fi ABSTRAKTIT TIETOTYYPIT (ADT, Abstract data type) Usein algoritmit esitetään pseudokielellä (á la Pascal) ja jätetään toteutuksen pienimmät yksityiskohdat avoimiksi fi Algoritmin perusajatusta on helpompi ymmärtää, kun ei tarvitse kiinnittää huomiota ohjelmointikielen syntaksiin fi Kuvaus on kieliriippumaton 9/18/02 64

65 3.4 Abstraktit tietotyypit Määritellään tietorakenteeseen kohdistuvat operaatioit Ei oteta kantaa, miten operaatiot toteutetaan Otetaan kantaa, mitä operaatiot tekevät (riittävä tarkkuustaso!) Mahdollistaa toteutuksen muuttamisen joustavasti Esimerkkejä: A) Joukko abstraktina tietotyyppinä Määritellään vaikkapa operaatiot: «- Leikkaus; Set cut(set A, Set B)» - Unioni; Set union(set A, Set B) ` - Komplementti; Set cmpl(set A, Set superset) - Koko (= alkioiden määrä); int size(set A) Œ - Kuuluu joukkoon?; boolean in(element E, Set A) 9/18/02 65

66 Operaatiot toteutetaan aliohjelmina Muualla ohjelmassa voidaan kutsua y.o. operaatioita tarvitsematta tietää, miten alkiot on talletettu (taulukko, lista, puu,...) B) Hakurakenne abstraktina tietotyyppinä Määritellään, että hakurakenne on kokoelma tietueita, jotka voidaan yksiselitteisesti tunnistaa niihin talletetun hakuavaimen arvon perusteella Määritellään esimerkiksi operaatiot Element Search(Key K) - Etsi tietue annetulla hakuavaimella Element Insert(Key K, Data D) - Lisää rakenteeseen tietue Element Delete(Key K) - Poista rakenteesta tietue Element Next(Element E) [Previous] - Etsi annettua tietuetta lähinnä seuraava [edellinen] tietue Element[] Print(Key From, Key To) - Etsi tietueet, joiden avainarvot ovat avainarvojen [From,To] välissä 9/18/02 66

67 C) Prioriteettijono abstraktina tietotyyppinä Määritellään, että rakenne on kokoelma alkioita, joihin jokaiseen liittyy alkion suhdetta muihin alkioihin kuvaava prioriteetti Määritellään esimerkiksi operaatiot Insert(Element E, int P) - Lisää alkio ja aseta sen prioriteetiksi P Element DeleteMax() - Poista ja palauta alkio, jonka prioriteettiarvo on suurin (tai deletemin - pienin) DecreaseKey(Element E, int delta) - pienennä (tai IncreaseKey - suurenna) alkion prioriteettiä deltalla D) Ohjelmointikielet ja abstraktit tietotyypit Esim. C-kielen standardityypit on toteutettu ADT:nä: int (16-32 bit) float,double (IEEE,..) char ( 8 bit) 9/18/02 67

68 Tiedostojen käsittely, FILE * Standardi-C ei sisällä mekanismia, jolla voitaisiin määritellä abstrakteja tyyppejä Ohjelmoija voi tosin noudattaa samaa periaatetta: Määritellään aliohjelmat, joilla käsitellään tietyntyyppisiä objekteja Ei käytetä tyypin rakennetta näiden aliohjelmien ulkopuolella Käsiteltävä objekti välitetään aliohjelmille muuttujaparametrina Käsittelyaliohjelmat kootaan yhteen paikkaan ja nimetään loogisesti fi VASTUU EHEYDEN NOUDATTAMISESTA JÄÄ OHJELMOIJALLE Oliokielissä abstraktit tietotyypit määritellään yleensä rajapintoina ja toteutetaan luokkina (Java, C++) 9/18/02 68

69 Tehtäviä Pohdi millaisia operaatioita tarvitaan abstraktien tietotyyppien taulukko ja linkitetty lista toteuttamiseksi Hahmottele toteutukset joillekin määrittelemistäsi operaatioista Vertaile käsitteitä rekursio ja iteraatio 9/18/02 69

70 4. LINEAARISET PERUSTIETORAKENTEET 4.1 Johdanto 4.2 Taulukko 4.3 Linkitetty lista (linked list) 4.4 Pino (stack) 4.5 Jono (queue) 4.6 Pakka (deque) 9/18/02 70

71 4.1 Johdanto Tietorakenne on lineaarinen, jos kaikki sen alkiot on ryhmitetty peräkkäin. Tällaista rakennetta voidaan käyttää esim. yksinkertaisena hakurakenteena, tilapäisenä tallennusrakenteena. 9/18/02 71

72 4.2 Taulukko Hyvin yksinkertainen lineaarinen rakenne. Perusrakenne valmiina useimmissa korkean tason ohjelmointikielissä. => Helppo ohjelmoida Alkiot indeksoidaan ensimmäisestä viimeiseen. Mihin tahansa alkioon voidaan heti viitata. Taulukon alkioiden väliin ei voi lisätä uutta alkiota eikä sieltä voi poistaa alkiota. => Rakenne on erittäin jäykkä, jos tällaisia toimintoja (päivityksiä) tarvitaan. 9/18/02 72

73 4.3 Linkitetty lista (linked list) Taulukkoa paljon joustavampi rakenne monessa tilanteessa. Lista koostuu yksittäisistä alkioista, joihin kuhunkin on talletettu dataa ja osoitin (referenssi) seuraavaan alkioon. Listan kokoa ei ole ennalta rajoitettu, vaan listaan voidaan lisätä ja siitä voidaan poistaa alkioita ajonaikaisesti. => Listan kokoa rajoittaa vain käytettävissä oleva muisti. Alkioita voi lisätä minne tahansa. Alkioita voi poistaa mistä tahansa. Alkioiden järjestystä voi vaihtaa. Listan alkiot voivat olla samaa tyyppiä tai lista voi olla geneerinen. 9/18/02 73

74 LINKITETYN LISTAN TÄRKEIN RAJOITUS: Alkioita voi käydä läpi vain yksitellen, ts. alkioihin ei voi viitata suoraan (vrt. taulukko) Linkitetyn listan tärkeimmät operaatiot ovat: TULOSTUS HAKU LISÄYS POISTO PÄIVITYS TYHJÄN LISTAN LUOMINEN N:NNEN ALKION PALAUTTAMINEN ONKO LISTA TYHJÄ? 9/18/02 74

75 Eri operaatioitten vaatima aika: TULOSTUS N HAKU N/2 (epäonnistunut: N) LISÄYS 1 POISTO N/2 Lista voidaan pitää järjestyksessä, jolloin (epäonnistunut) haku on nopeampi Tiedetään, ettei enää kannata etsiä, kun oikea kohta on jo ohitettu Lisäys on vastaavasti hitaampi (ei voidakaan lisätä aina listan alkuun) Listasta voidaan muodostaa rengas p /18/02 K2.6 75

76 4.4 Pino (stack) Pino on abstrakti tietotyyppi, jolle on määritelty seuraavat operaatiot: Push(x) - lisää pinon päälle alkion x Pop() - palauttaa ja poistaa pinon päällimmäisen alkion Toimii samaan tapaan kuin pöydällä oleva korttipakka Top() - palauttaa pinon päällimmäisen alkion (poistamatta sitä) IsEmpty() - palauttaa tiedon siitä, onko pino tyhjä 9/18/02 76

77 Jonokuri LIFO (Last In - First Out) Kaikki pino-operaatiot voidaan toteuttaa vakioajassa (ei riipu pinon koosta) Pino voidaan implementoida taulukon avulla tai linkitettynä listana Toteutus taulukkona: pino-osoitin, joka osoittaa päällimmäiseen alkioon isempty() (sp == apuna sp -1) 4 Taulukkototeutuksessa pinolle varattu tila voi loppua 9/18/ K2.13

78 Toteutus listana: top K2.14 push(): liitä uusi alkio listan alkuun pop(): poista ja palauta alkio listan alusta isempty(): tosi, jos lista on tyhjä (top == null) 9/18/02 78

79 Pinon sovelluksia Ohjelmointikielessä lausesulkujen tarkastus: kullekin alkusululle löytyy oikeantyyppinen loppusulku kielessä voi esiintyä useita eri sulkutyyppejä, esim. C- kielessä (,); [,]; {,} sulkuvirheet voivat usein sotkea kääntäjän toiminnan pahoin Ajonaikainen pino (aliohjelmakutsut): Kutsuvan ohjelman tila (=rekisterit) ja kutsun paikka (=program counter) pinoon Aliohjelmasta palattaessa voidaan palauttaa alkuperäinen tila Syötevirran kääntäminen päinvastaiseen järjestykseen 9/18/02 79

80 Yksinkertainen lausesulkujen tarkastusperiaate luetaan syötettä merkki kerrallaan tutkitaan vain sulkumerkkejä alkusulku asetetaan pinoon (push) kohdattaessa loppusulku otetaan pinosta (pop) päällimmäinen sulku jos pino on tyhjä (isempty) tai sulku on väärän tyyppinen fi virhe algoritmin päättyessä pinon tulee olla tyhjä 9/18/02 80

81 Lausekkeen arvon laskeminen Miten evaluoida lausekkeen arvo? Infix-notaatio: 5 * ( ( ) * 4 * ) Miten tallentaa välitulokset? Mikä on toimintajärjestys, kun lauseke luetaan ohjelmalle merkki merkiltä? 9/18/02 81

82 Periaate: 1) Muunnetaan lauseke pinon avulla postfix-muotoon: * 6 * 7 + * 2) Evaluoidaan postfix-lauseke pinon avulla 9/18/02 82

83 INFIX-POSTFIX-muunnos pinon avulla Luetaan Infix-lauseketta merkki kerrallaan operandit [0-9]* fi tulostetaan suoraan ( fi asetetaan pinoon (PUSH) operaattorit *,+ fi otetaan pinosta (POP) ja tulostetaan operaattoreita, joilla on sama tai suurempi prioriteetti, sen jälkeen asetetaan viimeksi luettu operaattori pinoon. Sulkumerkkiä ( ei kuitenkaan lueta ) fi otetaan pinosta ja tulostetaan operaattoreita, kunnes löytyy alkusulku, joka myös luetaan, mutta ei tulosteta Kun syöte loppuu, otetaan pinosta ja tulostetaan loput operaattorit 9/18/02 83

84 Esim. Muunnetaan lauseke 5*((9+8)*4*6+7) muotoon 598+4*6*7+* Syöte Pino Tuloste 5 5 * * ( *( ( *(( *((+ 8 8 ) *( + * *(* 4 4 * *(* * *(+ * 7 7 ) * + tyhjä * 9/18/02 84

85 POSTFIX-lausekkeen arvo voidaan laskea pinon avulla Esim. lauseke 598+4*6*7+* Input Pino * * * 2075 empty 9/18/02 85

86 4.5 JONO (queue) Jono on abstrakti tietotyyppi, jolle on määritelty seuraavat operaatiot: Put(x) tai Enqueue(x) - lisää jonon loppuun alkion x Get() tai Dequeue() - palauttaa (ja poistaa) jonon ensimmäisen alkion First() - palauttaa jonon ensimmäisen alkion IsEmpty() - kertoo, onko jono tyhjä Jonokuri FIFO (First In First Out) Jono voidaan toteuttaa eri tavoin (taulukon avulla tai linkitettynä listana). Toteutetaan usein sirkulaarisena taulukkona (indeksit lasketaan modulo N). 9/18/02 86

87 Jonon toteutus sirkulaarisena taulukkona Jono[0.. MAX-1] l ast fi r st MAX put get first osoittaa jonon alkuun last osoittaa 1. vapaaseen paikkaan jonossa yksi tyhjä paikka, jota ei käytetä 9/18/02 87

88 Put(x): Jono[last] = x; last = (last+1) % MAX; if (last == first) error; {Jono ei voi olla tyhjä!} Get(): tmp = Jono[first]; first = (first+1) % MAX; return tmp; First(): return Jono[first]; IsEmpty(): (last == first); 9/18/02 88

89 Jonon toteutus listana struct node { datatype data; struct node *next; }; typedef struct node * Queue; fi r st l ast K2.16 9/18/02 89

90 Put(x): temp = (Queue) malloc(sizeof(struct node)); temp->data = x; temp->next = NULL; last->next = temp; last = temp; Get(): temp = first; first = first->next; return (temp); First(): return(first); IsEmpty(): return (first == NULL); 9/18/02 90

91 Jonon sovelluksia Esim. Printterijono Puskuri tiedon välivarasto tietoa tulee tietoa lähtee tiedon järjestys säilyy Esim. tulostettava tiedosto menee puskurin kautta Diskreetti simulointi Esim. liikenne, tietoliikenne, palvelut Graafialgoritmit 9/18/02 91

92 4.6 PAKKA (deque) = Jonon ja pinon yhdistelmä Alkioita voidaan asettaa rakenteen molempiin päihin, ja myös ottaa pois Vrt. korttipakka kädessä 9/18/02 92

93 Tehtäviä Määrittele abstrakti tietotyyppi pakka Kuinka toteuttaisit määrittelemäsi abstraktion? Arvioi linkitetylle listalle määriteltyjen operaatioiden suoritusaikaa suhteessa listan pituuteen Vertaa linkitettyä listaa taulukkoon em. operaatioiden suhteen 9/18/02 93

94 5. ALGORITMIANALYYSI 5.1 Johdanto 5.2 Tavoitteet 5.3 Algoritmien luokittelu 5.4 Kertaluokkamerkinnät (Big Oh Notation) 5.5 Algoritmin toteutus 5.6 Kertaluokkamerkinnöillä laskeminen 5.7 Muita tunnuslukuja 5.8 C-ohjelman kompleksisuus 5.9 Rekursioyhtälöt 5.10 Kuinka analyysi tarkistetaan? 9/18/02 94

95 5.1 Johdanto MIKSI tarvitaan algoritmianalyysiä? Ohjelman resurssitarpeiden ennustaminen CPU-aika muistitila Algoritmien keskinäinen vertailu Sopivan algoritmin valitseminen 9/18/02 95

96 MITEN algoritmeja voi analysoida? 1. Empiirinen mittaaminen ja ekstrapolointi Tulos riippuu syöteaineistosta Tulos riippuu toteutuksesta Ekstrapolointi voi johtaa vääriin päätelmiin 2. Matemaattinen analyysi Luotettavampi, mutta ei ongelmaton Tulokset voivat olla epäkäytännöllisiä Voi johtaa analyyttisesti vaikeisiin ongelmiin 3. Käsitteellinen luokittelu Kvalitatiivinen analyysi harvoin riittävä 9/18/02 96

97 5.2 Tavoitteet A) Syöteaineiston laatu ei saa johtaa vääriin tuloksiin Koska täsmällinen ennustaminen suoritusajasta ei ole mahdollista, haetaan seuraavia tunnuslukuja: Pahin tapaus (worst case performance) Realistinen tai sitten ei Esim. haetaan tiettyä alkiota listasta. Mikä on pahin tapaus? Keskimääräinen tapaus (average case performance) Usein merkittävämpi tulos Analyysi usein vaikeaa Esim. Mikä on keskimääräinen tekstitiedosto? 9/18/02 97

98 B) Erotetaan algoritmi ja sen toteutus toisistaan Toteutus vaikuttaa suoritusaikaan vain kertoimen kautta C) Etsitään 'paras' yläraja Mahdollisimman lähellä teoreettista ylärajaa D) Keskitytään olennaiseen Pääosa CPU-ajasta kuluu vain pienessä osassa ohjelmaa E) Täsmällinen lauseke harvoin tarpeen Määräävä termi riittää 9/18/02 98

99 5.3 Algoritmien luokittelu 1 : kiinteä (vakio) suoritusaika esim. lausekkeen evaluointi N 2 : neliöllinen esim. sijoituslajittelu log N : logaritminen esim. puolitushaku N 3 : kuutiollinen esim. matriisitulo N : lineaarinen esim. lineaarinen haku N*log N : "N log N" esim. Mergesort 2 N : eksponentiaalinen esim. salasanan haku, travelling salesman Eksponentiaaliset algoritmit eivät ole käytännössä sovellettavia, mutta niitä esiintyy monien käytännön probleemien perusratkaisuissa 9/18/02 99

100 5.4 Kertaluokkamerkinnät Funktio T(N) Œ O( f(n) ), jos on olemassa c ja N 0 siten, että T(N) < c f(n), kaikille N > N 0 laskentaan Merkitään: T(N) = O( f(n) ) kuluva aika c f(n) T(n) Tämä on syötteestä ja toteutuksesta riippumaton yläraja f(n) ongelman koko HUOM! N0 Kuvaa askelten määrää, EI kulutettuja CPU-sekunteja Yläraja voi olla turhan epätarkka eli epärealistinen c ei ole välttämättä pieni N 0 ei ole välttämättä pieni Asymptoottinen käyttäytyminen ei välttämättä ratkaise "pienillä" N:n arvoilla, esim. 10*N 2 < 1000*N, N < 100 9/18/02 100

101 Esim. Tarkastellaan neljää eri algoritmia, joiden tehokkuusluvut ovat 100N, 5*N 2, N 3 /2 ja 2 N Oletetaan koneet, joista toinen laskee 1000 askelta sekunnissa, toinen askelta sekunnissa algoritmi N (10 3 s) N (10 4 s) muutos 100*N *N N 3 / N Eksponentiaalisella algoritmilla konetehon kymmenkertaistuminen johtaa siihen, että pystytään käsittelemään vain 30% suurempaa ongelmaa! 9/18/02 101

102 5.5 Algoritmin toteutus Usein ei ole olemassa selvästi parasta algoritmia tai tietorakennetta. Valintaan vaikuttaa monia tekijöitä : kuinka usein ohjelmaa tarvitaan? syötteen koko (aineiston määrä) suoritusaikavaatimukset reaaliaikainen / eräluonteinen työ lisäysten / poistojen / päivitysten määrä ja suhde hakuihin Matemaattinen analyysi kertoo vain osan totuudesta. Muita tekijöitä ovat : kääntäjä käyttöjärjestelmä I/O:n määrä Yleensä kannattaa aloittaa yksinkertaisella menetelmällä (brute force well tuned) 9/18/02 102

103 Ongelman kasvaessa algoritmia voidaan vaihtaa tehokkaampaan uusimatta koko ohjelmaa N 2 Æ N * LOG N Algoritmin viilaaminen katkaistaan sopivasti. Ohjelmakoodin optimointi käsin kannattaa harvoin. Tärkeämpää on se, että ohjelmassa on varauduttu muutoksiin hyvin ehjä kokonaisuus abstraktit tietotyypit Ohjelman ylläpidettävyys on usein tärkeämpää kuin tehokkuus! 9/18/02 103

104 5.6 Kertaluokkamerkinnöillä laskeminen f(x) = O(f(x)) f(x) = O(x * f(x)) c * f(x) = O(f(x)) f(x) + c = O(f(x)) f(x) + g(x) = O(MAX[ f(x), g(x) ]) = MAX[ O(f(x)), O(g(x)) ] f(x) * g(x) = O(f(x) * g(x)) N a i *x i = O(x N ) i=0 log 10 x = O(log 2 x) 9/18/02 104

105 log k x = log p x / log p k = (1/vakio) * log p x = O(log p x) 9/18/02 105

106 VIRHEITÄ: O(f(x)) - O(f(x)) = 0 (p.o. O(f(x)) ) f(x) = O(g(x) / 2) f(x) = O(x 2 + x) O(f(x)) = f(x) f(x) <= O(g(x)) f(x) >= O(g(x)) OK: f(x, M) = O(g(x) + M) 9/18/02 106

107 5.7 Muita tunnuslukuja Iso-O (Big-Oh): f on T:lle yläraja T(N) = O( f(n) ), jos on olemassa c ja N 0 siten, että T(N) < c f(n) kaikille N > N 0 Iso-Omega: f on T:lle alaraja T(N) = W( f(n) ), jos on olemassa c ja N 0 siten, että T(N) > c f(n) kaikille N > N 0 Iso-Theta: f kasvaa täsmälleen kuin T T(N) = Q( f(n) ) T(N) = O( f(n) ) ja T(N) = W( f(n) ) Pikku-o (Little-oh): f on T:n aito yläraja T(N) = o( f(n) ) T(N) = O( f(n) ) ja T(N) Q( f(n) ) Huom! Nyt ei puhuta ylärajoista tavallisessa mielessä 9/18/02 107

108 t c3n cn 3 c0n 2 T(N) = 77+N/2 K3.3 c2sqrt(n) N T(N) = O(N 2 ) T(N) = O(N 3 ) T(N) = O(N) T(N) = W(sqrt(N)) T(N) = W(N) T(N) = q(n) T(N) = o(n 2 ) T(N) = o(n 3 ) Big-Oh on tärkein tunnusluku. 9/18/02 108

109 5.8 C-ohjelman kompleksisuus Peräkkäiset lauseet: s= 0; vakio O(1) for (i=0; i<n; i++) O(N) s= s+1; Valitaan maksimi O(N) If-Then-Else Valitaan maksimi For-silmukat for (i=1; i<n; i++) for (j=i+1; j<=n; j++) s= s+1; (N-1)*N/2 = O(N 2 ) 9/18/02 109

110 Rekursio: Fibonacci-luvut int fibonacci(int n) { if (n<=1) return 1; else return fibonacci(n-1) + fibonacci(n-2); } T(0) = T(1) = 1 T(N) = T(N-1) + T(N-2) + 2 >= fib(n) (3/2) N <= fib(n) <= (5/3) N T(N) on eksponentiaalinen 9/18/02 110

111 Rekursio: Kertoma int factorial(int n) { if (n==0) return 1; else return n*factorial(n-1); } T(N) = T(N-1) + 1 T(N) = O(N) O() Yhtä hyvä kuin ei-rekursiivinen Rekursiosta aiheutuu yleiskustannuksia 9/18/02 111

112 5.9 Rekursioyhtälöt Rekursiivinen hajota ja hallitse -algoritmi johtaa usein rekursioyhtälöön joka olisi ratkaistava: Esim 1. Listan läpikäynti silmukassa, poista yksi alkio: T(N) = T(N-1) + N, T(1) =1 N T(N) = Â k = N (N + 1) / 2 k=1 T(N-1) = T((N-1)-1) + (N-1) = T(N-2) + N - 1 T(N-2) = T((N-2)-1) + (N-2) = T(N-3) + N - 2 T(N-k) = T((N-k)-1) + (N-k) = T(N-k-1) + N - k T(N) on noin N 2 / 2 = O(N 2 ) 9/18/02 112

113 Esim 2. Binäärihaku, puolita aineisto vakioajassa: T(N) = T(N/2) + 1, T(1) =1 N = 2 k, k = log 2 N T(2 k ) = T(2 k-1 ) + 1 = T(2 k-2 ) = T(2 0 ) + k = k +1 T(N) = O(k+1) = O(log N) Esim 3. Puolita aineisto (sitä ennen tutki kaikki): T(N) = T(N/2) + N T(N) = N + N/2 + N/4 + N/ = 2N = O(N) 9/18/02 113

114 Esim 4. Jaa aineisto kahteen puolikkaaseen, molemmat käsitellään T(N) = 2T(N/2) + N, T(1) = 0 N = 2 k, k = log 2 N T(2 k ) = 2T(2 k-1 ) + 2 k <=> T(2 k ) / 2 k = T(2 k-1 ) / 2 k <=> T(2 k-1 ) / 2 k-1 = T(2 k-2 ) / 2 k <=> T(2 k-2 ) / 2 k-2 = T(2 k-3 ) / 2 k <=> T(2 2 ) / 2 2 = T(2 1 ) / <=> T(2 1 ) / 2 1 = T(2 0 ) / Lasketaan yhteen (teleskooppi) fi T(2 k ) / 2 k = 0 / 1 + k fi T(N) = T(2 k ) = k 2 k = N log N = O(N log N) 9/18/02 114

115 Esim. Potenssiinkorotus: x n = x*x*x*...*x, n-1 kertolaskua => O(n) integer pow(int x, int n){ switch (n) { case 0: return 1; break; case 1: return x; break; default: if (n&1) return pow(sqr(x), n/2)*x; else return pow(sqr(x), n/2); } } esim. x 9 = (x 2 ) 4 x = ((x 2 ) 2 ) 2 x T(n) = T(n/2) + 2, T(1) = T(0) = 1 T(n) = O(log n) (Ratkaisu: vrt. Esim. kohta 2 edellä) 9/18/02 115

116 5.10 Kuinka analyysi tarkistetaan? Empiirisesti Toteuttamalla ohjelma Tehdään koeajoja arvoilla N, 2N, missä N on mahdollisimman suuri Kun N tuplaantuu O(N) - algoritmien ajoaika tuplaantuu O(N 2 ) : nelinkertaistuu O(N 3 ) : kahdeksankertaistuu jne. O(log N) : vain vakiotermi lisää riippumatta N:stä O(N log N) : hiukan huonompi kuin O(N) Alemman asteen termit sotkevat empiiristä tarkastelua 9/18/02 116

117 Jos T(N) on mitattu suoritusaika ja oletetaan, että T(N) = O( f(n) ), niin voidaan tilastoida suuretta c = T(N)/f(N) satunnaisilla N:n arvoilla Jos c lähestyy positiivista arvoa fi f(n) on tiukka raja, ehkä T(N) = q( f(n) ) Jos c lähestyy nollaa fi f(n) on liian lepsu raja, voidaan sanoa että T(N) = o( f(n) ) Jos arvot hajaantuvat => f(n) kasvaa liian hitaasti, T(N) ei ole O( f(n) ) 9/18/02 117

118 Tehtäviä Aseta seuraavat funktiot kasvunopeuden mukaiseen järjestykseen: 10^10, log N, log log N, N, N log N, N 2, 2 N, N 0.1, N!, log (N!), N 2 2 N Ratkaise seuraavat rekursioyhtälöt T(N) = 2T(N/2) + N 2 (vastaus: Q(N 2 )) T(N) = T(N-1) + log N (vastaus: O(log N!)) Analysoi seuraavan ohjelman aikavaatimus: int func(long n) { int i, sum = 0; if (n==0) return 0; for (i=0; i<n; i++) sum++; return sum + func(n-1); } 9/18/02 118

119 6. PUURAKENTEET 6.1 Käsitteistöä 6.2 Binääripuu (binary tree) 6.3 Puiden esitystapoja 6.4 Puussa kulkeminen (traversing a tree) 6.5 Puiden sovelluksia 9/18/02 119

120 6.1 Käsitteistöä Puurakenteen perusmalli on sukupuu ylös A juuri (root) alas B C G isä (parent) D H L lapsi (child) 9/18/02 120

121 Käsitteitä ja ominaisuuksia: Solmu (vertex) on puuhun kuuluva alkio, johon voidaan tallettaa dataa Väli, särmä, kaari (edge) on suora yhteys kahden solmun välillä Juuri (root) on puun ylin solmu Solmun lähin edeltäjä on sen isä (father, dad, parent). Kauemmista edeltäjistä käytetään nimeä isoisä, esi-isä tai edeltäjä (grandfather, ancestor) Solmun lähinnä alemmat seuraajat ovat sen lapsia (children). Näiden lapset vastaavasti lapsenlapsia (grandchildren) Kullakin solmulla on vain yksi isä Juurella ei ole isää 9/18/02 121

122 Solmulla voi olla 0-N kpl lapsia. Yleisessä puussa lasten määrää ei ole rajoitettu Saman isän lapset ovat toistensa sisaruksia (sibling) Lehti (leaf, external node) on solmu, jolla ei ole lapsia Muut solmut ovat puun sisäsolmuja (internal node) Lehdet ovat joskus rakenteeltaan erilaisia kuin sisäsolmut Polku (path) on yhteys kahden solmun välillä Juuresta mihin tahansa solmuun on vain yksi polku. Vastaavasti jokaisesta solmusta on vain yksi polku mihin tahansa toiseen solmuun Jokainen solmu on oman alipuunsa (subtree) juuri Puiden joukko on metsä (forest) 9/18/02 122

123 Järjestetyssä puussa (ordered tree) lasten järjestys on määrätty Vasen, Oikea Ensimmäinen, Toinen,...,Viimeinen EI tarkoita sitä että solmuihin liittyvä tieto olisi järjestyksessä! Solmu on tasolla N (level N), jos polulla siitä juureen on N solmua. Juuren taso on 0. Puun korkeus (height) on sen tasojen määrä, ts. pisimmän juuresta lehteen ulottuvan polun pituus 9/18/02 123

124 Lause: Jos puussa on N solmua niin siinä on N-1 särmää Todistus: Jokainen solmu kytkeytyy yhdellä särmällä isäsolmuunsa Juurisolmulla ei ole isää Puun rekursiivinen määritelmä: Puu on joko yksittäinen solmu tai juurisolmu, joka on kytketty joukkoon muita puita (= alipuita ) Alipuiden tulee olla pareittain pistevieraita 9/18/02 124

125 Usein käytetty merkintä: Solmut palloja Alipuut kolmioita P U U K4.2 Al i puu Al i puu 9/18/02 125

126 6.2 Binääripuu (binary tree) Binääripuu (binary tree) on järjestetty puu, jossa jokaisella solmulla on täsmälleen kaksi lasta: vasen ja oikea (voivat olla tyhjiä) Binääripuu on täysi (full), jos kaikki puussa olevat tasot ovat täynnä mahdollisesti alinta lukuunottamatta 9/18/02 126

127 Binääripuu on täydellinen (complete), jos alinta tasoa lukuunottamatta kaikki tasot ovat täynnä ja alimmalla tasolla solmut ovat vasemmassa reunassa Terminologiassa on pientä horjuvuutta 9/18/02 127

128 6.3 Puiden esitystapoja Dynaaminen tietorakenne struct node { char key; struct node *left; struct node *right; }; left key typedef struct node * link; Lehtisolmujen linkit voidaan asettaa arvoon NULL 9/18/ right

129 Sama Javalla class TreeNode { private Object data; private TreeNode left, right; } TreeNode (Object element) { data = element; left = null; right = null; } TreeNode root, p, q; Lehtisolmujen linkit voidaan asettaa arvoon NULL 9/18/02 129

130 Joskus juuren käsittely joudutaan suorittamaan erikoistapauksena Esim. jos kaikkiin solmuihin kohdistettava operaatio viittaa myös solmun isään Kannattaa määritellä ylimääräinen Head-solmu, josta on viittaus juureen Vrt. linkitetty lista Head K4.4 9/18/02 130

131 Samoin voidaan määritellä erityinen z-solmu, johon tyhjät alipuut eli lehtisolmujen linkit viittaavat (Sedgewick: Algorithms) : z-solmuja on vain yksi kappale Head z-solmun linkit viittaavat z-solmuun itseensä K4.5 Kaikki kerralla käytössä olevat dynaamiset tietorakenteet voivat käyttää samaa z-solmua Z 9/18/02 131

132 Nyt esim voidaan luoda tyhjä puu ja käsitellä sitä samoilla rutiineilla kuin muitakin puita: link Z = malloc(sizeof(struct node)); Z->left = Z; Z->right = Z; link Head = malloc(sizeof(struct node)); Head->left = Z; Head->right = Z; Head K4.6 Z 9/18/02 132

133 Tämä esitystapa mahdollistaa vain liikkumisen puussa alaspäin Jos halutaan liikkua myös ylös, voidaan lisätä kolmas linkki, dad, joka osoittaa solmun isään Yleistä puuta ei kannata esittää samalla tavalla, koska lasten määrä ei ole rajattu 9/18/02 133

134 6.3.2 Taulukkoesitys Täydellinen binääripuu voidaan esittää yksinkertaisessa taulukossa Juuri on taulukon 1. alkiossa Alkiossa k olevan solmun isä on alkiossa k DIV 2 Alkiossa k olevan solmun lapset ovat alkioissa 2*k ja 2*k+1 Esityksessä voi liikkua sekä ylös että alas puussa 9/18/02 134

135 6.3.3 Isä-linkit tai -taulukko yleiselle puulle Jos puussa tarvitsee liikkua vain ylöspäin, riittää kussakin solmusta tieto sen isästä. Tämä voidaan toteuttaa joko dynaamisena tietorakenteena tai taulukkona struct node { char key; struct node *dad; }; A E R E typedef struct node * link; A S T k M P L E a[k] A S A M P L E T R E E X dad[k] /18/02 135

136 Solmusta on osoitin vasemman- puolimmaiseen lapseen ja lähinnä oikealla olevaan veljeen Jos yleisessä puussa halutaan liikkua alaspäin, kytketään kunkin solmun jälkeläiset linkitetyksi listaksi. Siten voidaan varata tilaa tarpeen mukaan. A A S E R E T struct node { char key; struct node *First_child; struct node *Next_sibling; }; M P L E typedef struct node * link; => Esitysmuoto palautuu binääripuuksi! 9/18/02 136

137 6.4 Puussa kulkeminen (traversing a tree) Monessa tilanteessa pitää pystyä käymään läpi (traverse) kaikki puussa olevat alkiot Läpikäyntijärjestyksiä on useita esijärjestys (preorder) sisäjärjestys (inorder) jälkijärjestys (postorder) tasojärjestys (level order) 9/18/02 137

138 Esijärjestyksessä puu käydään läpi järjestyksessä: juuri - vasen alipuu - oikea alipuu P M S A A L E R T E E Sisäjärjestyksessä puu käydään läpi järjestyksessä: vasen alipuu - juuri - oikea alipuu A S A M P L E T R E E P M L S E A A R T E 9/18/02 E 138

139 Jälkijärjestyksessä puu käydään läpi järjestyksessä: vasen alipuu - oikea alipuu juuri A A S M T E E R E L P Tasojärjestyksessä puu käydään läpi kukin taso kerrallaan ylhäältä alkaen P M L S E A A R T E E P M L S E A A R T E E 9/18/02 139

140 Muistisääntö : Piirretään viiva juuren päältä lähtien vastapäivään puun ympäri läheltä liipaten, tulostetaan solmu kun se ohitetaan vasemmalta => Esijärjestys ohitetaan alta => Sisäjärjestys ohitetaan oikealta => Jälkijärjestys 9/18/02 140

141 Kolmen ensimmäisen läpikäyntitavan implementaatio on helpointa tehdä rekursion avulla void traverse_preorder(link t) { if (t!= NULL) { visit(t); traverse_preorder(t->left); traverse_preorder(t->right); } } 9/18/02 141

142 void traverse_inorder(link t) { if (t!= NULL) { traverse_inorder(t->left); visit(t); traverse_inorder(t->right); } } void traverse_postorder(link t) { if (t!= NULL) { traverse_postorder(t->left); traverse_postorder(t->right); visit(t); } } 9/18/02 142

143 Esijärjestys pinon avulla: Tasojärjestyksen implementointi käy helposti jonorakenteen avulla: void traverse_preorder(link t) { push(t); do { t = pop; if (t!= NULL) { visit(t); push(t->right); push(t->left); } } while (!stack_empty); } void traverse_levelorder(link t) { put(t); do { t = get; if (t!= NULL) { visit(t); put(t->left); put(t->right); } } while (!queue_empty); } 9/18/02 143

144 Yleisen puun läpikäynnissä em. algoritmit yleistetään E Esijärjestys A R E E A A S R T M P L E E A S T Jälkijärjestys M P L E A S A M P L E T R E E Koska yleinen puu on palautettavissa binääripuuksi, sitä koskevat algoritmit voidaan yleistää binääripuun käsittelyalgoritmeista 9/18/02 144

145 6.4.1 Eräitä läpikäynnin sovelluksia: Esijärjestys sisällysluettelon tulostaminen tiedostoluettelon tulostaminen Sisäjärjestys hakupuun sisältö aakkostettuna lauseke infix-muodossa Jälkijärjestys tulosyhteenveto lauseke postfix-muodossa 9/18/02 145

146 6.4.2 Läpikäyntijärjestyksen merkityksiä Esijärjestys vastaa depth first-hakua etsitään tietty haara mahdollisimman pitkälle ennen kuin peräännytään Tasojärjestys vastaa breadth first hakua etsitään tietyllä etäisyydellä juuresta olevia solmuja. 9/18/02 146

147 6.5 Puiden sovelluksia Jäsennyspuu. Esimerkiksi lauseke voidaan esittää puurakenteen avulla Alkuperäinen infix-lauseke: 5 * ( ( ) * (4 + 6) + 7 ) Kun tämä puu käydään läpi jälkijärjestyksessä, saadaan lauseke postfix-muodossa : * 7 + * + 9/18/02 147

148 Sisäjärjestys antaa lausekkeen alkuperäisessä infixmuodossa, kunhan sulut lisätään yhteenlaskusolmujen oikeille puolille 5 * ( ( ) * ( ) + 7 ) Esijärjestys antaa ns. prefix-muodon * 5 + * /18/02 148

149 Jäsennyspuun luominen: 1. Luetaan postfix-lauseketta merkki kerrallaan * 7 + * 2. Operandi => Tehdään tästä uuden puun juuri Osoitin uuteen puuhun asetetaan pinoon 3. Operaattori => Tehdään tästä uuden puun juuri Oikeaksi lapseksi popataan pinon päällimmäinen Vasemmaksi lapseksi seuraava Osoitin uuteen puuhun pinoon 9/18/02 149

150 Esim: K4.10a /18/02 150

151 * * /18/02 151

152 * * /18/02 152

153 * * 5 + * /18/02 153

154 6.5.2 Hakupuu Tieto voidaan järjestää puuhun siten, että haku on nopeaa. Esimerkki: binäärinen hakupuu (binary search tree) K E S C G R U A J T X I 9/18/02 154

155 6.5.3 Keko Tieto voidaan järjestää puuhun siten, että suurimman (pienimmän) alkion etsiminen on nopeaa. Esimerkki: keko (heap) X T O G S M N A E R A I 9/18/02 155

156 Tehtäviä Esitä yleisen puun läpikäyntialgoritmit pseudo-koodina Laske seuraavan lausekkeen arvo muuntamalla se ensin infixmuodosta postfix-muotoon ja laskemalla sitten postfix-lausekkeen arvo: * ((2 * 3 + 4) * * (4 + 5 * 6)) Edellisen tehtävän algoritmi toimii myös vähennys- ja jakolaskujen yhteydessä, kun näille operaattoreille asetetaan sopivat prioriteetit. Se ei toimi potenssiinkorotuksen kanssa, koska potenssiinkorotus assosioi oikealta vasemmalle, t.s. 2^3^4 = 2^(3^4) eikä (2^3)^4. Miten algoritmeja tulee muuttaa, jotta myös potenssiinkorotus on toimisi oikein? Esitä algoritmi, joka laskee annetun mielivaltaisen binääripuun solmujen määrän. 9/18/02 156

157 7. Prioriteettijonot (priority 7.1 Yleistä queues) 7.2 Keko (heap) 7.3 Kekojärjestäminen (heap sort) 9/18/02 157

158 7.1 Yleistä Jonorakenne, jossa alkioihin liittyy prioriteetti (etuoikeusarvo) ja rakenne on järjestetty sen mukaan Prioriteettijonosta poistetaan aina pienin (suurin) alkio. Vertaa seuraaviin Pino (poista uusin) Jono (poista vanhin) Prioriteettijonoissa esiintyviä operaatiota: void Add(PriorityElement e) - lisää uusi alkio e prioriteetilla P PriorityElement DeleteMin() - poista pienin (suurin) alkio void Replace(PriorityElement e) - korvaa pienin alkio void Change(PriorityElement e) - vaihda e:n prioriteetiksi P PriorityElement Delete(PriorityElement e) - poista alkio e PriorityQueue Merge(PriorityQueue Q1, Q2) - yhdistä kaksi jonoa 9/18/02 158

159 Prioriteettijonoille on monia erilaisia implementaatioita. Niiden olennainen ero on siinä, miten tehokkaasti ne toteuttavat em. operaatioita. Esimerkkejä: Ei-järjestetty lista insert nopea, O(1) deletemin, replace, delete hitaita, O(N) Järjestetty lista insert hidas, O(N) deletemin nopea, O(1) replace, delete hitaita, O(N) 9/18/02 159

160 Binäärinen hakupuu kaikki operaatiot log N keskimäärin (pahin tapaus O(N)) lisäykset satunnaisia deletemin: poistetaan aina pienin eli vasemmanpuolisin alkio oikea alipuu pysyy satunnaisena Tasapainotettu puu pahin tapaus O(log N) Hakupuut tukevat myös monia muita operaatioita ja ovat useimmiten turhan monimutkaisia prioriteettijonojen toteutukseen 9/18/02 160

161 SOVELLUTUKSIA: Mikä tahansa prioriteettijono vastaa jotain järjestämisalgoritmia: Lisää N alkiota ja poista ne yksitellen Ei-järjestetty lista <=> selection sort Järjestetty lista <=> insertion sort printterijono käyttäjän mukaan tiedoston koon mukaan simulaatiot Huffman encoding [Huffman (1952)] käyttöjärjestelmät prosessien iän mukaan 9/18/02 161

162 7.2 Keko (heap) Tärkeä prioriteettijonototeutus. Kaikki operaatiot (paitsi Join-operaatio) ajassa O(log N) Keko on binääripuu, jossa avain on pienempi (suurempi), kuin sen lapset. Tällöin sanotaan, että puu täyttää kekoehdon Esimerkin kekoehto: isä suurempi kuin poika X T O G S M N A E R A I 9/18/02 162

163 Keko voidaan esittää taulukkona, koska keko on täydellinen binääripuu X T O G S M N A E R A I isä : j / 2 pojat : 2j ja 2j + 1 Keko-algoritmien yleisperiaate: Ensin yksinkertainen rakenteellinen muutos Sitten keon modifiointi siten, että kekoehto palautetaan voimaan 9/18/02 163

164 Insert Lisää alkio taulukon loppuun ensimmäiseen tyhjään paikkaan Korjaa kekoehto nostamalla alkiota ylemmäs vaihtamalla aina pareittain isän kanssa (upheap) tai luomalla tyhjä solmu, siirtämällä sitä ylöspäin ja asettamalla uusi alkio lopulta siihen 9/18/02 164

165 DeleteMin Juuri poistetaan Asetetaan viimeinen elementti juuren tilalle ja annetaan juurena olevan elementin 'valua' oikealle paikalleen (downheap) tai valutetaan tyhjää paikkaa alemmas ja siirretään viimeinen elementti lopulta siihen Vaihdetaan isä aina pienemmän (riippuen kekoehdosta) pojan kanssa 9/18/02 165

166 Esimerkki prioriteettijonon käytöstä, valikointiongelma: Etsi taulukosta k:nneksi pienin alkio! Menetelmä A Luetaan N alkiota taulukkoon Järjestäminen O(N 2 ) tai O(N log N) Otetaan k:nnes alkio 9/18/02 166

167 Menetelmä B Luetaan k alkiota taulukkoon Järjestetään kasvavaan järjestykseen O(k 2 ) Nyt k:nnes on suurin Luetaan loput N-k alkiota yksi kerrallaan Jos luettu alkio pienempi kuin k:nnes => Sijoitetaan uusi alkio paikalleen k:nnes häviää O((N - k) k) Lopussa k:nneksi pienin on k:nnentena Jos k on pieni => O(N k) Jos k on luokkaa n/2 => O(N 2 ) 9/18/02 167

168 Menetelmä C Sijoitetaan N alkiota kekoon O(N log N) pahin tapaus O(N) keskimäärin, sillä insert menee keskimäärin ajassa O(1) Poistetaan k alkiota O(k log N) Viimeksi poistettu alkio on k:nneksi pienin Kokonaisaika O(N + k log N) 9/18/02 168

169 Menetelmä D Sijoitetaan k alkiota kekoon O(k) Kekoehto: isä suurempi kuin poika Nyt suurin on kekon päällä Luetaan loput N-k yksi kerrallaan Jos luettu alkio on pienempi kuin keon päällimmäinen => Poistetaan päällimmäinen (suurin) O(log k) Laitetaan uusi alkio kekoon O(log k) 9/18/02 169

170 Lopussa k:nneksi pienin keon päällä Kokonaisaika O(N + (N - k) log k) = O(N log k) Huom! k:nneksi pienin alkio on (N - k + 1):nneksi suurin alkio 9/18/02 170

171 Esimerkki 2, tapahtumasimulointi: Esim. Jonotus rautateiden lipunmyynnissä Uusia asiakkaita generoituu vaikkapa eksponentiaalijakauman mukaan Asiakkaan palveluaika jakautuu jonkin toisen jakauman mukaan Simuloinnin perusteella määrätään palvelevien kassojen lukumäärä Kullakin hetkellä tiedetään joukko tulevia tapahtumia ja niiden tapahtuma-ajat Tulevat tapahtumat kannattaa tallettaa kekoon, jossa prioriteettiarvona on aika 9/18/02 171

172 7.3 Kekojärjestäminen (heap sort) Lisätään kaikki alkiot kekoon ja poistetaan ne yksitellen Poistetut alkiot voidaan sijoittaa samaan tilaan for (k = 1; k <= M; k++) insert(taulu[k]); for (k = M; k > 0; k--) taulu[k] = deletemin(taulu); 9/18/02 172

173 Menetelmä on riippumaton siitä, miten prioriteettijono on toteutettu. Jos toteutus on keko, saadaan kekojärjestäminen. Kekojärjestämisessä tehokkuusluku on aina korkeintaan N log N. Suoritettavia käskyjä / elementti kuitenkin enemmän kuin Quicksortissa keskimäärin 9/18/02 173

174 Tehtäviä Muodosta keko lisäämällä alkujaan tyhjään kekoon avaimet MYOLDUNIVERSITY. Käytä prioriteettina aakkosjärjestystä. Kekoehto on isä on pienempi kuin lapset. Miten tilanne muuttuu, jos keko muodostetaan lineaarisessa ajassa toimivalla buildheapalgoritmilla? Esitä algoritmi, joka yhdistää kaksi kekoa, joissa on N ja M avainta. Mikä on algoritmisi aikavaatimus O-notaatiossa? 9/18/02 174

175 8. Järjestäminen (sorting) 8.1 Johdanto 8.2 Yksinkertaiset menetelmät 8.3 Lomitus (merging) 8.4 Lomitusjärjestäminen (merge sort) 8.5 Quicksort 8.6 Valikointi (selection) 8.7 Jakauman laskeminen (Distribution counting) 8.8 Kantalukujärjestäminen (radix sorting) 8.9 Järjestämismenetelmän valinnasta 9/18/02 175

176 8.1 Johdanto Järjestäminen eli lajittelu on tietojenkäsittelyn perusasioita. Sovelluksia on lukemattomia: henkilörekisterit puhelinluettelo tilitapahtumat graafiset koordinaatit 9/18/02 176

177 Perusajatukset: Järjestetään tiedostoja, jotka koostuvat tietueista Jokaisessa tietueessa on yksi tai useampi avain, jonka perusteella järjestetään Jos järjestetään keskusmuistissa, on kyse sisäisestä järjestämisestä (internal sorting) Jos järjestetään levyllä tai mg-nauhalla, koska tiedostot eivät mahdu keskusmuistiin, on kyse ulkoisesta järjestämisestä (external sorting) 9/18/02 177

178 Järjestämismenetelmän vaatima tietokoneaika on verrannollinen järjestettävien elementtien määrään seuraavasti: O( N 2 ) perusmenetelmät O(N log N) kehittyneet menetelmät O(N) jos avaimella on erikoisominaisuuksia, joita voidaan käyttää hyväksi bittitasolla W(N log N) alaraja järjestämisalgoritmeille, jotka perustuvat kokonaisten avainten vertailuihin 9/18/02 178

179 Järjestämismenetelmä on stabiili, jos se säilyttää samanlaiset avaimet omaavien tietueiden keskinäisen järjestyksen. Perusmenetelmät ovat yleensä stabiileja, kehittyneet menetelmät eivät Esimerkiksi, jos järjestän sähköpostiviestini ensin ajan suhteen ja sitten lähettäjän suhteen, stabiilissa menetelmässä saman lähettäjän viestit pysyvät aikajärjestyksessä. 9/18/02 179

180 Järjestämismenetelmän valintaan vaikuttavia tekijöitä ovat: tiedon määrä tietoalkion koko avaimen laatu, esim. integer / string järjestysaste menetelmän tehokkuus menetelmän tilantarve menetelmän monimutkaisuus 9/18/02 180

181 8.2 Yksinkertaiset menetelmät Järjestämisen perusmenetelmät perustuvat vierekkäisten alkioiden vertailuun ja niiden vaihtamiseen keskenään. Vaihto voi olla eksplisiittinen kuten esim. kuplajärjestämisessä tai implisiittinen kuten lisäysjärjestämisessä Valintajärjestäminen Lisäysjärjestäminen (8.2.3 Kuplajärjestäminen) Toteutustavan mukaan eräät menetelmät ovat yksinkertaisia, vaikka ne toimivatkin tehokkaasti Kuorijärjestäminen 8.7 Jakauman laskeminen 9/18/02 181

182 8.2.1 Valintajärjestäminen (selection sort) Etsitään taulukon pienin alkio ja sijoi-tetaan se taulukon alkuun vaihtamalla sen paikka 1. alkion kanssa. Seuraavaksi etsitään jäljellä olevasta osuudesta taulukon toisiksi pienin alkio ja vaihdetaan se 2. alkion kanssa. Jne. Vertailuja tarvitaan N 2 /2 kappaletta. Vaihtoja tarvitaan vain N kappaletta, millä on merkitystä, jos tietueet ovat suuria. Viimeksi mainittu asia voidaan kiertää epäsuoralla järjestämisellä (järjestetäänkin osoittimia eikä itse tietueita). 9/18/02 182

183 for (i = 0; i < N-1; i++) { min = i; for (j = i+1; j < N; j++) if (a[j] < a[min]) min = j; temp = a[min]; a[min] = a[i]; a[i] = temp; } 9/18/02 183

184 8.2.2 Lisäysjärjestäminen (insertion sort) Järjestettävä aineisto jakautuu kahteen osaan, jo järjestettyyn osaan ja sen jälkeiseen järjestämättömään osaan Joka askelella otetaan järjestämättömän osan ensimmäinen alkio, verrataan sitä askel askeleelta järjestettyyn osaan, kunnes oikea kohta löytyy. Alkio sijoitetaan tähän väliin, jolloin järjestynyt osa on kasvanut yhdellä 9/18/02 184

185 for (i = 1; i < N; i++) { temp = a[i]; j = i; while (j > 0 && a[j-1] > temp) { a[j] = a[j-1]; j--; } a[j] = temp; } Testi j > 0 on välttämätön, jotta indeksi ei juokse taulukon ulkopuolelle 9/18/02 185

186 Se voidaan kuitenkin välttää sijoittamalla elementtiin a[0] vartiosotilas (sentinel), joka on arvoltaan pienempi kuin taulukon muut alkiot. Nyt whilesilmukka ei juokse taulukon alarajasta läpi. Samalla koodi yksinkertaistuu ja tehostuu hieman. a[0] = INT_MIN; for (i = 2; i <= N; i++) { temp = a[i]; j = i; while (a[j-1] > temp) { a[j] = a[j-1]; j--; } a[j] = temp; } 9/18/02 186

187 Järjestettävä data on alkioissa a[1] - a[n] Sisäsilmukka suoritetaan keskimäärin N 2 /2 kertaa Lisäysjärjestämistä käytetään usein manuaalisessa järjestämisessä, esim. postinjakajilla. Tällöin lisäyskohta haetaan älykkäämmin ja lisäys voidaan toteuttaa yhdellä operaatiolla => algoritmin tehokkuus on noin N log N manuaalisessa toteutuksessa 9/18/02 187

188 8.2.3 Kuplajärjestäminen (bubble sort) Joissakin ohjelmoinnin oppikirjoissa käytetään tätä esimerkkinä järjestämisalgoritmista. Valitettavasti... Perusidea on se, että verrataan pareittain vierekkäisiä taulukon alkioita ja vaihdetaan tarvittaessa niiden paikkaa. Tällöin suurin alkio "kuplii" taulukon loppuun. Sitten toistetaan sama yhtä pienemmälle joukolle for (i = N-1; i >= 0; i--) for (j = 1; j <= i; j++) if (a[j-1] > a[j]){ temp = a[j-1]; a[j-1] = a[j]; a[j] = temp; } Kuplajärjestäminen on tehottomin perusmenetelmä. Sitä EI KANNATA KÄYTTÄÄ 9/18/02 188

189 Analyysiä: Oletetaan järjestämätön lista arvoja, joiden joukossa ei ole duplikaatteja Inversio on tapaus, jossa kaksi listan alkiota on väärässä järjestyksessä. Esim. i < j, mutta a[i] > a[j]. Teoreema 7.1. Inversioiden lukumäärä satunnaisessa listassa on keskimäärin N (N-1) / 4. 9/18/02 189

190 Todistus: Jokaista listaa L kohti on olemassa yksikäsitteinen käänteislista L R Oletetaan pari (x, y), x > y listassa L. Tällöin pari (y, x), x > y esiintyy käänteislistassa L R Yo. pari on inversio täsmälleen yhdessä listoista L ja L R Erilaisten parien lukumäärä kummassakin listassa yhteensä on (N- 1) + (N-2) = N (N-1) / 2 Keskimääräinen määrä inversioita listaa kohti on siis edellisen puolikas => Inversioita on siis keskimäärin N (N-1) / 4 kappaletta 9/18/02 190

191 Teoreema 8.2. Mikä tahansa algoritmi, joka järjestää alkioita vaihtamalla vierekkäisiä alkioita keskenään, vaatii aikaa W(N 2 ) Todistus: Inversioiden lukumäärä on N(N-1)/4 = W(N 2 ) Jokainen vierekkäisten alkioiden vaihto poistaa vain yhden inversion => Tarvitaan W(N 2 ) vaihtoa 9/18/02 191

192 Tämä on ns. alarajatodistus (lower bound proof), joka pätee kaikille em. ehdon täyttäville algoritmeille, riippumatta siitä, onko näitä edes keksitty. Tehokkaammat järjestämisalgoritmit perustuvat siihen, että ne siirtävät alkioita kerralla kauemmas ja siten poistavat kerralla useampia kuin yhden inversion. 9/18/02 192

193 8.2.4 Kuorijärjestäminen (shell sort) Menetelmä perustuu siihen, että tiedosto h-järjestetään eri h:n arvoilla H-järjestetyssä tiedostossa ovat joka H:nnesta elementistä muodostuvat alijoukot järjestyksessä H-järjestäminen tapahtuu lisäysjärjestämisen avulla Kuorijärjestämisessä suoritetaan lisäys järjestäminen kaikille osajoukoille käyttäen peräkkäin tiettyjä h-arvoja Menetelmän tehokkuus perustuu siihen, että alkioita siirretään pitempiä matkoja 9/18/02 193

194 Donald Shellin alkuperäiset inkrementit: h t = (int) (N / 2), h k = h k+1 / 2 => O(N 2 ) pahin tapaus Empiirisesti löydetty hyvä h-jono on ns. Hibbardin inkrementit 1093, 364, 121, 40, 13, 4, 1 eli h n = 3h n => O(N 3/2 ) pahin tapaus 9/18/02 194

195 Sedgewickin inkrementit 1,5,19,41,109,... => pahin tapaus O(N 4/3 ) Avoimia kysymyksiä: Voidaanko löytää parempia sekvenssejä? Keskimääräisestä tehokkuudesta ei ole tarkkaa tietoa. On arvioitu eri tapauksille O(N 5/4 ), O(N 7/6 ) tai O(N (logn) 2 ). 9/18/02 195

196 8.3 Lomitus (merging) Kaksi järjestyksessä olevaa tiedostoa yhdistetään uudeksi tiedostoksi, joka on myös järjestyksessä Tyyppitilanne: Rekisteriin, joka on järjestetty, lisätään uusia elementtejä Ne kootaan ensin tapahtumatiedostoon (myös järjestyksessä) Nämä yhdistetään määräajoin Yhdistely lineaarisessa ajassa, two-way merging: a[0..m], b[0..n] => c[0..m+n] 9/18/02 196

197 Valitaan aina pienin alkio a:sta ja b:stä ja kirjoitetaan se c:hen. Taulukkojen lopussa vahtisotilaat. i = 0; j = 0; a[m] = INT_MAX; b[n] = INT_MAX; for (k = 0; k < M + N; k++) if ( a[i] < b[j] ) { c[k] = a[i]; i = i + 1; } else { c[k] = b[j]; j = j + 1; } Vaatii aikaa O(M + N) 9/18/02 197

198 8.4 Lomitusjärjestäminen (merge sort) Yhdistetään järjestäminen ja lomitus: 1. Jaa tiedosto kahtia 2. Järjestä puoliskot rekursiivisesti 3. Yhdistele puoliskot yhdeksi (vertaa Quicksort) Divide & Conquer-algoritmi T(N) = 2T(N/2) + N, T(1) = 1 Tehokkuus aina N log N Lyhyt sisin silmukka 9/18/02 198

199 Stabiili MUTTA vaatii ylimääräisen muistitilan Mergesort soveltuu hyvin tilanteisiin, joissa tietoon päästään käsiksi vain peräkkäisjärjestyksessä (esim. linkitetyt listat, ulkoiset tiedostot). Voidaan toteuttaa myös ei-rekursiivisena 9/18/02 199

200 void mergesort(int left; int right) { int i, j, k, m; if (right > left) { m = (right + left) / 2; mergesort(left, m); mergesort(m + 1, right); for (i = m; i >= left; i--) b[i]= a[i]; for (j = m + 1; j <= right; j++) b[right + m j] = a[j]; 9/18/02 200

201 } i = left; j = right; for (k = left; k <= right; k++) if (b[i] < b[j]) { a[k] = b[i]; i = i + 1; } else { a[k] = b[j]; j = j - 1; } } 9/18/02 201

202 Mergesort linkitetyille listoille: link mergesort(link c; int N) { link alkuosa, loppuosa; if (c->next == z) return c; else { alkuosa = c; for (i = 2; i <= (N / 2); i++) c = c->next; 9/18/02 202

203 loppuosa = c->next; c->next = z; } return merge( mergesort(alkuosa, N / 2), mergesort(loppuosa, N-(N/2))); } link merge(link a; link b){...} two-way merge linkitetyille listoille 9/18/02 203

204 8.5 Quicksort Kehittäjä C.A.R. Hoare 1960 Tunnetuin ja yleisin tehokas järjestämismenetelmä Keskimääräinen tehokkuus N log N Pahin tapaus N 2, mutta se voidaan välttää pienillä virityksillä Kohtuullisen helppo toteuttaa perusmuodossaan 9/18/02 204

205 PERUSIDEA: Partitionti muokkaa taulukkoa a[left..right] ja hakee siitä kohdan i siten, että 1) alkio a[i] on kohdallaan 2) alkiot a[left].. a[i-1] a[i] 3) alkiot a[i+1]..a[right] a[i] Tämän jälkeen partitiointi suoritetaan molemmille puoliskoille rekursiivisesti 9/18/02 205

206 Quicksort on divide & conquer -algoritmi void quicksort(int left; int right) { int i; if (right > left) { i = partition(left, right); quicksort(left, i-1); quicksort(i+1, right); } } 9/18/02 206

207 Partitiofunktion toiminta: 1. Valitaan alueen oikeasta reunasta partitioalkio (pivot-alkio) 2. Verrataan siihen alkioita yhtäaikaa taulukon vasemmasta ja oikeasta reunasta alkaen 3. Vaihdetaan vasemmalla olevat sitä suuremmat alkiot oikealla oleviin sitä pienempiin alkioihin 4. Pivot-alkion kanssa yhtäsuuret alkiot osallistuvat vaihtoon (ei välttämätöntä, mutta tasapainottaa algoritmin toimintaa)... b a Q... B y z y P swap 9/18/02 207

208 int partition(int left; int right) { int i, j, pivot, apu; pivot = a[right]; i = left - 1; j = right; do { do i++; while (a[i] < pivot); do j--; while (a[j] > pivot); 9/18/02 208

209 apu = a[i]; a[i] = a[j]; a[j] = apu; } while (j > i); } a[j] = a[i]; a[i] = a[right]; a[right] = apu; return i; 9/18/02 209

210 Ongelmia ja virityksiä 1) Jos taulukko on valmiiksi järjestyksessä, partitiot degeneroituvat ja kyseessä on N 2 algoritmi fivalitaan partitioelementti mediaani-kolmesta menetelmällä tai satunnaisesti 2) Sama tilanne johtaa siihen, että suoritetaan N rekursiokutsua, jolloin ajonaikaisessa pinossa on N aktivaa-tiotietuetta fipoistetaan rekursio ja työnnetään suuremman alueen rajat itse pinoon (pienempi käsitellään suoraan). Pinon kooksi tulee korkeintaan log N. 9/18/02 210

211 Rekursio suoritetaan pienillekin partitioille fivaihdetaan lisäysjärjestämiseen, kun right - left < M tai filopetetaan vastaavassa tilanteessa quicksort ja järjestetään lopuksi koko taulukko lisäysjärjestämisellä 9/18/02 211

212 8.6 Valikointi (selection) "Hae mielivaltaisessa järjestyksessä olevasta tietoaineistosta k:nneksi suurin alkio. Esim. "Hae aineiston mediaani" Prioriteettijonon avulla O(N + k log N) Mediaanin haku O(N log N) Täsmällinen järjestäminen vie turhaa aikaa Jos k on pieni, valintajärjestäminen on hyvä menetelmä Mielivaltaiselle aineistolla voidaan soveltaa quicksortin idea: Partitioidaan aineisto ja otetaan jatkoon se osuus, johon k sisältyy. 9/18/02 212

213 int Select(int left; int k; int right) { } int i = -1; if (left < right) { } i = partition(left, right); if (k < i) return Select(left, k, i-1); if (k > i) return Select(i+1, k, right); return i; Keskimääräinen kompleksisuus O(N) 9/18/02 213

214 8.7 Jakauman laskeminen (Distribution counting) N tietuetta, joissa kokonaislukuavaimia välillä 0..M-1. N > M; Esim. a = <x,y,x,y,z,y,z>, N = S = 7, M = 3 "Etsitään samojen avainarvojen alueet taulukossa" 1) Aluelaskurien alustus; count = <0,0,0> for (j=0; j<m; j++) count[i] = 0; 2) Lasketaan avainten frekvenssit; count = <2,3,2> for (i=0; i<n; i++) count[a[i]]++; 9/18/02 214

215 3) Lasketaan kumulatiiviset frekvenssit; count = < 2,5,7> for (j=0; j<m; j++) count[j] += count[j-1]; 4) Sijoitetaan avaimet alueisiinsa; t = < x,x,y,y,y,z,z > (a=<x,y,x,y,z,y,z>) for (i=n-1; i>=0; i--) { t[ count[ a[i] ] ] = a[i]; // t[7]=z,t[5]=y,t[6]=z count[a[i]]--; } 5) Kopioidaan aputaulukko alkuperäiseen taulukkoon; a = t for (i=0; i<n; i++) a[i] = t[i]; 9/18/02 215

216 8.8 Kantalukujärjestäminen (radix sorting) Järjestäminen perustuu siihen, että käsitellään ja vertaillaan avaimen osia Esimerkki: Avaimet ovat kokonaislukuja välillä Järjestetään dekadeittain. Tietokoneessa avaimia käsitellään binäärilukuina eli järjestetään bittipositio/bittiryhmä kerrallaan fi Ominaisuuden hyväksikäyttö vaatii tehokasta pääsyä bittitason toimintoihin. Jos avaimet ovat lyhyitä, kannattaa käyttää jakauman laskemismenetelmää. Tarvittavan aputaulukon count koko on 2 b. 9/18/02 216

217 Tärkeimmät menetelmät ovat: digitaalinen vaihtojärjestäminen suora digitaalinen järjestäminen 9/18/02 217

218 C-simulaatio bittioperaatioille: n >> k Siirrä (shift) k bittiä oikealle n & (2 k -1) Ota (mask) viimeiset k bittiä int bits(n, k, j) = (n >> k) & (2 j -1) Palauttaa sanan osan, jossa on j bittiä alkaen positiosta k oikealta laskien Esim: bits(n, 0, 2) = 2 viimeistä bittiä 9/18/02 218

219 8.8.1 Digitaalinen vaihtojärjestäminen (radix exchange sort) Tiedot järjestetään bittipositio kerrallaan vasemmalta oikealle Kukin positio jaetaan kahteen osaan keräämällä nollat ja ykköset omiin ryhmiin Osat järjestetään edelleen rekursiivisesti seuraavasta bitistä lähtien Jos osan kooksi tulee 1, sitä ei järjestetä eteenpäin 9/18/02 219

220 Esimerkki /18/02 220

221 Tehokkuus N log N tai N*b (b = bittimäärä) Jos avaimet ovat satunnaisesti jakautuneita, ei kaikkia bittejä tarvitse tutkia Log N bittiä riittää, jolloin menetelmä on jopa nopeampi kuin Quicksort Samoilla avaimilla käydään läpi kaikki bitit, jolloin tehokkuus laskee 9/18/02 221

222 void radix_exchange(int left; int right; int pos) { if ((right > left) && (pos >=0)) { i = left; j = right; do { while (((bits(a[i],pos,1) = 0) && (i < j))) i++; while (((bits(a[j],pos,1) = 1) && (i < j))) j--; swap(a[i], a[j]); } while (j!= i); 9/18/02 222

223 if (bits(a[right],b,1) = 0) j++; } } radix_exchange(left,j-1,pos-1); radix_exchange(j, right,pos-1); Menetelmä muistuttaa Quicksortia! 9/18/02 223

224 8.8.2 Suora digitaalinen järjestäminen (straight radix sort) Järjestetään bittipositio kerrallaan oikealta vasemmalle Käyttää jakauman laskemista M:n bitin osuuksille (M 1) Perustuu osaltaan siihen, että jakauman laskeminen on stabiili menetelmä Jos M on yksi, järjestetään bitti kerrallaan. Tehokkuus paranee, jos M kasvaa Hyvä suositus on M = b / 4, jossa b on avainten bittien lukumäärä 9/18/02 224

225 Esimerkki /18/02 225

226 Esim. 32-bittisiä kokonaislukuja järjestetään tavu kerrallaan Tehokkuusluku on N, eli kyseessä on lineaarinen menetelmä Mutta: vaatii lisätilaa N alkiota hidas sisin luuppi 9/18/02 226

227 8.9 Järjestämismenetelmän valinnasta Yhteenveto tehokkuusluvuista W(N) A(N) Selection sort N 2 /2 N 2 /2 Insertion sort N 2 /2 N 2 /4 Shellsort c 0 N 4/3 c 0 N 7/6 * Distribution counting c 0 N c 0 N Quicksort N 2 /2 1.38NlogN Radix exchange sort c 0 NlogN c 0 NlogN Straight radix sort c 0 N c 0 N Heapsort 2.0NlogNei tietoa Mergesort 1.0NlogN1.0NlogN * Shellsortin h-jono 1, 5, 19, 41, 109,... 9/18/02 227

228 Huom! Kaikki laskettavat operaatiot eivät ole keskenään suoraan verrannollisia Kaikille algoritmeille ei löytynyt vakiokertoimen c 0 arvoa 9/18/02 228

229 Muita ominaisuuksia Lisämuistin tarve stabiilius Selection sort Ei On Insertion sort Ei On Shellsort Ei Ei Distribution count N + count On Quicksort Ei Ei Radix exchange sort Ei Ei Straight radix sort N + 2 m On Heapsort Ei Ei Mergesort N tai osoitt. On Huom! Mergesort voidaan toteuttaa ilman lisätilaa (monimutkaista) Quicksort ja Radix exhange sort voidaan toteuttaa stabiileina (monimutkaista) 9/18/02 229

230 Tehokkuusluku ei kerro kaikkea! On muitakin näkökulmia: Selection sort Yksinkertainen Pienelle tiedostolle, jossa suuret tietueet Voidaan soveltaa valikointiongelmaan, kun k on pieni Insertion sort Yksinkertainen Hyvä menetelmä pienille tiedostoille (N<50) Tehokas (lineaarinen) menetelmä, jos tiedosto 'melkein järjestyksessä Shellsort Yksinkertainen Tehokas vielä kohtalaisen suurilla tiedostoilla (N < ) 9/18/02 230

231 Distribution counting Yksinkertainen Tilanteisiin, joissa avainavaruus pienempi kuin avainten määrä Vaatii lisätilaa Quicksort Käytännön valinta useimpiin suuriin sovelluksiin Partitioelementtiä ei tule valita triviaalisti laidoista Viritykset ohjelmoitava huolellisesti Ei käy, jos tarvitaan stabiiliutta Huolelliset viritykset, jos ehdoton vaatimus NlogN-käyttäytymisestä Voidaan soveltaa valikointiongelmaan lineaarisessa ajassa 9/18/02 231

232 Radix exchange sort Implementaatio edellyttää pääsyä bitti-informaatioon kiinni Voidaan toteuttaa myös muissa kantaluvuissa (bucket sort) Tehokas, jos aineisto satunnainen Tehokkuus kärsii, jos aineistossa runsaasti samoja avainarvoja Ei kannata käyttää merkkijonoavaimille Straight radix sort Implementaatio edellyttää pääsyä bitti/tavuinformaatioon kiinni Tehokas Vaatii lisätilan, joka voi olla rasite suurilla tiedostoilla Ei kannata käyttää merkkijonoavaimille 9/18/02 232

233 Heapsort Taattu N log N Sopii hyvin ongelmaan, jossa halutaan löytää aineistosta k pienintä alkiota (k << N) Mergesort Taattu N log N Vaatii lisätilan Sopii tilanteisiin, joissa dataa käsitellään peräkkäisesti Lomitus on ulkoisten järjestämismenetelmien perusalgoritmeja 9/18/02 233

234 Tehtäviä Mikä on mediaani3:sta -menetelmää käyttävän quicksort-algoritmin pahimman tapauksen aikavaativuus? Anna esimerkki tällaisesta syötteestä (pituus vähintään 7 merkkiä). Pohdi miten quicksort algoritmia voisi virittää siten, että sen pahin tapaus olisi O(N log N). 9/18/02 234

235 9. HAKURAKENTEET (dictionaries) 9.1 Etsintä 9.2 Listat tallennusrakenteina 9.3 Taulukko tallennusrakenteena 9.4 Binäärinen hakupuu 9.5 Tasapainotetut puut (balanced trees) 9.6 Digitaaliset avaimet 9/18/02 235

236 9.1 Etsintä Etsintä on tietojenkäsittelyn perusongelmia, joka voidaan määritellä seuraavasti: Tiedot on esitetty tietorakenteessa, joka koostuu tietueista Kussakin tietueessa on avain (key), jonka avulla se voidaan tunnistaa Etsinnässä pyritään löytämään tietorakenteesta kaikki tietueet, joilla on annettu avain Luonnollisesti asiaan liittyy lisäysten, poistojen ja päivitysten tekeminen tietorakenteeseen Ongelmaan tunnetaan ratkaisuina erilaisia hakurakenteita 9/18/02 236

237 Esimerkkejä käytännön etsintäongelmista: Hae taulukosta annettu alkio Hae elektronisen sanakirjan sana Hae pankkitilin saldo Hae opintosuoritusrekisteristä opiskelijan suoritustiedot Hae opintosuoritusrekisteristä tietyn kurssin suorittaneiden opiskelijoiden nimet Etsi ne artikkelit, joissa esiintyy tämä hakusana 9/18/02 237

238 Etsintää varten on hyödyllistä määritellä abstrakti tietotyyppi hakurakenne (dictionary), johon liittyy ainakin seuraavia toimintoja: Alusta hakurakenne Hae avainta vastaava(t) tietue(et) Lisää uusi tietue Poista avainta vastaava(t) tietue(et) Yhdista kaksi hakurakennetta Tulosta hakurakenteessa olevat tietueet avainten perusteella lajiteltuna Lisäys ja poisto sisältävät yleensä osanaan hakutoiminnon 9/18/02 238

239 Muita toimintoja, joita voidaan tarvita: Hae tietue, jolla on lähinnä seuraava / edellinen avainarvo (naapurikysely, neighbour query) Hae tietueet, joiden avainarvo on tietyllä välillä (aluekysely, range query) Rakenteessa olevat duplikaatit (duplicates, tietueet, joilla on sama avainarvo) voidaan käsitellä eri tavoin: kukin erillisenä tietueena yksi tietue ja siitä lähtevä osoitin toiseen rakenteeseen yksi tietue ja siinä laskuri 9/18/02 239

240 Hakurakenne voidaan implementoida hyvin monella tavalla. Asiaan liittyviä näkökulmia ovat ainakin: tiedon määrä hakuihin, lisäyksiin ja poistoihin liittyvät aikavaatimukset talletetaanko rakenne keskusmuistiin vai massamuistiin? lisäysten ja poistojen määrä tarvitaanko erityyppisiä hakuavaimia? tarvitaanko operaatioita, joissa tietoa käsitellään järjestyksessä? menetelmän monimutkaisuus 9/18/02 240

241 Joitakin sovellusalueita: yksinkertaiset kortistot symbolitaulut tietokantojen hakemistot tiedostorakenteet CAD 9/18/02 241

242 Käsiteltävät hakurakenteet voidaan rinnastaa myös alkeellisiin tietokantoihin: vain yksi hakuavain vain yksi käyttäjä ei suojaus- eikä toipumismekanismeja ei yhtenäisyystarkistusta Käytännön tiedonhallintajärjestelmissä nyt käsiteltävät asiat liittyvät tietokannan indeksien toteutukseen. 9/18/02 242

243 9.2 Listat tallennusrakenteina Joukko yksinkertaisia hakurakenteita, joille on yhteistä seuraavat asiat: Hakuoperaatio on lineaarinen, mistä syystä rakenne soveltuu vain pieniin sovelluksiin (N < 100) Lisäykset ja poistot on helppo toteuttaa Voidaan toteuttaa linkitettynä listana tai listana taulukossa 9/18/02 243

244 Muunnelmia: Järjestämätön lista onnistunut haku: O(N), N/2 epäonnistunut haku: O(N) lisäys: O(1) poisto: haku + O(1) Järjestetty lista onnistunut haku: O(N), N/2 epäonnistunut haku: O(N), N/2 lisäys: O(N), N/2 poisto: haku + O(1) 9/18/02 244

245 Aktiviteetin mukaan järjestetty lista Jos avainten hakufrekvenssit poikkeavat toisistaan paljon, lista voidaan järjestää hakutilaston mukaan => Painotettu keskimääräinen hakuaika lyhenee Jos hakutilasto tunnetaan ennakolta, lista järjestetään alunperin sen mukaan Muutoin voidaan toteuttaa itsejärjestyvä lista (selfadjusting list): Jokainen haku siirtää alkiota pykälän edemmäksi Tai Haettu alkio siirretään listan alkuun 9/18/02 245

246 9.3 Taulukko tallennusrakenteena Yksinkertainen hakurakenne, jolla on seuraavia ominaisuuksia: Järjestetyssä taulukossa haku voidaan toteuttaa erittäin tehokkaasti suurillakin tietomäärillä Lisäykset ja poistot ovat raskaita operaatioita, O(N) => Jos paljon muutoksia, ei taulukkoa kannata käyttää Ongelmaa voidaan hieman kiertää lazy deletion menetelmällä, (ei varsinaisesti poisteta alkiota, vaan merkitään se mitättömäksi) Jos taulukko ei ole järjestyksessä, sitä ei juuri kannata käyttää hakurakenteena 9/18/02 246

247 Hakumenetelmät järjestetyssä taulukossa: Lineaarinen haku (linear search) Haetaan taulukon alusta lähtien, kunnes alkio löytyy, tai sen paikka on ohitettu Tehokkuus O(N) Binäärihaku (binary search): Tutkittava alue jaetaan kahtia, katsotaan kummassa puoliskossa tieto on, ja jatketaan hakua tässä puoliskossa. Vrt. yhtälön numeerinen ratkaisu puolitusmenetelmällä Tehokkuus O(log N) alkiosta tieto löytyy 21 haulla 9/18/02 247

248 #define N 1000 int a[n];... int binary_search(int key) { int left, right, probe; left = 0; right = N-1; do { probe = (left + right)/2; if (key < a[probe]) right = probe - 1; else left = probe + 1; } while ((key!= a[probe]) && (left <= right) ); if (key == a[probe]) return probe; else return = -1; 9/18/ }

249 Interpolaatiohaku Kehittyneempi menetelmä, jossa käytetään hyväksi tietoa tiedon jakaumasta. Puolitushaussa uusi hakupaikka lasketaan: Interpolaatiohaussa pyritään laskemaan, mistä alkiota kannattaa hakea (jakolasku katkaiseva DIV): Tehokkuus O(log (log N)), jos avainten jakauma on kohtalaisen tasainen 9/18/02 249

250 9.4 Binäärinen hakupuu (binary search tree) Binääripuu, joka on järjestetty sopivasti: Kunkin solmun vasemmassa lapsessa olevat alkiot pienempiä kuin solmu itse Oikealla puolella olevat lapset suurempia kuin solmu itse Jos puussa on duplikaatteja, ne ovat aina vain toisessa haarassa, esim. oikealla puolella K E S C G R U A J T X 9/18/02 I 250

251 Lehtien lapsina voi olla NULL tai z-solmu Voidaan käyttää Head-solmua, josta on osoitin juureen ja jonka avainarvo on pienempi kuin millään alkiolla puussa => Haun ja lisäyksen koodi yksinkertaistuu 9/18/02 251

252 9.4.1 Alkion haku: Edetään juuresta käsin alaspäin kääntyen aina vasempaan tai oikeaan haaraan, kunnes avain löytyy Palautetaan osoitin tähän solmuun. Jos avainta ei löydy, palautetaan NULL tai z-solmu Käytettäessä z-solmua haettava alkio talletetaan ensin siihen, jolloin haku päättyy aina avaimen löytymiseen. Nyt täytyy vain tarkistaa, löytyikö alkio puusta vai z:sta. rinnakkaisuus? Jos duplikaatit on talletettu puuhun, ne haetaan jatkamalla siitä, mihin edellinen haku päättyi: item = find(data, head); next_item = find(data,item->right); 9/18/02 252

253 9.4.2 Alkion lisäys: 1) Uusi alkio lisätään aina lehdeksi 2) Etsitään rekursiivisesti oikea paikka uudelle alkiolle 3) Haun aikana täytyy säilyttää tieto siitä, minkä lehden alle haku päättyi. 9/18/02 253

254 9.4.3 Alkion poisto: Monimutkaisempi toimenpide, jossa useita eri tapauksia: a) Lehti voidaan poistaa suoraan b) Jos solmulla on yksi lapsi, solmun isä asetetaan osoittamaan tähän lapseen c) Jos solmulla on kaksi lasta: Etsitään lähinnä seuraavan avainarvon sisältävä solmu S Kopioidaan tiedot tästä tuhottavaan solmuun Poistetaan solmu S rekursiivisesti. Tällä on korkeintaan oikea lapsi Toinen ratkaisu: Lazy deletion ja ajoittain puun uudelleen rakentaminen 9/18/02 254

255 9.4.4 Alkioiden lajittelu: Binäärisen hakupuun sisältö saadaan lajitellussa järjestyksessä käymällä puu läpi sisäjärjestyksessä Tehokkuusominaisuuksia: Ideaalisessa binäärisessä hakupuussa kaikki operaatiot tehdään ajassa O(log N) paitsi tyhjän puun luonti O(1) Käytännössä puun kaikki haarat eivät ole yhtä pitkiä, jolloin hakuaika riippuu polun pituudesta Pahimmassa tilanteessa puu degeneroituu listaksi, jolloin hakuaika on O(N) 9/18/02 255

256 9.4.6 Analyysi: Teoreema: keskeisten operaatioiden (haku, lisäys, poisto, minimi, maksimi, seuraaja, edeltäjä) aikavaatimus binäärisessä hakupuussa on O(h), jossa h on puun korkeus. Esim. haku: Pahin tapaus: h = N, jolloin pahimmassa tapauksessa hakuaika O(N) Paras tapaus: h = 1, jolloin parhaassa tapauksessa hakuaika O(1) Ideaalisessa tapauksessa puu tasapainossa: h = log(n) ja hakuaika O(log N) Keskimääräinen polun pituus: Oletus: kaikki puut yhtä todennäköisiä fi keskimääräinen hakuaika O(log N) 9/18/02 256

257 MUTTA... Delete-operaatioista johtuen kaikki puut eivät olekaan yhtä todennäköisiä fi Lisäysten ja poistojen vuorottelu johtaa pitkän päälle hakuaikaan O( N) Pahimmassa tapauksessa hakuaika on O(N). alkiot järjestyksessä alkiot käänteisessä järjestyksessä vuorottelevat avainarvot, esim sekvenssit, esim Nämä tapaukset voivat hyvin esiintyä käytännössä fi Hakuajat voivat venyä liian pitkiksi Ratkaisu: Hakupuuta muokataan siten, että se pysyy tasapainossa 9/18/02 257

258 9.5 Tasapainotetut puut (balanced trees) Puun käsittelyyn liittyy sopivia ehtoja ja toimintoja, jotka takaavat lähes täydellisen tasapainon (eri haarojen pituus sama). Useita erilaisia rakenteita, mm.: AVL-puu Punamusta puu B-puu Näitä tarkastellaan seuraavassa lähemmin Lisäksi on olemassa ns. Splay-puu, jossa Yksittäinen operaatio voi ottaa ajan O(N) M peräkkäistä operaatiota voidaan taata ottavan aikaa O(M log N) 9/18/02 258

259 9.5.1 Korkeustasapainotettu puu eli AVL-puu (height balanced tree, AVL tree) Määrittely: Tyhjä puu on korkeustasapainotettu Jos T on ei-tyhjä binääripuu, jolla on lapsina T L ja T R, niin T on korkeustasapainotettu, jos ja vain jos 1) T L ja T R ovat korkeus-tasapainotettuja 2) h L - h R 1, jossa h L ja h R ovat alipuiden korkeudet Puun toteutuksessa jokaiseen solmuun liittyy tasapainotekijä (balance factor), jonka arvo on h L - h R eli -1, 0 tai 1 9/18/02 259

260 Haku: Kuten binäärisessä hakupuussa Lisäys: Kuten binäärisessä hakupuussa, mutta sitä seuraa tasapainotekijöiden päivitys ja tarvittaessa puun tasapainotus Tasapainotus: Kun jossakin solmussa tasapainotekijän arvoksi tulee 2 tai -2, puun muotoa muutetaan tässä kohdassa rotaatioilla Rotaatioita on kahdenlaisia: yksinkertaisia rotaatioita kaksoisrotaatioita Molempia voidaan tehdä sekä vasemmalle että oikealle 9/18/02 260

261 Yksinkertainen rotaatio (single rotation) k1 right k2 k2 k1 left T3 T1 T1 T2 T2 T3 9/18/02 261

262 Kaksoisrotaatio (double rotation) k1 left-right k3 k2 k2 k1 k3 T4 T1 T1 T2 T3 T4 T2 T3 Kaksoisrotaatio voidaan ymmärtää myös kahtena yksinkertaisena rotaationa, jotka tehdään peräkkäin Rotaatiot säilyttävät puun avainten järjestyksen. 9/18/02 262

263 Se, kumpi rotaatio tehdään, määräytyy siitä, mihin haaraan epätasapainon aiheuttava lisäys on tullut Rotaatio tehdään alimmassa solmussa, jossa on epätasapainoa Jos lisäys on tullut ko. solmun vasemman- tai oikeanpuoleisimman lapsenlapsen alle, tehdään yksinkertainen rotaatio päinvastaiseen suuntaan Jos lisäys on tullut ko. solmun sisempään alipuuhun, tehdään kaksoisrotaatio, joka nostaa ko. alipuuta ylemmäs puussa AVL-puussa haku, lisäys ja poisto tehdään ajassa O(log N). Tasapainotus ja tasapainotekijöiden asetus hidastavat puun käsittelyä vakiotekijällä (vähäinen merkitys) 9/18/02 263

264 9.5.2 Punamusta puu Punamusta puu on binäärinen hakupuu, jossa on voimassa seuraavat säännöt 1) Jokainen solmu on joko punainen tai musta 2) Juuri on musta 3) Jos solmu on punainen, sen lapset ovat mustia 4) Jokainen polku juuresta NULL-pointteriin / Z-solmuun sisältää saman määrän mustia solmuja Usein käytetään määritelmää, jossa värit liitetään kaariin, esim. 1) Jokainen kaari on joko punainen tai musta 2) NULLiin / Z-solmuun johtavat kaaret ovat mustia 3) Millään polulla juuresta lehteen ei saa olla kahta peräkkäistä punaista kaarta 4) Jokainen polku juuresta NULLiin / Z-solmuun sisältää saman määrän mustia kaaria 9/18/02 264

265 Haku: Tapahtuu kuin binäärisessä hakupuussa Lisäys: (bottom-up menetelmä) Isäkaari tarkoittaa solmun yläpuolella olevaan kaarta (isästä solmuun) Haetaan alkion paikka puussa ja lisätään se uudeksi lehdeksi p. Lisätyn solmun isäkaari merkitään punaiseksi. Jos p:n isän t:n isäkaari on musta, ei tarvita muuta Jos t:n isäkaari on punainen, tarvitaan rotaatio, joka poistaa peräkkäiset punaiset kaaret. Rotaation jälkeen punaiset kaaret eivät ole enää peräkkäin. 9/18/02 265

266 Jos ennen lisäystä sekä t:n että sen sisaruksen v:n isäkaaret ovat punaisia, rotaatio ei auta. Silloin tehdään värien vaihto, jossa t:n isän u:n isäkaari muuttuu punaiseksi ja t:n ja v:n isäkaaret mustiksi. Tarvittaessa tasapainotusta jatketaan ylempänä puussa, jos u:n isän isäkaari on punainen. 9/18/02 266

267 Lisäys: (top-down menetelmä) Tasapainotus tehdään jo matkalla kohti lehteä, jonka alle uusi alkio lisätään Jos kohdataan solmu t, jonka lapsikaaret ovat punaisia, ne vaihdetaan mustiksi ja t:n isäkaari muuttuu punaiseksi Jos tällöin t:n isän u:n isäkaari on punainen, tehdään rotaatio Tilanne, jossa rotaation jälkeen olisi kaksi peräkkäistä punaista kaarta, on mahdoton, koska t:n isän u:n sisaren isäkaari ei voi olla punainen. Se on ehkäisty ennakolta. 9/18/02 267

268 Poisto: Voidaan toteuttaa samantyyppisten periaatteiden avulla sekä bottom-up että top-down -algoritmeina Punamustan puun korkeus on korkeintaan n. 2logN Haku, lisäys ja poisto voidaan toteuttaa ajassa O(log N). Kustannus 1 bitti / solmu 9/18/02 268

269 9.5.3 B-puu B-puu on tasapainotettu hakupuu, jossa yhdellä solmulla voi olla useita lapsia eli sen haarautumisaste (m) voi vaihdella muutamasta aina tuhansiin. Määritelmä: Juuri on joko lehti tai sillä on 2...m lasta Kaikilla sisäsolmuilla on (m div 2)+1... m lasta Kaikki lehdet ovat samalla syvyydellä Solmuissa on osoittimia varsinaisiin tietueisiin Esimerkkitapaus: puu (m=4) 9/18/02 269

270 Käsittelysäännöt: Haku: Sama idea kuin binäärisessä hakupuussa, mutta lavennettuna useampihaaraiseen puuhun Lisäys: 1) Haetaan uuden alkion paikka 2) Jos solmussa on tilaa, avain lisätään siihen 3) Jos solmu on täynnä (haun aikana), se jaetaan (split) kahdeksi solmuksi, joihin talletetaan: Toiseen pienet avaimet ja toiseen suuret Pienet ja suuret erottava arvo talletetaan isäsolmuun (kohta 2) 9/18/02 270

271 Jos juurikin joudutaan halkaisemaan, luodaan uusi juuri, jonka lapsiksi tulevat vanhan puolikkaat VAIN NÄIN PUUN KORKEUS VOI KASVAA! => Puu pysyy tasapainossa 9/18/02 271

272 Poisto: Melko monimutkainen toimenpide, jossa voidaan joutua myös siirtämään alkioita solmusta toiseen Jos solmuun jää liian vähän tietueita, täytyy etsiä solmu, jonka kanssa k.o. solmu voi sulautua Tällöin isäsolmusta häviää yksi osoitin, jne., voi johtaa juuren häviämiseen, jolloin puun korkeus pienenee 9/18/02 272

273 Ominaisuudet: haku ajassa O(log N) lisäys ja poisto: O(M log N) Todellinen hyöty B-puista saadaan levymuistitoteutuksissa M valitaan niin, että solmujen koko vastaa levyblokin kokoa Levyhakuja tarvitaan puun korkeuden verran 9/18/02 273

274 Eri versioita B + -puu: avaimia talletetaan vain lehtisolmuihin B*-puu: sisäsolmut vähintään 2/3-täynnä B link -puu, jossa samalla tasolla olevien lehtien ja sisäsolmujen välillä vaakasuorat linkit (level link) B-puu voidaan keskusmuistirakenteena toteuttaa punamustana puuna, esim puu: 9/18/02 274

275 Tietorakenteet ja ulkoiset muistit keskusmuisti ([Kilo-], Mega- ja Gigatavuja) kallis ja nopea (0.5-5 / MB) hierarkia: muisti, cache, rekisteri ulkoinen muisti (Giga- ja Teratavuja, [Peta-, Exa-]) hidas ja halpa (0,005-0,05 / MB) massamuistit hierarkia: raita (track, vrt. CD-levy), sivu (page, sektori) tyypillinen B-puu: ei mahdu kokonaan keskusmuistiin sivuhakujen määrä dominoi 9/18/02 275

276 9.5.4 B-puu ulkoisena hakurakenteena Jokainen solmu tallennetaan omalle levysivulle => Uuden solmun varaus helppoa Sisäsolmuissa on avainten lisäksi linkkitieto, mistä sivuilta lapset löytyvät Lehdissä on vain avaimia Lehtiä ei tarvitse merkitä erikseen, koska puun korkeus tunnetaan Sisäsolmut kannattaa hajauttaa eri levyille, jolloin hakuvarsista ei tule pullonkaulaa. 9/18/02 276

277 B-puu kannattaa toteuttaa rakenteena, jossa kaikki tietueet talletetaan lehtiin ja ylemmissä solmuissa on vain avainarvoja => Haarautumisastetta voidaan nostaa tuntuvasti Esim. Sisäsolmuissa M int = 1024, jolloin 2-tasolta on linkit jopa yli miljoonaan sivuun. Lehdissä M ext = tietueiden määrä / sivu B-puu on yleisesti käytössä tietokantarakenteiden toteutuksessa B-Puu sallii joustavat lisäykset ja nopean haun 9/18/02 277

278 9.6 Digitaaliset avaimet Etsintä perustuu suoraan avaimen esitysmuodon bitteihin, ei avainten keskinäiseen vertailuun A = S = E = R = C = H = I = N = Toteutus edellyttää tehokasta pääsyä bitti-informaatioon käsiksi 9/18/02 278

279 Jos avaimet tasaisesti jakautuneet, keskimääräinen tehokkuus O(log N) Worst case on bittien määrä Merkkijonoavaimet eivät ole hyviä, koska ne ovat hyvin epätasaisesti jakautuneet Menetelmä voidaan yleistää muissakin kantaluvuissa kuin 2 esitettyihin avaimiin 9/18/02 279

280 9.6.1 Digitaalinen hakupuu (digital search tree) Hakupuu, jossa haarautuminen tapahtuu avaimen bittien perusteella vasen = 0, oikea = 1 (tai päinvastoin) Jokainen taso alaspäin tarkoittaa seuraavaa bittiä Muutoin toiminta muistuttaa binääristä hakupuuta 9/18/02 280

281 Haku: 1. Aloitetaan juuresta ja eniten merkitsevästä bitistä 2. Jos avain on käsiteltävässä solmussa haku päättyy 3. Jos ei, edetään puussa nykyisen bitin perusteella 4. Siirrytään seuraavaan bittiin, jatketaan kohdasta 2 Lisäys: 1. Alkio lisätään aina puun lehdeksi 2. Haetaan lisättävän alkion paikka 3. Lisätään alkio lehtisolmun alle seuraavan bitin perusteella Poisto: Kuten binäärisessä hakupuussa Puussa ei voi olla duplikaatteja (käsitellään muutoin) 9/18/02 281

282 Luentotehtävä Jatka seuraavassa alkioiden lisäämistä digitaaliseen hakupuuhun. Alkiot A,B ja C on jo lisätty puuhun. Lisää seuraavaksi alkiot D,E,F,G,H,I,J,K,L ja M tässä järjestyksessä: C B A Alkioiden bittiavaimet: A:? H: B: I: C: J: D: K: E: L: F: M: G: /18/02 282

283 Ominaisuudet: Average case: O(log N) Worst case: O(b) Usein tasapainoisempi kuin vastaava binäärinen hakupuu 9/18/02 283

284 9.6.2 Radix search trie Digitaalisen hakupuun yhtenä puutteena on se, että siinä joudutaan vertailemaan koko avainta jokaisella askelella, vaikka eteneminen tapahtuu vain bittien perusteella. fi Idea: erotetaan etsintäpuu ja avaimet toisistaan fi Saadaan: Radix search trie : Hakupuussa on vain linkkejä bittien perusteella Tietueet ovat puun lehtinä Puun haarat ovat vain niin pitkiä, kuin on tarpeen avainten erottamiseksi toisistaan Puun muoto ei riipu avainten tallennusjärjestyksestä Vaatii toteutuksessa pääsyä käsiksi bitti-informaatioon 9/18/02 284

285 Haku: Aloitetaan juuresta ja eniten merkitsevästä bitistä Edetään bitti kerrallaan puussa alaspäin kääntyen vasempaan tai oikeaan haaraan, kunnes kohdataan puun lehti Katsotaan, onko alkio lehdessä Average case: O(log N) Worst case: O(b) 9/18/02 285

286 Lisäys: 1) Haetaan alkion paikka bittien perusteella 2) Jos löydetty paikka oli tyhjä, lisätään alkio tähän kohtaan puun lehdeksi 3) Jos paikassa oli lehti, tästä tulee puun sisäsolmu ja sen alle rakennetaan alipuu tai alipuut sen mukaan, että lehdessä ollut avain ja lisättävä avain eroavat toisistaan 4) Luodaan uudet lehtisolmut, joihin entisen 3)-lehden avain ja lisättävä avain talletetaan 9/18/02 286

287 Poisto: 1) Etsi poistettava avain 2) Poista kyseinen lehtisolmu Jos lähin sisarus on myös lehtisolmu, lyhennä puuta sen osalta, kunnes ko. solmu eroaa vain yhden bitin mittaisen matkan jostakin puun muusta haarasta 9/18/02 287

288 9.6.3 Variaatioita Polun pituutta voidaan pienentää, jos verrataan kerralla M bittiä. Puu koostuu silloin solmuista, joissa on 2 M haaraa Jos M suuri, puu on matala, mutta sen hyötysuhde on huono (paljon käyttämättömiä linkkejä) Ratkaisuna hybridirakenne, jossa lähellä juurta M 1 on suuri ja lehdissä M 2 on pieni 9/18/02 288

289 Patricia-puussa on ratkaistu radix search trien ongelma, että puussa voi olla pitkiä tyhjien linkkien ketjuja Solmuissa on tieto siitä, minkä bitin mukaan haarautuminen tapahtuu Lisäksi puussa on vain yhdenlaisia solmuja Avaimia talletetaan, paitsi lehtiin, myös puun sisäsolmuihin. Niihin viitataan niistä puun lehdistä, joihin haku päättyy ko. avaimen bittien perusteella Toimii hyvin myös pitkillä avaimilla, koska itse avain testataan vain kerran ja biteistäkin vain osa 9/18/02 289

290 Tehtäviä Talleta avaimet TIETORAKENNETEHTÄVÄT tässä järjestyksessä tyhjään puuhun, kun avaimia talletetaan puun kaikkiin solmuihin ja duplikaatit talletetaan aina vasemmalle. Käytä top-downtasapainotusta (solmujen jaot tapahtuvat ylhäältä alaspäin haun yhteydessä kuljettaessa 4-solmun läpi). Keskusmuistissa olevissa puurakenteissa yksi tapa tallettaa duplikaattiavaimet on se, että varsinaisen hakupuun solmuihin kukin avain talletetaan vain kerran ja solmusta lähtee linkitetty lista, johon duplikaatit talletetaan. Miten tätä rakennetta voitaisiin tehostaa, jos duplikaatteja on paljon (esim. jos varsinaisena avaimena on henkilön sukunimi ja listassa duplikaattitietueet on erotettu etunimen perusteella toisistaan)? 9/18/02 290

291 10 Hajautus 10.1 Yleistä 10.2 Hajautusfunktio (hash function) 10.3 Erillinen ketjutus (separate chaining, open hashing) 10.4 Avoin osoitus (open addressing, closed hashing) Lineaarinen kokeilu (linear probing) Neliöllinen kokeilu (quadratic probing) Kaksoishajautus (double hashing) 10.5 Erityiskysymyksiä Uudelleenhajautus (Rehashing) Ulkoinen etsintä (external searching) 10.6 Hakurakenteet valinnasta 9/18/02 291

292 10.1 Yleistä Jos avaimet ovat kokonaislukuja välillä 1-N, voidaan niitä käyttää suoraan hakutaulukon (koko N) indeksointiin. Hakuaika on O(1). Useimmiten avainavaruus on liian laaja pitkät kokonaisluvut merkkijonot Hajautus pyrkii muuntamaan tällaiset avaimet kokonaisluvuksi välille 1-N, jolloin tieto voidaan tallentaa taulukkoon ja hakea sieltä ajassa O(1) 9/18/02 292

293 Hajautus on kompromissi aika-tilavaatimusten suhteen: rajaton tila: avain indeksinä nopea haku, huono pakkaustiheys rajaton aika: tietueet peräkkäin, ei tietorakennetta hidas haku, hyvä pakkaustiheys 9/18/02 293

294 Hajautuksen toteuttamiseen tarvitaan kaksi asiaa: hajautusfunktio ja yhteentörmäysten käsittelymekanismi 1) Hajautusfunktio (hash function) muuntaa kaikki avainavaruuden arvot hajautustaulukon osoiteavaruuteen 1.. N (tai 0.. N tai 0.. (N-1)) Toteutettu yleensä aritmeettisilla laskutoimituksilla Ideaalinen hajautusfunktio palauttaisi eri osoitearvon kullekin eri avainarvolle. Käytännössä näin ei ole, vaan tarvitaan: 9/18/02 294

295 2) Yhteentörmäysten käsittelymekanismi (collision resolution) Kun hajautusfunktio tuottaa eri avaimille saman arvon, nämä tilanteet tulee erottaa toisistaan. Tähän on useita eri menetelmiä, mm. erillinen ketjutus (separate chaining) lineaarinen kokeilu (linear probing) neliöllinen kokeilu (quadratic probing) kaksoishajautus (double hashing) 9/18/02 295

296 10.2 Hajautusfunktio (hash function) Hyvä hajautusfunktio hajauttaa kaikki avainarvot tasaisesti osoiteavaruuteen Olennainen asia on se, että kaikkien avaimeen kuuluvien numeroiden tai merkkien tulisi vaikuttaa hajautusarvoon 9/18/02 296

297 Kokonaislukuavaimet: 1) Jos avain on kokonaisluku (k >> N), varsin hyvä funktio on h(k) = k % N N:n tulee olla alkuluku. Tämä on helpoin tapa varmistaa, että kokonaisluvun k jokainen bitti vaikuttaa tulokseen. 2) Vielä parempi idea on, että korotetaan avain neliöön ja otetaan keskeltä muutama numero: h(k) = trunc(k 2 /C) % N, jossa CN 2 k 2 (avaimet välillä 1-k) N:ksi kannattaa valita kahden potenssi 9/18/02 297

298 Merkkijonoavaimet: Merkkijono tulkitaan suurena kokonaislukuna ja käsitellään yleensä sopivina osina, esim. merkki kerrallaan 3) Yksinkertainen ajatus on tulkita merkit numeroina, laskea ne yhteen ja jakaa summa sopivalla luvulla char k[100]; int temp = 0; for (i = 0; i < key_length; i++) temp = temp + k[i]; h = temp % N; Ongelma on se, että merkkien numeroarvot ovat epätasaisesti jakautuneet välillä tai 0-255, ja näistäkin vain pieni osa on aktiivisesti käytössä 9/18/02 298

299 4) Otetaan kolme ensimmäistä kirjainta, tulkitaan ne 27-järjestelmän lukuna (27 erilaista kirjainta) ja muunnetaan ne 10-järjestelmään: temp = 729 * value(k[1]) + 27 * value(k[2]) + value(k[3]); h = temp % N; Oletus: Value palauttaa luvun välillä 0-26 Jos kirjaimet ovat satunnaisia, tässä on hyvä funktio. Käytännössä näin ei tietenkään ole. 9/18/02 299

300 5) Tulkitaan koko merkkijono kokonaislukuna ja lasketaan siitä % N N ei tietenkään saa olla 128 tai 256! Asia lasketaan inkrementaalisesti Hornerin säännöllä temp = 0; for (i = 0; i < key_length; i++) temp = ( (32*temp) + value(k[i]) ) % N; h = temp; Oletus: Funktio value palauttaa luvun välillä /18/02 300

301 6) Hajautusfunktioiden toteutuksia [Kenneth Oksanen, 2002] unsigned int hashf(const char } *buf, size_t len) { unsigned int h = 0; int i; for (i = 0; i < len; i++) { } h += buf[i]; h += h << 10; h ^= h >> 7; h += h << 3; h ^= h >> 11; h += h << 15; return h; unsigned int hashf(unsigned int key) { unsigned int h = 0xDEADBEEF; h = key & 0xFFFF; key >>= 16; h += h << 10; h ^= h >> 7; h += key & 0xFF; key >>= 8; h += h << 10; h ^= h >> 7; h += key; key >>= 8; h += h << 10; h ^= h >> 7; h += h << 3; h ^= h >> 11; h += h << 15; return h; } 9/18/02 301

302 10.3 Erillinen ketjutus (separate chaining, open hashing) Hajautustaulukko sisältää osoittimet listoihin, joihin yhteentörmänneet tietueet talletetaan Esimerkki: Hajautetaan alla oleva merkkijono 11 alkiota sisältävään taulukkoon käyttäen hajautusfunktiota k%11 Kirjainten numeroarvot ovat: A = 1, B = 2... K: A S E A R C H I N G E X A M P L E h(k): /18/02 302

303 k k % 11 A = 1 1 B = 2 2 C = 3 3 D = 4 4 E = 5 5 F = 6 6 G = 7 7 H = 8 8 I = 9 9 J = K = 11 0 L = 12 1 M = 13 2 N = 14 3 O = 15 4 P = 16 5 Q = 17 6 R = 18 7 S = 19 8 T = 20 9 U = V = 22 0 W = 23 1 X = 24 2 Y = 25 3 Z = /18/02 303

304 Hajautusrakenteen sisältö: O A M C E G H I A X N E R S A E L P Listat kannattaa pitää järjestyksessä Listojen pituus riippuu hajautusarvojen jakaumasta ja duplikaattien määrästä Keskimäärin se on M / N hyvällä hajautusfunktiolla (M hajautettua alkiota) N kannattaa valita esimerkiksi siten, että M / N 10 9/18/02 304

305 Haku: Laske hajautusfunktion arvo Etsi alkion paikka listasta Palauta alkio tai tyhjä, jos haku epäonnistui Lisäys ja poisto: Suoritetaan haku. Tehdään lisäys/poisto listaan. Rakenne ei rajoita talletettavan tiedon määrää. Jos se kasvaa runsaasti, toiminnot vähitellen hidastuvat. 9/18/02 305

306 10.4 Avoin osoitus (open addressing, closed hashing) Tietueet talletetaan suoraan hajautustaulukkoon hajautusfunktion osoittamaan paikkaan Vältetään dynaaminen muistinkäsittely Taulukon koko N suurempi kuin hajautettavien avainten määrä M Yhteentörmäysten käsittelyyn on useita eri menetelmiä, joissa tietueiden haku-/ sijoituspaikka lasketaan seuraavasti h i (k) = (hash(k) + f(i)) % N i = 0, 1, 2,... f(0) = 0 Haku yleensä erittäin nopeaa, ellei taulukko tule liian täyteen Jos taulukko täyttyy, uudelleen järjestely raskas toimenpide 9/18/02 306

307 Lineaarinen kokeilu (linear probing) Yhteentörmäysten sattuessa etsitään taulukosta järjestyksessä seuraavaa paikkaa, kunnes operaatio onnistuu tai epäonnistuu h i (k) = (hash(k) + i) % N i = 0, 1, 2,... Tyhjät paikat merkitään jollain sopivalla erikoisarvolla Haku: Laske hajautusfunktion arvo Jos paikka on jo käytössä, etsi taulukosta järjestyksessä eteenpäin, kunnes tietue löytyy tai tulee vastaan tyhjä paikka 9/18/02 307

308 Lisäys: Laske hajautusfunktion arvo Jos paikka on jo käytössä, etsi taulukosta järjestyksessä eteenpäin seuraava tyhjä paikka. Lisää alkio tähän Poisto: Hankalampi tilanne, koska syntyvä tyhjä paikka ei saa sotkea muuta rakennetta Ratkaisuna poistetun alkion paikalle asetetaan erikoisarvo (place holder), joka tulkitaan tyhjäksi lisäysoperaatiossa, mutta ei hakuoperaatiossa 9/18/02 308

309 Luentotehtävä: lineaarinen kokeilu Seuraavassa on aloitettu alkioiden hajauttaminen 19 paikkaiseen taulukkoon käyttäen hajautusfunktiona: h i (k) = (k + i) % 19, i = 0, 1, 2, ; f(0) = 0 K: A S E A R C H I N G E X A M P L E h(k): i: Tehtävä: Jatka hajauttamalla loput avaimet S A A E /18/02 309

310 k k % 19 A = 1 1 B = 2 2 C = 3 3 D = 4 4 E = 5 5 F = 6 6 G = 7 7 H = 8 8 I = 9 9 J = K = L = M = N = O = P = Q = R = S = 19 0 T = 20 1 U = 21 2 V = 22 3 W = 23 4 X = 24 5 Y = 25 6 Z = /18/02 310

311 Lineaarisen kokeilun ongelmana on se, että taulukon täyttyessä syntyy kasaumia (cluster), jotka pidentävät hakuketjua merkittävästi Esimerkin kohdassa...e X A syntyy kasauma 5-10 talletettaessa merkki X Kasaumien todennäköisyyttä pyritään pienentämään muissa menetelmissä 9/18/02 311

312 Neliöllinen kokeilu (quadratic probing) Sama pääperiaate kuin lineaarisessa kokeilussa, mutta yhteentörmäyksen sattuessa seuraavat kokeilut tehdään alkioissa: h i (k) = (hash(k) + i 2 ) % N, i = 0, 1, 2,... Estää em. primäärisen kasautumisen Periaatteessa esiintyy sekundääristä kasautumista (merkitys vähäinen) Taulukon koon täytyy olla alkuluku, muuten kokeilujen määrä voi jäädä aivan liian pieneksi Uusia alkiota voidaan varmuudella lisätä vain, jos taulukon täyttöaste on alle puolet 9/18/02 312

313 Kaksoishajautus (double hashing) Sama pääperiaate kuin edellisissä, mutta yhteentörmäyksen sattuessa seuraavat kokeilut tehdään alkioissa: h i (k) = (hash(k) + i*hash 2 (k)) % N, i = 0, 1, 2,... hash 2 ei saa koskaan saada arvoa 0 hyvä valinta on: hash 2 (k) = R - (k % R) R on alkuluku, < N Kaksoishajautus ratkaisee primäärisen kasautumisen ongelman 9/18/02 313

314 Sekundääristä kasautumista esiintyy, mutta sen merkitys on vähäinen Kahden hajautusfunktion laskeminen kuormittaa laskemista enemmän kuin neliöllisessä kokeilussa 9/18/02 314

315 k k%17 1+(k MOD 11) A = B = C = D = E = F = G = H = I = J = K = L = M = N = O = P = Q = R = S = T = U = V = W = X = Y = Z = /18/02 315

316 10.5 Erityiskysymyksiä 1) Mikä on taulukon oikea koko? fi jos se arvioidaan väärin, joudutaan hajauttamaan uudelleen (rehashing), mikä on raskas operaatio, O(N) 2) Jos tiedon määrä vaihtelee suuresti, joudutaan kenties tarpeettomasti hajauttamaan uudelleen tai täyttöaste voi jäädä liian alhaiseksi fi ei sovellu näihin tilanteisiin 3) Jos aineiston koko on suuri, rakenne ei mahdu muistiin fi ulkoinen etsintä 4) Jos täyttöaste a kasvaa lähelle arvoa 1,operaatioiden kesto kasvaa nopeasti: a = M / N 9/18/02 316

317 Pienillä arvoilla: onnistunut haku: 1 + M / N epäonnistunut haku: 1 + M / 2N Suurilla täyttöasteilla operaatioiden vaatima aika on muotoa: a 9/18/02 317

318 Uudelleenhajautus (Rehashing) Taulukon täyttyessä luodaan uusi, kaksi kertaa isompi taulukko, johon vanhan taulukon tiedot hajautetaan Voidaan suorittaa myös toiseen suuntaan, jos taulukosta tulee poistojen jälkeen liian harva Keskimääräinen kustannus O(1) yhtä operaatiota kohti, mutta saattaa viivästää yksittäistä tapahtumaa huomattavasti 9/18/02 318

319 Ulkoinen etsintä (external searching) Ulkoisessa etsinnässä tieto on osin tai kokonaan talletettu oheismuistiin => I/O-aika dominoi => Laitteistotekniikka voi asettaa lisärajoituksia Ulkoisilla hakumenetelmillä on hyvin suuri käytännön merkitys, koska tietokannat yleensä talletetaan levylle. Tavoitteena on minimoida levyhakujen määrä => Peräkkäishaku levyllä mieletöntä 9/18/02 319

320 Tärkeitä menetelmiä ovat: Indeksoitu hierarkkinen rakenne B-puut Laajennettava hajautus sisäisten menetelmien loogisia laajennuksia eroavat suorituskyvyltään lähinnä lisäysten joustavuuden suhteen 9/18/02 320

321 Laitteistotekniikan vaikutukset: 1) Sarjasaantilaitteet (mg-nauha, kasettinauha) Ainoastaan peräkkäishaku on mahdollista, joten mitään erityismenetelmiä ei ole 9/18/02 321

322 2) Suorasaantilaitteet (levy) Oletetaan yksinkertainen toimintamalli: Käytössä on useita levyjä Levyllä tieto on jaettu sivuille, joihin voi viitata mielivaltaisessa järjestyksessä Kullekin sivulle mahtuu useita tietueita Todellisuus on monimutkaisempi: virtuaalimuisti cache rinnakkaisuuden hallinta Jatkossa tarkastellaan vain levyllä olevia tallennusrakenteita 9/18/02 322

323 Indeksoitu hierarkkinen rakenne (indexed sequential access) Peräkkäishakumenetelmä, jonka apuna on yksi tai useampia tasoja hakemistoja (index) 1) Tieto on järjestyksessä ja jaettu erillisille sivuille 2) Kullakin levyllä on hakemistosivuja, joissa on tieto kaikista sivuista, mitä rakenteeseen kuuluu: sivun sisältämät alkiot (alku, loppu) sivun osoite levyllä 3) Keskusmuistissa voi olla master-hakemisto (master index), johon on talletettu tieto, mitä tietoja on kullakin levyllä 9/18/02 323

324 Esimerkki: Merkkijono EXTERNALSEARCHINGEXAMPLE tallennettuna tähän rakenteeseen: Jokaisella levyllä hakemistosivu on ensimmäisenä, sitten datasivut Hakemistossa on tieto käytössä olevien sivujen osoitteista ja sivuilla olevien avainten minimi- ja maksimiarvoista Samaa avainta voi olla usealla sivulla 9/18/02 324

325 0 1 2 Disk 1: *1C2E AAAC EEEE Disk 2: E1I2N EGHI LLMN Disk 3: N1R2X NPRR STXX Master index:*1e2n3x Tietueen hakuun tarvitaan tavallisesti vain kaksi levyhakua (3 tai 4 hakua, jos avain esiintyy hakemistoissa) Päivittäminen erittäin kankeaa, koska kaikki hakemistot voidaan joutua rakentamaan uudelleen 9/18/02 325

326 Laajennettu hajautus (exdendible hashing) Vain 2 hakua Tehokas lisääminen Tieto tallennettu sivuille, jotka täyttyessään jakaantuvat (vrt. B-puu) Sivut löydetään indeksin avulla (vrt. hierarkinen indeksoitu haku) Apuna avainten digitaaliset ominaisuudet (bitit) 9/18/02 326

327 Esimerkki: Talletetaan alla oleva merkkijono tietorakenteeseen tällä menetelmällä: EXTERNALSEARCHINGEXAMPLE 4 elementtiä / sivu kirjaimilla 5-bittinen koodi 9/18/02 327

328 Alkion haku: 1) Laske avaimen d:n ensimmäisen bitin perusteella oikea hakemistosivu 2) Hae hakemistosta sivun osoite ja sen jälkeen sivu levyltä muistiin 3) Muistissa hae tieto peräkkäishaulla, binäärihaulla tms. 9/18/02 328

329 Uuden alkion lisääminen: 3 eri tapausta: 1)Lisäys sivulle, jolla on tilaa 2)Lisäys sivulle, jolla ei ole tilaa ja hakemiston päivitys 3)Lisäys sivulle, jolla ei ole tilaa ja hakemiston kahdennus (harvinaista) 9/18/02 329

330 Hakemisto Sisältää vain avaimet ja osoittimet levylle, ei dataa => Sivulle mahtuu entryjä enemmän kuin varsinaisia tietueita. Esimerkissä suhde = 8 / 4, käytännössä suurempi Kun hakemisto ei mahdu yhdelle sivulle, tarvitaan master index, joka toimii samalla periaatteella ja sijaitsee keskusmuistissa => Tieto löytyy kahdella haulla 9/18/02 330

331 Ongelmia 1) Epäsymmetrinen avainjakauma => Hakemiston koko kasvaa tarpeettomasti Esim. 32-bittiset avaimet: Joillakin sivuilla erotteluun tarvitaan 20 bittiä, joillakin riittää 5 bittiä => Hakemistossa 2 20 entryä ja paljon päällekkäisiä osoittimia Ratkaisu: Hajautetaan avaimet ennen hakua => Jakauma tasoittuu => Yhteentörmäyksistä ei ongelmaa => Nimitys: Exdendible hashing 9/18/02 331

332 2)Liikaa samoja avaimia Perusalgoritmi ei toimi, jos samoja avaimia on enemmän, kuin sivulle mahtuu => Tarvitaan virittelyä YHTEENVETO 1)Tehokas haku, vain 2 levyhakua 2)Joustava päivitys 9/18/02 332

333 10.6 Hakurakenteen valinnasta Hakurakenne voidaan implementoida monella tavalla. Asiaan liittyviä näkökulmia ovat: tiedon määrä talletetaanko rakenne keskusmuistiin vai massamuistiin? hakuihin, lisäyksiin ja poistoihin liittyvät aikavaatimukset lisäysten ja poistojen määrä tarvitaanko erityyppisiä hakuavaimia? operaatiot, joissa avaimia käsitellään järjestyksessä? menetelmän monimutkaisuus 9/18/02 333

334 Yhteenveto sisäisten menetelmien tehokkuusluvuista, kun haku onnistuu (epäonnistunut haku on hitaampaa W(N) A(N) Linkitetty lista (järj.) N N/2 Binäärihaku taulukosta log N Interp.haku taulukosta log log N tasaisella jakaumalla Binäärinen hakupuu N 1.38log N puu O(log N) AVL-puu 1.4logN logn Puna-musta puu 2log N log N Erillinen ketjutus N N / M Lineaarinen kokeilu (a = 0.9)N 5 Kaksoishajautus (a = 0.99) N 5 Digitaalinen hakupuu b log N Radix search trie b log N 9/18/02 334

335 Muita näkökulmia sovellettavuuteen Linkitetty lista Yksinkertainen toteuttaa Pienille sovelluksille (N < 20) Kannattaa pitää järjestyksessä Voidaan järjestää myös aktiviteetin mukaan Binäärihaku / interpolaatiohaku taulukosta Staattisille sovelluksille, joissa vähän lisäyksiä ja poistoja Interpolointi vie aikaa, joten sitä ei kannata käyttää aivan pienillä aineistoilla 9/18/02 335

336 Binäärinen hakupuu Suhteellisen yksinkertainen Sopii moniin sovelluksiin, joissa ei ehdottomia aikavaatimuksia Voi käyttäytyä huonosti varsin tavallisilla aineistoilla Tasapainotetut puut Sovelluksiin, joissa aikavaatimus on ehdoton Melko monimutkaisia toteuttaa Sopeutuvat hyvin dynaamisiin tilanteisiin 9/18/02 336

337 Hajautus Sopii moniin sovelluksiin ja on yleensä hyvin tehokas hakumenetelmä Hajautusta EI kannata käyttää: aikakriittisissä sovelluksissa (ilman virittelyä) jos tarvitaan mahdollisuus käsitellä tietoa järjestyksessä jos tiedon määrää ei voida ennakoida ollenkaan 9/18/02 337

338 Hajautusmenetelmän valinnasta: Erillinen ketjutus Yksinkertaisin toteuttaa ja joustaa hyvin tiedon määrän vaihdellessa Listat voi järjestää myös aktiviteetin mukaan itseorganisaation avulla Listat voi korvata puilla, mikä parantaa worst casea. Avoin osoitus Taulukon täyttöasteen tulisi olla alle 0.5 Lineaarista kokeilua ei kannata käyttää Neliöllinen kokeilu on tehokkaampi kuin kaksoishajautus 9/18/02 338

339 Digitaaliset hakupuut Hyvät worst case- ja average case- tehokkuusluvut Toteutus edellyttää tehokasta pääsyä käsiksi bittiinformaatioon Melko monimutkaisia toteuttaa Pitkille avaimille kannattaa käyttää vain Patricia-puuta Useita erilaisia muunnelmia, joihin kannattaa perehtyä, jos hakee todella tehokasta rakennetta. Ulkoiset hakumenetelmät Käytännön valinta on B-puu tai laajennettu hajautus B-puusta on erilaisia virityksiä, joihin kannattaa perehtyä etukäteen 9/18/02 339

340 Tehtäviä Ketjutetussa hajautuksessa uudelleenhajautus puolta suurempaan hajautustauluun voidaan tehdä, kun rakenteessa on esim. kaksi kertaa niin paljon avaimia kuin mikä on taulun koko. Milloin uudelleenhajautus puolta pienempään tauluun kannattaa tällöin tehdä? Miten uudelleenhajautus kannattaa toteuttaa avoimen osoituksen menetelmissä? Hajautuksen perusmenetelmät eivät säilytä avainten järjestystä, jolloin haluttaessa luetella tietyllä välillä olevat avaimet joudutaan käymään läpi koko rakenne. Pohdi, miten toteuttaisit hajautusalgoritmit ja - rakenteen, jos tämä toimenpide pitäisi pystyä tekemään selvästi nopeammin (ei kuitenkaan välttämättä ajassa O(M), jossa M on haettavien avainten lukumäärä). 9/18/02 340

341 11. VERKOT ( graphs ) 11.1 Yleistä 11.2 Terminologiaa 11.3 Verkon esittäminen 11.4 Verkon läpikäyntialgoritmit (graph traversal) 11.5 Painotetut verkot (weighted graphs) 11.6 Pienin virityspuu (minimun spanning tree) 9/18/02 341

342 11.7 Lyhin reitti (shortest path) 11.8 Verkon yhtenäisyys (graph connectivity) 11.9 Suunnatut verkot Joukot ja verkot 9/18/02 342

343 11.1 Yleistä Verkko on kokoelma solmuja (vertex), joita yhdistää toisiinsa joukko särmiä (edge). Särmiä kutsutaan myös kaariksi (arc). Solmuilla on nimi ja niihin voi liittyä dataa A B C D E 9/18/02 343

344 Särmät yksilöidään niiden päätesolmujen avulla. Särmiin voi liittyä paino (weight) Verkon määrittely ei riipu siitä, miten se on esitetty tai piirretty. Usein maantieteellinen esitys on selkein Verkkojen sovelluksia: Lentoyhtiön aikataulu Maantieverkko Projektin aikataulu Putkistokaavio Virtapiiri Tietoliikenneverkko 3D malli kappaleesta 9/18/02 344

345 Eräitä verkkoihin liittyviä ongelmia: Onko reittiä pisteestä A pisteeseen B? Mikä on lyhin reitti pisteestä A pisteeseen B, kun lasketaan särmät? Mikä on halvin reitti pisteestä A pisteeseen B, kun lasketaan särmiin liittyvät kustannukset? Mikä on pienin kustannus, jolla verkon eri solmut voidaan yhdistää toisiinsa? Voidaanko verkko levittää tasoon? 9/18/02 345

346 11.2 Terminologiaa Solmujen väliset yhteydet: Polku (path) on solmujen lista, joka johtaa solmusta x solmuun y, siten että listan peräkkäisten solmujen välillä on särmä Yksinkertainen polku (simple path) ei kulje saman solmun kautta kahdesti Silmukka (cycle) on yksinkertainen polku, paitsi että sen alku- ja loppusolmut ovat samat 9/18/02 346

347 Jos verkon särmiä voi edetä vain tiettyyn suuntaan, kyseessä on suunnattu verkko (directed graph, network). Muutoin verkko on suuntaamaton (undirected) Esimerkki: Projektin aikataulu. Mikä vaihe seuraa mitäkin? Jos verkon särmiin liittyy jokin kustannus, on kyseessä painotettu verkko (weighted graph) Esimerkki: Maantieverkko + etäisyydet 9/18/02 347

348 Verkon yhtenevyys: Suuntaamaton verkko on yhtenäinen (connected), jos jokaisesta solmusta on polku kaikkiin muihin solmuihin Epäyhtenäinen verkko koostuu yhtenäisistä osaverkoista Esimerkki: Suomen maantieverkko on epäyhtenäinen, koska tietä pitkin ei pääse kaikkiin kaupunkeihin, esim. Maarianhaminaan. Välissä tarvitaan muunlaisia yhteyksiä. 9/18/02 348

349 Puut: Puu (tree) on yhtenäinen suuntaamaton verkko, jossa ei ole silmukoita fi Puussa kahden solmun välillä on vain yksi (yksinkertainen) polku fi Jos puuhun lisätään särmä muodostuu silmukka Metsä (forest) on epäyhtenäinen verkko, jonka yhtenäiset osat ovat puita 9/18/02 349

350 Virityspuu (spanning tree) on verkon yhtenäinen aliverkko, joka sisältää kaikki verkon solmut, mutta vain niin paljon särmiä kuin tarvitaan muodostamaan niistä puu Virityspuu ei ole yksikäsitteinen Esimerkki: Pienin määrä johtoa, mikä tarvitaan yhdistämään tietty joukko kytkentäpisteitä 9/18/02 350

351 Verkon särmien määrä: Puu, jossa on V solmua, sisältää V-1 särmää Suuntaamattomassa verkossa, jossa on V solmua, särmien määrä E voi olla: 0 E V(V-1)/2 Verkko, jossa on kaikki mahdolliset särmät, on täydellinen (complete) Verkkoa voidaan sanoa tiheäksi (dense) tai harvaksi (sparse). Rajakynnyksenä esimerkiksi V log V särmää. 9/18/02 351

352 11.3 Verkon esittäminen Verkko voidaan esittää tietorakenteena usealla eri tavalla: 1) Yhteysmatriisi (adjacency matrix) Oletetaan, että verkon solmut kuvataan kokonaislukuina 1..V Esimerkkiverkko voidaan esittää nyt matriisimuodossa, jossa alkio 1 kuvaa särmän olemassaoloa ja alkio 0, että särmää ei ole. A B C 9/18/02 352

353 Sovitaan, että alkiosta on yhteys itseensä Matriisissa puolet alkioista on tarpeettomia, mutta täydellistä matriisia on helpompi käsitellä algoritmisesti Yhteysmatriisi soveltuu tiheille verkoille Suunnatussa verkossa matriisi ei ole symmetrinen 9/18/02 353

354 2) Seuraajaluettelo (adjacency structure) Jokaisen solmun seuraajalistassa (adjacency list) luetellaan kaikki ne solmut, joihin on särmä tästä solmusta Esimerkkiverkon seuraajaluettelo: A B C A: C B: C C: A, B 9/18/02 354

355 A A: F, C, B, G B C G B: A C: A D E D: F, E E: G,F, D F: A, E, D F G: E, A H: I I: H H I 9/18/02 355

356 Relaatioista Olkoon verkko G = (V,E), jossa V on verkon solmujen joukko ja E on verkon kaarien joukko E Õ V x V Binäärirelaatio E on refleksiivinen, jos kaikille x Œ V pätee (x,x) Œ E symmetrinen, jos (x,y) Œ E Æ (y,x) Œ E transitiivinen, jos (x,y) Œ E ja (y,z) Œ E Æ (x,z) Œ E x y z Relaatio, joka on refleksiivinen, symmetrinen sekä transitiivinen on ekvivalenssirelaatio vrt = tai < luonnollisille luvuille 9/18/02 356

357 11.4 Verkon läpikäyntialgoritmit (graph traversal) Algoritmien tavoitteena on käydä läpi verkon kaikki solmut Tätä varten verkon ajatellaan koostuvan kolmesta osasta: 1) Puu (tree) Solmut, joissa on jo käyty 2) Reunus (fringe) Solmut, joiden etäisyys puusta on yksi särmä 3) Tuntematon (unseen) Muut solmut, jotka ovat siis kauempana puusta 9/18/02 357

358 Verkko (sen yhtenäinen osa) käydään läpi valitsemalla reunukselta jokin solmu, liittämällä se puuhun ja siirtämällä sen naapurit reunukseen Eri algoritmit poikkeavat siinä, mikä solmu reunukselta valitaan Lopputuloksena saadaan verkon hakupuu 9/18/02 358

359 Depth-first haku (depth-first search, DFS) Menetelmässä valitaan aina reunuksen uusin solmu ja liitetään se puuhun Reunus toteutetaan pinona: Pinon päällimmäinen solmu liitetään puuhun Tämän vierekkäiset alkiot työnnetään pinoon, elleivät ne jo ole siellä Pinon lisäksi ylläpidetään aputaulukoita visited[] ja parent[] 9/18/02 359

360 Rekursiivinen DFS Rekursiivinen toteutus käy verkon kaikki solmut läpi seuraavalla tavalla: 1. Vieraile (visit) solmussa 2. Tutki, onko seuraajalistan mukaisissa solmuissa vierailtu 3. Jos jossakin listan solmussa ei ole käyty, kutsu DFS:ää tälle solmulle rekursiivisen algoritmin ja pinoalgoritmin DFSpuut ovat erilaisia 9/18/02 360

361 DFS algoritmin tehokkuus on: Seuraajalistalle O(V + E) Yhteysmatriisille O(V 2 ) DFS-algoritmilla voidaan ratkaista eräitä tärkeitä verkkoihin liittyviä ongelmia, mm. Onko verkko yhtenäinen? Mitkä ovat verkon yhtenäiset osaverkot? Onko verkossa silmukoita? 9/18/02 361

362 Breadth-first-haku (breath-first search, BFS) Menetelmässä valitaan aina reunuksen vanhin solmu ja liitetään se puuhun Reunus toteutetaan jonona: Jonon ensimmäinen solmu liitetään puuhun Tämän vierekkäiset alkiot laitetaan jonon loppuun, elleivät ne jo ole jonossa Tuloksena saadaan BFS-puu 9/18/02 362

363 BFS ratkaisee eräitä verkko-ongelmia Mikä on lyhin reitti pisteestä A pisteeseen B, jos lasketaan vain kuljettujen särmien määrää? Mitkä ovat lyhimmät reitit kaikkiin solmuihin lähtien solmusta A, jos lasketaan vain kuljettujen särmien määrää? DFS:n ja BFS:n perusero: DFS etenee verkossa niin pitkälle kuin mahdollista ja peruuttaa sitten etsiessään uutta etenemishaaraa BFS etenee verkossa leveällä rintamalla säilyttäen saman etäisyyden lähtöpisteeseen 9/18/02 363

364 Reunuksen esittämiseen käytetty tietorakenne voidaan yleistää prioriteettijonoksi, jollain saadaan erilaisia PFS-hakuja (priority-first search) Mikä on lyhin reitti pisteestä A pisteeseen B painotetussa verkossa? Mitkä ovat lyhimmät reitit kaikkiin solmuihin lähtien solmusta A, jos verkko on painotettu? Mikä on painotetun verkon pienin virityspuu? 9/18/02 364

365 11.5 Painotetut verkot (weighted graphs) Painotetussa verkossa jokaiseen särmään liittyy kustannus, esim. Aikataulu: hinta tai matkan pituus Projektikaavio: osatyön kestoaika Sähkökytkentä: johdon pituus Algoritmeissa käytetään usein termiä etäisyys, vaikka kysymys on painosta Yleensä painot ovat positiivisia. Negatiivisten painojen esiintyminen voi mutkistaa algoritmeja merkittävästi 9/18/02 365

366 Yleisimmät ongelmat: 1.Mikä on lyhin reitti pisteestä A pisteeseen B? 2.Mikä on (painotetun) verkon pienin virityspuu? 9/18/02 366

367 Painot voidaan esittää yhteysmatriisissa hyvin helposti A B 2 3 C Lävistäjäalkiot on selkeintä pitää nollina Seuraajaluettelossa esitykseen täytyy liittää painotiedot: A: (C, 2) B: (C, 3) C: (A, 2), (B, 3) 9/18/02 367