T /253 Tietorakenteet ja algoritmit T/Y

Koko: px
Aloita esitys sivulta:

Download "T-106.250/253 Tietorakenteet ja algoritmit T/Y"

Transkriptio

1 SIS LLYS 1. JOHDANTO 2. OHJELMOINNIN PERUSTEIDEN KERTAUS 3. ALGORITMITEORIAN PERUSAJATUKSIA 4. LINEAARISET PERUSTIETORAKENTEET 5. ALGORITMIANALYYSI 6. PUURAKENTEET 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

2 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 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

3 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 Ê 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š

4 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 * * 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

5 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 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

6 Exponentiaalinen menetelmš, sovelletaan suoraan mššritelmšš rekursiivisesti F3 F4 F5 F3 F6 F2 F2 F1 F2 F3 F4 F1 F2 F1 Laskettaessa F6:n arvoa, lasketaan: F0 F5 F4 F3 F2 F1 1 kerran 2 kertaa 3 kertaa 5 kertaa 8 kertaa F2 F1 F1 F0 F1 F0 F1 F0 F1 F0 Koska pštee, ettš F100 Å F 100, missš F Å 1.618, seuraa, ettš F100:n laskemiseen tarvitaan luokkaa operaatiota OHJELMOINNIN PERUSTEIDEN LYHYT KERTAUS 2.1 YleistŠ 2.2 Taulukko 2.3 Linkitetyn listan (linked list) toteutus 2.4 Tapausesimerkki Polynomi 2.5 Rekursio

7 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 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

8 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 K q r 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 Alkion poistaminen kšy helposti, kun on kšsillš osoitin poistettavaa alkiota edeltšvššn alkioon: (C) (Java) r = q->next; q->next = r->next; free(r); p r = q.next; q.next = r.next; K2.2 q r EnsimmŠisen alkion poistaminen on erikoistapaus: r = p; r = p; p = p->next; p = p.next; free(r); 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

10 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; 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 K2.3 r = malloc(sizeof(node)); r->data = 99; r->next = q->next; q->next = r; r q

11 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 */ 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;

12 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 */ 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 */

13 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 */ Lista voidaan toteuttaa myšs taulukon avulla Tarvitaan 2 taulukkoa; data[0..n] next[0..n] arvot osoittimet data next 0 head 4 z 1 T 6 I 5 L 3 S 2 6 A 1 p h e a d L I S T A z K2.7

14 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; 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;

15 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! 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!!

16 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) = 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! =

17 Rekursion neljš kultaista sššntšš: Perustapaukset (ratkaistavissa ilman rekursiota) Edistyminen (liikutaan perustapausta kohti) Oletus (kaikki rekursiiviset kutsut toimivat) VŠltŠ turhaa tyštš (jokainen tapaus ratkaistaan vain kerran) 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;

18 Esim. Fibonacci-luvut: int fibonacci(int n) { if (n<=1) return 1; else return fibonacci(n-1)+fibonacci(n-2); Ê {Rikkoo neljšttš sššntšš F4 F5 F3 F6 F3 F4 F2 Parempi toteuttaa eirekursiivisena F3 F2 F2 F1 F2 F1 F1 F0 F2 F1 F1 F0 F1 F0 F1 F F1 F0 35 Esim. Hanoin tornit: SiirrŠ renkaat toiseen tappiin yksi kerrallaan niin, ettš isompi rengas ei koskaan ole pienemmšn pššllš: Mis tä Minne Via K

19 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 Via K2.17 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

20 3. ALGORITMITEORIAN PERUSAJATUKSIA 3.1 Algoritmit suhteessa tietorakenteisiin 3.2 Algoritmien vertailu 3.3 Algoritmien toteutus 3.4 Abstraktit tietotyypit 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

21 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) 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;

22 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; Tietorakenteiden kšsitteellinen luokittelu Luokitteluun on erilaisia lšhestymistapoja: MitkŠ seuraavista ovat tietorakenteita? Bitti Boolean Integer Taulukko Tuple Double Verkko

23 Atominen tieto vs. rakenteinen tieto Riippuu abstraktiotasosta Staattinen vs. dynaaminen tietorakenne MikŠ seuraavista on staattinen, mikš dynaaminen tietorakenne? Taulukko Tietue Dynaaminen taulukko Linkitetty lista Verkko BinŠŠripuu Muistinvaraus kiinteš tai dynaaminen Alkion saavutettavuus: MitŠ eroa? Taulukko Tietue Linkitetty lista BinŠŠripuu Verkko Alkion paikka voidaan laskea vakioajassa tai sitten ei

24 Abstraktiotaso MitŠ eroa? BinŠŠripuu JŠsennyspuu BinŠŠrinen hakupuu Taulukko 1 * A B C D G Hajautustaulukko Talletusrakenne vai semanttinen rakenne: Rakenne voi olla puhdas talletusrakenne tai abstrakti tietotyyppi, jolla on jokin semantiikka 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?)

25 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 ABSTRAKTIT TIETOTYYPIT (ADT, Abstract data type) Usein algoritmit esitetššn pseudokielellš ( la Pascal) ja jštetššn toteutuksen pienimmšt yksityiskohdat avoimiksi Algoritmin perusajatusta on helpompi ymmšrtšš, kun ei tarvitse kiinnittšš huomiota ohjelmointikielen syntaksiin Kuvaus on kieliriippumaton 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)

26 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š 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)

27 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 VASTUU EHEYDEN NOUDATTAMISESTA J OHJELMOIJALLE OliokielissŠ abstraktit tietotyypit mššritellššn yleensš rajapintoina ja toteutetaan luokkina (Java, C++) 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)

28 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 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

29 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 vapaasti. => 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 LINKITETYN LISTAN T RKEIN RAJOITUS Alkioita voi kšydš lšpi vain yksitellen, ts. alkioihin ei voi viitata suoraan (vrt. taulukko) TŠrkeimmŠt operaatiot ovat: TULOSTUS HAKU LIS YS POISTO P IVITYS TYHJ N LISTAN LUOMINEN N:NNEN ALKION PALAUTTAMINEN ONKO LISTA TYHJ? É

30 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 K 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š) Empty palauttaa tiedon siitš, onko pino tyhjš

31 Jonokuri LIFO (Last In - First Out) Kaikki pino-operaatiot voidaan toteuttaa vakioajassa (ei riipu pinon koosta) Pino voidaan implementoida eri tavoin, mm. taulukon avulla tai linkitettynš listana Toteutus taulukkona, apuna pino-osoitin, joka osoittaa pinon pššllimmšiseen alkioon: empty: (sp == -1) Taulukkototeutuksessa pinolle varattu tila voi loppua K sp Toteutus listana: top K2.14 push: liitš uusi alkio listan alkuun pop: poista ja palauta alkio listan alusta empty: (top == NULL)

32 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 yksinkertainen tarkistusohjelma luetaan merkki kerrallaan tutkitaan vain sulkumerkkejš alkusulku asetetaan pinoon kohdattaessa loppusulku popataan pinosta pššllimmšinen sulku ü jos pino on tyhjš tai sulku on vššršn tyyppinen => virhe Ohjelman lopussa pinon tulee olla tyhjš

33 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š? Periaate: 1) Muunnetaan lauseke pinon avulla postfix-muotoon: * 6 * 7 + * 2) Evaluoidaan postfix-lauseke pinon avulla

34 INFIX-POSTFIX-muunnos pinon avulla Luetaan Infix-lauseketta merkki kerrallaan ( => asetetaan pinoon (PUSH) *,+ => ensin POPataan ja tulostetaan operaattoreita, joilla on sama tai parempi prioriteetti, sen jšlkeen asetetaan vastaluettu operaattori pinoon. SulkumerkkiŠ Õ(Õ ei koskaan POPata ) => POPataan ja tulostetaan operaattoreita, kunnes lšytyy alkusulku, joka myšs POPataan, mutta ei tulosteta Kun input loppuu, POPataan ja tulostetaan loput operaattorit Esim. Muunnetaan lauseke 5*((9+8)*4*6+7) muotoon 598+4*6*7+* Input Pino Output 5 5 * * ( *( ( *(( *((+ 8 8 ) *( + * *(* 4 4 * *(* * *(+ * 7 7 ) * + tyhjš *

35 POSTFIX-lausekkeen arvo voidaan laskea pinon avulla Esim. lauseke 598+4*6*7+* Input Pino * * * 2075 empty Muita pinon sovelluksia: 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

36 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 Empty kertoo, onko jono tyhjš Jonokuri FIFO (First In First Out) Jono voidaan implementoida eri tavoin, mm. taulukon avulla tai linkitettynš listana. Usein implementoidaan sirkulaarisena taulukkona (indeksit lasketaan modulo N) Jonon toteutus sirkulaarisena taulukkona last fi rst MAX first osoittaa jonon alkuun Jono[0.. MAX-1] put get last osoittaa 1. vapaaseen paikkaan jonossa yksi tyhjš paikka, jota ei kšytetš

37 Put: Jono[last] =...; last = (last+1) % MAX; if (last == first) error; {Jono ei voi olla tyhjš! Get: Palauta Jono[first]; first = (first+1) % MAX; First = Jono[first]; Empty = (last == first); Jonon toteutus listana struct node { datatype data; struct node *next; ; Ê typedef struct node * Queue; first last K

38 Put: temp = (Queue) malloc(sizeof(struct node)); temp->data =...; temp->next = NULL; last->next = temp; last = temp; Get: temp = first; first = first->next; return (temp); First = return(first); Empty = return (first == null); 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

39 4.6 PAKKA (deque) = Jonon ja pinon yhdistelmš Alkioita voidaan asettaa rakenteen molempiin pšihin, ja myšs ottaa pois Vrt. korttipakka kšdessš 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?

40 5.1 Johdanto MIKSI tarvitaan algoritmianalyysiš? Ohjelman resurssitarpeiden ennustaminen CPU-aika muistitila Algoritmien keskinšinen vertailu Sopivan algoritmin valitseminen MITEN algoritmeja voi analysoida? 1. Empiirinen mittaaminen ja ekstrapolointi Ongelmia: 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

41 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?ó 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šš

42 1 : 5.3 Algoritmien luokittelu kiinteš (vakio) suoritusaika esim. lausekkeen evaluointi log N : logaritminen esim. puolitushaku N 2 : N 3 : nelišllinen esim. sijoituslajittelu kuutiollinen esim. matriisitulo N : lineaarinen esim. lineaarinen haku N*log N : "N log N" esim. Quicksort 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 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 MerkitŠŠn: T(N) = O( f(n) ) TŠmŠ on syštteestš ja toteutuksesta riippumaton ylšraja laskentaan kuluva aika c f(n) T(n) f(n) ongelman koko HUOM! N 0 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 <

43 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! 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)

44 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! 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)

45 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) 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š

46 t c 3 N cn 3 c 0 N 2 T(N) = 7 7+N/ 2 K3.3 c 2 sqrt(n) N T(N) = O(N 2 ) T(N) = O(N 3 ) T(N) = O(N) T(N) = Ω(sqrt(N)) T(N) = Ω(N) T(N) = θ(n) T(N) = o(n 2 ) T(N) = o(n 3 ) Big-Oh on tšrkein tunnusluku 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 )

47 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 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

48 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) on noin N 2 / 2 = O(N 2 ) 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)

49 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) T(2 k ) / 2 k = 0 / 1 + k T(N) = T(2 k ) = k 2 k = N log N = O(N log N) 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š)

50 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 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 => f(n) on tiukka raja, ehkš T(N) = θ( f(n) ) Jos c lšhestyy nollaa => 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) )

51 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 KŠsitteistšŠ Puurakenteen perusmalli on sukupuu ylšs A juuri (root) alas B C G isš (parent) D H L lapsi (child)

52 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šš 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)

53 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 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

54 Usein kšytetty merkintš: Solmut palloja Alipuut kolmioita U P U K4.2 Alipuu Alipuu 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

55 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 Puiden esitystapoja Dynaaminen tietorakenne Ê struct node { char key; struct node *left; struct node *right; ; typedef struct node * link; left key right Lehtisolmujen linkit voidaan asettaa arvoon NULL

56 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 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 K

57 Samoin voidaan mššritellš erityinen z-solmu, johon tyhjšt alipuut eli lehtisolmujen linkit viittaavat (Sedgewick: Algorithms) : z-solmuja on vain yksi kappale z-solmun linkit viittaavat z-solmuun itseensš Head K4.5 Kaikki kerralla kšytšssš olevat dynaamiset tietorakenteet voivat kšyttšš samaa z-solmua Z 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

58 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 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

59 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; ; Ê typedef struct node * link; A A S E R T E k M P L E a[k] A S A M P L E T R E E X dad[k] 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 E R S T M P L E E struct node { char key; struct node *First_child; struct node *Next_sibling; ; Ê typedef struct node * link; => Esitysmuoto palautuu binššripuuksi!

60 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) 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 E 120

61 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 M P L S E A A R T E E Ò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

62 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); 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);

63 EsijŠrjestys pinon 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); TasojŠrjestyksen implementointi kšy helposti jonorakenteen avulla: void traverse_levelorder(link t) { put(t); do { t = get; Ê if (t!= NULL) { visit(t); put(t->left); put(t->right); while (!queue_empty); Yleisen puun lšpikšynnissš em. algoritmit yleistetššn A E R E EsijŠrjestys E A A S R T M P L E E A S T M P L E JŠlkijŠrjestys 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

64 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 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.ó

65 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 + * 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 + *

66 JŠsennyspuun luominen: Luetaan postfix-lauseketta merkki kerrallaan * 7 + * Operandi => TehdŠŠn tšstš uuden puun juuri Osoitin uuteen puuhun asetetaan pinoon Operaattori => TehdŠŠn tšstš uuden puun juuri Oikeaksi lapseksi popataan pinon pššllimmšinen Vasemmaksi lapseksi seuraava Osoitin uuteen puuhun pinoon Esim: K4.10a

67 * + * * * 7 + +

68 * 5 * + * 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

69 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

Tietorakenteet ja algoritmit Johdanto Lauri Malmi / Ari Korhonen

Tietorakenteet ja algoritmit Johdanto Lauri Malmi / Ari Korhonen Tietorakenteet ja algoritmit Johdanto Lauri Malmi / Ari 1 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:

Lisätiedot

Tietorakenteet ja algoritmit - syksy 2015 1

Tietorakenteet ja algoritmit - syksy 2015 1 Tietorakenteet ja algoritmit - syksy 2015 1 Tietorakenteet ja algoritmit - syksy 2015 2 Tietorakenteet ja algoritmit Johdanto Ari Korhonen Tietorakenteet ja algoritmit - syksy 2015 1. JOHDANTO 1.1 Määritelmiä

Lisätiedot

Algoritmianalyysin perusteet

Algoritmianalyysin perusteet Tietorakenteet ja algoritmit Algoritmianalyysin perusteet Ari Korhonen 1 5. ALGORITMIANALYYSI 5.1 Johdanto 5.2 Tavoitteet 5.3 Algoritmien luokittelu 5.4 Kertaluokkamerkinnät (Big Oh Notation) 5.5 Kertaluokkamerkinnöillä

Lisätiedot

A274101 TIETORAKENTEET JA ALGORITMIT

A274101 TIETORAKENTEET JA ALGORITMIT A274101 TIETORAKENTEET JA ALGORITMIT PUURAKENTEET, BINÄÄRIPUU, TASAPAINOTETUT PUUT MIKÄ ON PUUTIETORAKENNE? Esim. Viereinen kuva esittää erästä puuta. Tietojenkäsittelytieteessä puut kasvavat alaspäin.

Lisätiedot

1.1 Pino (stack) Koodiluonnos. Graafinen esitys ...

1.1 Pino (stack) Koodiluonnos. Graafinen esitys ... 1. Tietorakenteet Tietorakenteet organisoivat samankaltaisten olioiden muodostaman tietojoukon. Tämä järjestys voidaan saada aikaan monin tavoin, esim. Keräämällä oliot taulukkoon. Liittämällä olioihin

Lisätiedot

A274101 TIETORAKENTEET JA ALGORITMIT

A274101 TIETORAKENTEET JA ALGORITMIT A274101 TIETORAKENTEET JA ALGORITMIT PERUSTIETORAKENTEET LISTA, PINO, JONO, PAKKA ABSTRAKTI TIETOTYYPPI Tietotyyppi on abstrakti, kun se on määritelty (esim. matemaattisesti) ottamatta kantaa varsinaiseen

Lisätiedot

REKURSIO. Rekursiivinen ohjelma Kutsuu itseään. Rekursiivinen rakenne. Rakenne sisältyy itseensä. Rekursiivinen funktio. On määritelty itsensä avulla

REKURSIO. Rekursiivinen ohjelma Kutsuu itseään. Rekursiivinen rakenne. Rakenne sisältyy itseensä. Rekursiivinen funktio. On määritelty itsensä avulla REKURSIO Rekursiivinen ohjelma Kutsuu itseään Rekursiivinen rakenne Rakenne sisältyy itseensä Rekursiivinen funktio On määritelty itsensä avulla Esim. Fibonacci-luvut: X(i) = X(i-1) + X(i-2), X(0) = X(1)

Lisätiedot

Tietorakenteet ja algoritmit. Kertaus. Ari Korhonen

Tietorakenteet ja algoritmit. Kertaus. Ari Korhonen Tietorakenteet ja algoritmit Kertaus Ari Korhonen 1.12.2015 Tietorakenteet ja algoritmit - syksy 2015 1 Presemosta: 12. Kertaus» Mitkä tekijät, miten ja miksi vaiku1avat algoritmien nopeuteen» Rekursiohistoriapuut

Lisätiedot

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

9/18/02 1. Tietorakenteet ja algoritmit Y. Syksy Dipoli T T-106.253 Tietorakenteet ja algoritmit Y Syksy 2002 - Dipoli 9/18/02 1 Korhonen, A., Malmi, L. Tietorakenteet ja algoritmit / Kurssikuvaus 1. Kurssikuvaus 1.1 Esitiedot 1.2 Tavoitteet 1.3 Opetuksen järjestelyt

Lisätiedot

Lineaariset perustietorakenteet

Lineaariset perustietorakenteet Tietorakenteet ja algoritmit Lineaariset perustietorakenteet Ari Korhonen 15.9.2015 Tietorakenteet ja algoritmit Y 1 2. TIETORAKENTEIDEN TOTEUTUS- PERIAATTEITA Peruskäsitteitä pieni kertaus ohjelmoinnin

Lisätiedot

Algoritmit 1. Luento 3 Ti Timo Männikkö

Algoritmit 1. Luento 3 Ti Timo Männikkö Algoritmit 1 Luento 3 Ti 17.1.2017 Timo Männikkö Luento 3 Algoritmin analysointi Rekursio Lomituslajittelu Aikavaativuus Tietorakenteet Pino Algoritmit 1 Kevät 2017 Luento 3 Ti 17.1.2017 2/27 Algoritmien

Lisätiedot

Algoritmit 2. Luento 2 To Timo Männikkö

Algoritmit 2. Luento 2 To Timo Männikkö Algoritmit 2 Luento 2 To 14.3.2019 Timo Männikkö Luento 2 Tietorakenteet Lineaarinen lista, binääripuu Prioriteettijono Kekorakenne Keko-operaatiot Keon toteutus taulukolla Algoritmit 2 Kevät 2019 Luento

Lisätiedot

Algoritmien suunnittelumenetelmiä

Algoritmien suunnittelumenetelmiä Tietorakenteet ja algoritmit Algoritmien suunnittelumenetelmiä Ari Korhonen 24.9.2015 Tietorakenteet ja algoritmit 1 Algoritmien suunnittelumenetelmiä Lineaariset talletusrakenteet: taulukko, linkitetty

Lisätiedot

Algoritmit 2. Luento 2 Ke Timo Männikkö

Algoritmit 2. Luento 2 Ke Timo Männikkö Algoritmit 2 Luento 2 Ke 15.3.2017 Timo Männikkö Luento 2 Tietorakenteet Lineaarinen lista, binääripuu Prioriteettijono Kekorakenne Keko-operaatiot Keon toteutus taulukolla Algoritmit 2 Kevät 2017 Luento

Lisätiedot

Hakupuut. tässä luvussa tarkastelemme puita tiedon tallennusrakenteina

Hakupuut. tässä luvussa tarkastelemme puita tiedon tallennusrakenteina Hakupuut tässä luvussa tarkastelemme puita tiedon tallennusrakenteina hakupuun avulla voidaan toteuttaa kaikki joukko-tietotyypin operaatiot (myös succ ja pred) pahimman tapauksen aikavaativuus on tavallisella

Lisätiedot

Tietorakenteet ja algoritmit Puurakenteet Ari Korhonen

Tietorakenteet ja algoritmit Puurakenteet Ari Korhonen Tietorakenteet ja algoritmit Puurakenteet ri Korhonen 13.10.2015 Tietorakenteet ja algoritmit 1 7. PUURKNTT 7.1 Käsitteistöä 7.2 Binääripuu (binary tree) 7.3 Puiden esitys- ja toteutustapoja 7.4 Puussa

Lisätiedot

3. Hakupuut. B-puu on hakupuun laji, joka sopii mm. tietokantasovelluksiin, joissa rakenne on talletettu kiintolevylle eikä keskusmuistiin.

3. Hakupuut. B-puu on hakupuun laji, joka sopii mm. tietokantasovelluksiin, joissa rakenne on talletettu kiintolevylle eikä keskusmuistiin. 3. Hakupuut Hakupuu on listaa tehokkaampi dynaamisen joukon toteutus. Erityisesti suurilla tietomäärillä hakupuu kannattaa tasapainottaa, jolloin päivitysoperaatioista tulee hankalampia toteuttaa mutta

Lisätiedot

TIETORAKENTEET JA ALGORITMIT

TIETORAKENTEET JA ALGORITMIT TIETORAKENTEET JA ALGORITMIT Timo Harju 1999-2004 1 typedef link List; /* Vaihtoehtoisia nimiä */ typedef link Stack; /* nodepointterille */ typedef link Queue typedef struct node Node; /* itse nodelle

Lisätiedot

Pinot, jonot, yleisemmin sekvenssit: kokoelma peräkkäisiä alkioita (lineaarinen järjestys) Yleisempi tilanne: alkioiden hierarkia

Pinot, jonot, yleisemmin sekvenssit: kokoelma peräkkäisiä alkioita (lineaarinen järjestys) Yleisempi tilanne: alkioiden hierarkia Pinot, jonot, yleisemmin sekvenssit: kokoelma peräkkäisiä alkioita (lineaarinen järjestys) Yleisempi tilanne: alkioiden hierarkia Kukin alkio (viite) talletettuna solmuun (node) vastaa paikan käsitettä

Lisätiedot

Sisällys. 18. Abstraktit tietotyypit. Johdanto. Johdanto

Sisällys. 18. Abstraktit tietotyypit. Johdanto. Johdanto Sisällys 18. bstraktit tietotyypit Johdanto abstrakteihin tietotyyppeihin. Pino ja jono. Linkitetty lista. Pino linkitetyllä listalla toteutettuna. 18.1 18.2 Johdanto Javan omat tietotyypit ovat jo tuttuja:

Lisätiedot

3. Binääripuu, Java-toteutus

3. Binääripuu, Java-toteutus 3. Binääripuu, Java-toteutus /*-------------------------------------------------------------/ / Rajapinta SearchTree: binäärisen hakupuun käsittelyrajapinta / / Metodit: / / void insert( Comparable x );

Lisätiedot

811312A Tietorakenteet ja algoritmit II Perustietorakenteet

811312A Tietorakenteet ja algoritmit II Perustietorakenteet 811312A Tietorakenteet ja algoritmit 2017-2018 II Perustietorakenteet Sisältö 1. Johdanto 2. Pino 3. Jono 4. Lista 811312A TRA, Perustietorakenteet 2 II.1. Johdanto Tietorakenne on tapa, jolla algoritmi

Lisätiedot

18. Abstraktit tietotyypit 18.1

18. Abstraktit tietotyypit 18.1 18. Abstraktit tietotyypit 18.1 Sisällys Johdanto abstrakteihin tietotyyppeihin. Pino ja jono. Linkitetty lista. Pino linkitetyllä listalla toteutettuna. 18.2 Johdanto Javan omat tietotyypit ovat jo tuttuja:

Lisätiedot

Pino S on abstrakti tietotyyppi, jolla on ainakin perusmetodit:

Pino S on abstrakti tietotyyppi, jolla on ainakin perusmetodit: Pino (stack) Pino: viimeisenä sisään, ensimmäisenä ulos (LIFO, Last In, First Out) -tietorakenne kaksi perusoperaatiota: alkion lisäys pinon päälle (push), ja päällimmäisen alkion poisto (pop) Push(alkio)

Lisätiedot

ALGORITMIT 1 DEMOVASTAUKSET KEVÄT 2012

ALGORITMIT 1 DEMOVASTAUKSET KEVÄT 2012 ALGORITMIT 1 DEMOVASTAUKSET KEVÄT 2012 1.1. (a) Jaettava m, jakaja n. Vähennetään luku n luvusta m niin kauan kuin m pysyy ei-negatiivisena. Jos jäljelle jää nolla, jaettava oli tasan jaollinen. int m,

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Rekursio Rekursion käyttötapauksia Rekursio määritelmissä Rekursio ongelmanratkaisussa ja ohjelmointitekniikkana Esimerkkejä taulukolla Esimerkkejä linkatulla listalla Hanoin

Lisätiedot

Algoritmit 2. Luento 7 Ti Timo Männikkö

Algoritmit 2. Luento 7 Ti Timo Männikkö Algoritmit 2 Luento 7 Ti 4.4.2017 Timo Männikkö Luento 7 Joukot Joukko-operaatioita Joukkojen esitystapoja Alkiovieraat osajoukot Toteutus puurakenteena Algoritmit 2 Kevät 2017 Luento 7 Ti 4.4.2017 2/26

Lisätiedot

Tehtävän V.1 ratkaisuehdotus Tietorakenteet, syksy 2003

Tehtävän V.1 ratkaisuehdotus Tietorakenteet, syksy 2003 Tehtävän V.1 ratkaisuehdotus Tietorakenteet, syksy 2003 Matti Nykänen 5. joulukuuta 2003 1 Satelliitit Muunnetaan luennoilla luonnosteltua toteutusta seuraavaksi: Korvataan puusolmun p kentät p. key ja

Lisätiedot

Algoritmit 1. Luento 8 Ke Timo Männikkö

Algoritmit 1. Luento 8 Ke Timo Männikkö Algoritmit 1 Luento 8 Ke 1.2.2017 Timo Männikkö Luento 8 Järjestetty binääripuu Solmujen läpikäynti Binääripuun korkeus Binääripuun tasapainottaminen Graafit ja verkot Verkon lyhimmät polut Fordin ja Fulkersonin

Lisätiedot

Algoritmit 1. Demot Timo Männikkö

Algoritmit 1. Demot Timo Männikkö Algoritmit 1 Demot 2 1.-2.2.2017 Timo Männikkö Tehtävä 1 (a) Ei-rekursiivinen algoritmi: laskesumma(t, n) sum = t[0]; for (i = 1; i < n; i++) sum = sum + t[i]; return sum; Silmukka suoritetaan n 1 kertaa

Lisätiedot

815338A Ohjelmointikielten periaatteet 2015-2016. Harjoitus 5 Vastaukset

815338A Ohjelmointikielten periaatteet 2015-2016. Harjoitus 5 Vastaukset 815338A Ohjelmointikielten periaatteet 2015-2016. Harjoitus 5 Vastaukset Harjoituksen aiheena ovat aliohjelmat ja abstraktit tietotyypit sekä olio-ohjelmointi. Tehtävät tehdään C-, C++- ja Java-kielillä.

Lisätiedot

4 Tehokkuus ja algoritmien suunnittelu

4 Tehokkuus ja algoritmien suunnittelu TIE-20100 Tietorakenteet ja algoritmit 52 4 Tehokkuus ja algoritmien suunnittelu Tässä luvussa pohditaan tehokkuuden käsitettä ja esitellään kurssilla käytetty kertaluokkanotaatio, jolla kuvataan algoritmin

Lisätiedot

Muuttujien roolit Kiintoarvo cin >> r;

Muuttujien roolit Kiintoarvo cin >> r; Muuttujien roolit Muuttujilla on ohjelmissa eräitä tyypillisiä käyttötapoja, joita kutsutaan muuttujien rooleiksi. Esimerkiksi muuttuja, jonka arvoa ei muuteta enää kertaakaan muuttujan alustamisen jälkeen,

Lisätiedot

Lyhyt kertaus osoittimista

Lyhyt kertaus osoittimista , syksy 2007 Kertausta Luento 10 12.10.2007 Syksy 2007 1 Lyhyt kertaus osoittimista char *p; /* char, int, jne ilmoittavat, minkä tyyppisiä */ Keskusmuisti int *q; /* olioita sisältäviin muistilohkoihin

Lisätiedot

Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PushFront(x): lisää tietoalkion x jonon eteen

Kaksiloppuinen jono D on abstrakti tietotyyppi, jolla on ainakin seuraavat 4 perusmetodia... PushFront(x): lisää tietoalkion x jonon eteen Viimeksi käsiteltiin pino: lisäys ja poisto lopusta jono: lisäys loppuun, poisto alusta Pinon ja jonon yleistävä tietorakenne: kaksiloppuinen jono alkion lisäys/poisto voidaan kohdistaa jonon alkuun tai

Lisätiedot

Rakenteiset tietotyypit Moniulotteiset taulukot

Rakenteiset tietotyypit Moniulotteiset taulukot C! Rakenteiset tietotyypit Moniulotteiset taulukot 22.2.2018 Agenda Rakenteiset tietotyypit Vilkaisu 6. kierroksen tehtäviin Moniulotteiset taulukot Esimerkki Seuraava luento to 8.3. Ilmoittautuminen ohjelmointikokeeseen

Lisätiedot

Koe ma 1.3 klo 16-19 salissa A111, koeaika kuten tavallista 2h 30min

Koe ma 1.3 klo 16-19 salissa A111, koeaika kuten tavallista 2h 30min Koe Koe ma 1.3 klo 16-19 salissa A111, koeaika kuten tavallista 2h 30min Kokeessa saa olla mukana A4:n kokoinen kaksipuolinen käsiten tehty, itse kirjoitettu lunttilappu 1 Tärkeää ja vähemmäntärkeää Ensimmäisen

Lisätiedot

Algoritmit 1. Luento 4 Ke Timo Männikkö

Algoritmit 1. Luento 4 Ke Timo Männikkö Algoritmit 1 Luento 4 Ke 18.1.2017 Timo Männikkö Luento 4 Tietorakenteet Pino Pinon toteutus Jono Jonon toteutus Lista Listaoperaatiot Algoritmit 1 Kevät 2017 Luento 4 Ke 18.1.2017 2/29 Pino Pino, stack,

Lisätiedot

1 Puu, Keko ja Prioriteettijono

1 Puu, Keko ja Prioriteettijono TIE-20100 Tietorakenteet ja algoritmit 1 1 Puu, Keko ja Prioriteettijono Tässä luvussa käsitellään algoritmien suunnitteluperiaatetta muunna ja hallitse (transform and conquer) Lisäksi esitellään binääripuun

Lisätiedot

Algoritmit 1. Luento 2 Ke Timo Männikkö

Algoritmit 1. Luento 2 Ke Timo Männikkö Algoritmit 1 Luento 2 Ke 11.1.2017 Timo Männikkö Luento 2 Algoritmin esitys Algoritmien analysointi Suoritusaika Asymptoottinen kertaluokka Peruskertaluokkia NP-täydelliset ongelmat Algoritmit 1 Kevät

Lisätiedot

A274101 TIETORAKENTEET JA ALGORITMIT

A274101 TIETORAKENTEET JA ALGORITMIT A274101 TIETORAKENTEET JA ALGORITMIT ALGORITMIEN ANALYYSISTÄ 1.ratkaisu Laskentaaika hakkeri - optimoitu ALGORITMIANALYYSIÄ hyvä algoritmi hakkeri -optimoitu hyvä algoritmi Tehtävän koko Kuva mukailtu

Lisätiedot

Tieto- ja tallennusrakenteet

Tieto- ja tallennusrakenteet Tieto- ja tallennusrakenteet Sisältö Tyyppi, abstrakti tietotyyppi, abstraktin tietotyypin toteutus Tallennusrakenteet Taulukko Linkitetty rakenne Abstraktit tietotyypit Lista (Puu) (Viimeisellä viikolla)

Lisätiedot

2) Aliohjelma, jonka toiminta perustuu sivuvaikutuksiin: aliohjelma muuttaa parametrejaan tai globaaleja muuttujia, tulostaa jotakin jne.

2) Aliohjelma, jonka toiminta perustuu sivuvaikutuksiin: aliohjelma muuttaa parametrejaan tai globaaleja muuttujia, tulostaa jotakin jne. Proseduurit Proseduuri voi olla 1) Funktio, joka palauttaa jonkin arvon: real function sinc(x) real x sinc = sin(x)/x... y = sinc(1.5) 2) Aliohjelma, jonka toiminta perustuu sivuvaikutuksiin: aliohjelma

Lisätiedot

Algoritmit 1. Luento 7 Ti Timo Männikkö

Algoritmit 1. Luento 7 Ti Timo Männikkö Algoritmit 1 Luento 7 Ti 31.1.2017 Timo Männikkö Luento 7 Järjestetty binääripuu Binääripuiden termejä Binääripuiden operaatiot Solmun haku, lisäys, poisto Algoritmit 1 Kevät 2017 Luento 7 Ti 31.1.2017

Lisätiedot

Tietorakenteet, laskuharjoitus 3, ratkaisuja

Tietorakenteet, laskuharjoitus 3, ratkaisuja Tietorakenteet, laskuharjoitus 3, ratkaisuja 1. (a) Toistolauseen runko-osassa tehdään yksi laskuoperaatio, runko on siis vakioaikainen. Jos syöte on n, suoritetaan runko n kertaa, eli aikavaativuus kokonaisuudessaan

Lisätiedot

Algoritmit 2. Luento 4 To Timo Männikkö

Algoritmit 2. Luento 4 To Timo Männikkö Algoritmit 2 Luento 4 To 21.3.2019 Timo Männikkö Luento 4 Hajautus Yhteentörmäysten käsittely Avoin osoitteenmuodostus Hajautusfunktiot Puurakenteet Solmujen läpikäynti Algoritmit 2 Kevät 2019 Luento 4

Lisätiedot

811312A Tietorakenteet ja algoritmit III Lajittelualgoritmeista

811312A Tietorakenteet ja algoritmit III Lajittelualgoritmeista 811312A Tietorakenteet ja algoritmit 2016-2017 III Lajittelualgoritmeista Sisältö 1. Johdanto 2. Pikalajittelu 3. Kekolajittelu 4. Lajittelualgoritmien suorituskyvyn rajoista 811312A TRA, Lajittelualgoritmeista

Lisätiedot

AVL-puut. eräs tapa tasapainottaa binäärihakupuu siten, että korkeus on O(log n) kun puussa on n avainta

AVL-puut. eräs tapa tasapainottaa binäärihakupuu siten, että korkeus on O(log n) kun puussa on n avainta AVL-puut eräs tapa tasapainottaa binäärihakupuu siten, että korkeus on O(log n) kun puussa on n avainta pohjana jo esitetyt binäärihakupuiden operaatiot tasapainotus vie pahimmillaan lisäajan lisäys- ja

Lisätiedot

Tietorakenteet, laskuharjoitus 6,

Tietorakenteet, laskuharjoitus 6, Tietorakenteet, laskuharjoitus, 23.-2.1 1. (a) Kuvassa 1 on esitetty eräät pienimmistä AVL-puista, joiden korkeus on 3 ja 4. Pienin h:n korkuinen AVL-puu ei ole yksikäsitteinen juuren alipuiden keskinäisen

Lisätiedot

Algoritmit 2. Luento 4 Ke Timo Männikkö

Algoritmit 2. Luento 4 Ke Timo Männikkö Algoritmit 2 Luento 4 Ke 22.3.2017 Timo Männikkö Luento 4 Hajautus Yhteentörmäysten käsittely Avoin osoitteenmuodostus Hajautusfunktiot Puurakenteet Solmujen läpikäynti Algoritmit 2 Kevät 2017 Luento 4

Lisätiedot

Tieto ja sen osoite (3) Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Osoitinmuuttujat. Tieto ja sen osoite (5)

Tieto ja sen osoite (3) Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Osoitinmuuttujat. Tieto ja sen osoite (5) Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Muuttujat Tietorakenteet Kontrolli Optimointi Tarkistukset 1 Tieto ja sen osoite (3) X DC LOAD, =X LOAD R2, X int x =; symbolin X arvo muuttujan X arvo

Lisätiedot

Kysymyksiä koko kurssista?

Kysymyksiä koko kurssista? Kysymyksiä koko kurssista? Lisää kysymyksesi osoitteessa slido.com syötä event code: #8777 Voit myös pyytää esimerkkiä jostain tietystä asiasta Vastailen kysymyksiin luennon loppupuolella Tätä luentoa

Lisätiedot

Algoritmit 1. Luento 6 Ke Timo Männikkö

Algoritmit 1. Luento 6 Ke Timo Männikkö Algoritmit 1 Luento 6 Ke 25.1.2017 Timo Männikkö Luento 6 Järjestetty lista Listan toteutus dynaamisesti Linkitetyn listan operaatiot Vaihtoehtoisia listarakenteita Puurakenteet Binääripuu Järjestetty

Lisätiedot

Java-kielen perusteet

Java-kielen perusteet Java-kielen perusteet Tunnus, varattu sana, kommentti Muuttuja, alkeistietotyyppi, merkkijono, literaalivakio, nimetty vakio Tiedon merkkipohjainen tulostaminen 1 Tunnus Java tunnus Java-kirjain Java-numero

Lisätiedot

A274101 TIETORAKENTEET JA ALGORITMIT

A274101 TIETORAKENTEET JA ALGORITMIT A274101 TIETORAKENTEET JA ALGORITMIT GRAAFITEHTÄVIÄ JA -ALGORITMEJA Lähteet: Timo Harju, Opintomoniste Keijo Ruohonen, Graafiteoria (math.tut.fi/~ruohonen/gt.pdf) GRAAFIN LÄPIKÄYMINEN Perusta useimmille

Lisätiedot

Tiraka, yhteenveto tenttiinlukua varten

Tiraka, yhteenveto tenttiinlukua varten Tiraka, yhteenveto tenttiinlukua varten TERMEJÄ Tietorakenne Tietorakenne on tapa tallettaa tietoa niin, että tietoa voidaan lisätä, poistaa, muokata ja hakea. Tietorakenteet siis säilövät tiedon niin,

Lisätiedot

lähtokohta: kahden O(h) korkuisen keon yhdistäminen uudella juurella vie O(h) operaatiota vrt. RemoveMinElem() keossa

lähtokohta: kahden O(h) korkuisen keon yhdistäminen uudella juurella vie O(h) operaatiota vrt. RemoveMinElem() keossa Kekolajittelu Prioriteettijonolla toteutettu keko InsertItem ja RemoveMinElem: O(log(n)) Lajittelu prioriteettijonolla: PriorityQueueSort(lajiteltava sekvenssi S) alusta prioriteettijono P while S.IsEmpty()

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Taulukon edut Taulukon haitat Taulukon haittojen välttäminen Dynaamisesti linkattu lista Linkatun listan solmun määrittelytavat Lineaarisen listan toteutus dynaamisesti linkattuna

Lisätiedot

811312A Tietorakenteet ja algoritmit Kertausta kurssin alkuosasta

811312A Tietorakenteet ja algoritmit Kertausta kurssin alkuosasta 811312A Tietorakenteet ja algoritmit 2017-2018 Kertausta kurssin alkuosasta II Perustietorakenteet Pino, jono ja listat tunnettava Osattava soveltaa rakenteita algoritmeissa Osattava päätellä operaatioiden

Lisätiedot

Miten käydä läpi puun alkiot (traversal)?

Miten käydä läpi puun alkiot (traversal)? inääripuut ieman lisää aidon binääripuun ominaisuuksia lehtisolmuja on yksi enemmän kuin sisäsolmuja inääripuut tasolla d on korkeintaan 2 d solmua pätee myös epäaidolle binääripuulle taso 0: 2 0 = 1 solmu

Lisätiedot

8. Lajittelu, joukot ja valinta

8. Lajittelu, joukot ja valinta 8. Lajittelu, joukot ja valinta Yksi tietojenkäsittelyn klassisista tehtävistä on lajittelu (järjestäminen) (sorting) jo mekaanisten tietojenkäsittelylaitteiden ajalta. Lajiteltua tietoa tarvitaan lukemattomissa

Lisätiedot

1 Erilaisia tapoja järjestää

1 Erilaisia tapoja järjestää TIE-20100 Tietorakenteet ja algoritmit 1 1 Erilaisia tapoja järjestää Käsitellään seuraavaksi järjestämisalgoritmeja, jotka perustuvat muihin kuin vertailuun alkioiden oikean järjestyksen saamiseksi. Lisäksi

Lisätiedot

Algoritmit 2. Luento 8 To Timo Männikkö

Algoritmit 2. Luento 8 To Timo Männikkö Algoritmit 2 Luento 8 To 4.4.2019 Timo Männikkö Luento 8 Algoritmien analysointi Algoritmien suunnittelu Rekursio Osittaminen Rekursioyhtälöt Rekursioyhtälön ratkaiseminen Master-lause Algoritmit 2 Kevät

Lisätiedot

4. Joukkojen käsittely

4. Joukkojen käsittely 4 Joukkojen käsittely Tämän luvun jälkeen opiskelija osaa soveltaa lomittuvien kasojen operaatioita tuntee lomittuvien kasojen toteutuksen binomi- ja Fibonacci-kasoina sekä näiden totetutusten analyysiperiaatteet

Lisätiedot

Muita linkattuja rakenteita

Muita linkattuja rakenteita 1 Muita linkattuja rakenteita Johdanto Aikaisemmin on käsitelty listan, jonon ja pinon toteutus dynaamisesti linkattuna rakenteena. Dynaamisella linkkauksella voidaan toteuttaa mitä moninaisimpia rakenteita.

Lisätiedot

Tietueet. Tietueiden määrittely

Tietueet. Tietueiden määrittely Tietueet Tietueiden määrittely Tietue on tietorakenne, joka kokoaa yhteen eri tyyppistä tietoa yhdeksi asiakokonaisuudeksi. Tähän kokonaisuuteen voidaan viitata yhteisellä nimellä. Auttaa ohjelmoijaa järjestelemään

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Elegantti toteutus funktiolle insert_to_list_end Alkion lisäys sisällön mukaan järjestettyyn listaan (insert_to_list) Linkatun listan yleisyys alkiotyypin suhteen source-tasolla

Lisätiedot

Tietorakenteet, laskuharjoitus 7, ratkaisuja

Tietorakenteet, laskuharjoitus 7, ratkaisuja Tietorakenteet, laskuharjoitus, ratkaisuja. Seuraava kuvasarja näyttää B + -puun muutokset lisäysten jälkeen. Avaimet ja 5 mahtuvat lehtisolmuihin, joten niiden lisäys ei muuta puun rakennetta. Avain 9

Lisätiedot

Algoritmit 1. Demot Timo Männikkö

Algoritmit 1. Demot Timo Männikkö Algoritmit 1 Demot 2 7.-8.2.2018 Timo Männikkö Tehtävä 1 (a) Ei-rekursiivinen algoritmi: etsipienin(t, n) { pnn = t[0]; for (i = 1; i < n; i++) { pnn = min(pnn, t[i]); return pnn; Silmukka suoritetaan

Lisätiedot

811312A Tietorakenteet ja algoritmit, 2015-2016. VI Algoritmien suunnitteluparadigmoja

811312A Tietorakenteet ja algoritmit, 2015-2016. VI Algoritmien suunnitteluparadigmoja 811312A Tietorakenteet ja algoritmit, 2015-2016 VI Algoritmien suunnitteluparadigmoja Sisältö 1. Hajota ja hallitse-menetelmä 2. Dynaaminen taulukointi 3. Ahneet algoritmit 4. Peruuttavat algoritmit 811312A

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Merkintöjen tulkintoja *++Pstack->top = item *Pstack->top++ = item (*Pstack->top)++ *(Pstack++)->top = item *(++Pstack)->top = item Lisää pinon toteutuksia Dynaaminen taulukko

Lisätiedot

v 1 v 2 v 3 v 4 d lapsisolmua d 1 avainta lapsen v i alipuun avaimet k i 1 ja k i k 0 =, k d = Sisäsolmuissa vähint. yksi avain vähint.

v 1 v 2 v 3 v 4 d lapsisolmua d 1 avainta lapsen v i alipuun avaimet k i 1 ja k i k 0 =, k d = Sisäsolmuissa vähint. yksi avain vähint. Yleiset hakupuut 4 Monitiehakupuu: Binäärihakupuu 0 1 3 5 6 7 8 v k 1 k k 3 v v 3 v 4 k 1 k 3 k 1 k k k 3 d lapsisolmua d 1 avainta Yleinen hakupuu? Tietorakenteet, syksy 007 1 Esimerkki monitiehakupuusta

Lisätiedot

Koottu lause; { ja } -merkkien väliin kirjoitetut lauseet muodostavat lohkon, jonka sisällä lauseet suoritetaan peräkkäin.

Koottu lause; { ja } -merkkien väliin kirjoitetut lauseet muodostavat lohkon, jonka sisällä lauseet suoritetaan peräkkäin. 2. Ohjausrakenteet Ohjausrakenteiden avulla ohjataan ohjelman suoritusta. peräkkäisyys valinta toisto Koottu lause; { ja } -merkkien väliin kirjoitetut lauseet muodostavat lohkon, jonka sisällä lauseet

Lisätiedot

1.1 Tavallinen binäärihakupuu

1.1 Tavallinen binäärihakupuu TIE-20100 Tietorakenteet ja algoritmit 1 1 Puurakenteet http://imgur.com/l77fy5x Tässä luvussa käsitellään erilaisia yleisiä puurakenteita. ensin käsitellään tavallinen binäärihakupuu sitten tutustutaan

Lisätiedot

Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI)

Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Muuttujat Tietorakenteet Kontrolli Optimointi Tarkistukset 1 Muuttujan X osoite on 230 Muuttujan X arvo on 12 Symbolin X arvo on 230 symbolit ovat yleensä

Lisätiedot

Tutkimusmenetelmät-kurssi, s-2004

Tutkimusmenetelmät-kurssi, s-2004 Algoritmitutkimuksen menetelmistä Tutkimusmenetelmät-kurssi, s-2004 Pekka Kilpeläinen Kuopion yliopisto Tietojenkäsittelytieteen laitos Algoritmitutkimuksen menetelmistä p.1/20 Sisällys Tänään Tietojenkäsittelytiede

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Kurssin sisältö pääpiirteittäin Tarvittavat pohjatiedot Avainsanat Abstraktio Esimerkkiohjelman tehtäväkuvaus Abstraktion käyttö tehtävässä Abstrakti tietotyyppi Hyötyjä ADT:n

Lisätiedot

10. Painotetut graafit

10. Painotetut graafit 10. Painotetut graafit Esiintyy monesti sovelluksia, joita on kätevä esittää graafeina. Tällaisia ovat esim. tietoverkko tai maantieverkko. Näihin liittyy erinäisiä tekijöitä. Tietoverkkoja käytettäessä

Lisätiedot

815338A Ohjelmointikielten periaatteet Harjoitus 3 vastaukset

815338A Ohjelmointikielten periaatteet Harjoitus 3 vastaukset 815338A Ohjelmointikielten periaatteet 2015-2016. Harjoitus 3 vastaukset Harjoituksen aiheena ovat imperatiivisten kielten muuttujiin liittyvät kysymykset. Tehtävä 1. Määritä muuttujien max_num, lista,

Lisätiedot

811312A Tietorakenteet ja algoritmit, 2014-2015, Harjoitus 7, ratkaisu

811312A Tietorakenteet ja algoritmit, 2014-2015, Harjoitus 7, ratkaisu 832A Tietorakenteet ja algoritmit, 204-205, Harjoitus 7, ratkaisu Hajota ja hallitse-menetelmä: Tehtävä 7.. Muodosta hajota ja hallitse-menetelmää käyttäen algoritmi TULOSTA_PUU_LASKEVA, joka tulostaa

Lisätiedot

Luku 8. Aluekyselyt. 8.1 Summataulukko

Luku 8. Aluekyselyt. 8.1 Summataulukko Luku 8 Aluekyselyt Aluekysely on tiettyä taulukon väliä koskeva kysely. Tyypillisiä aluekyselyitä ovat, mikä on taulukon välin lukujen summa tai pienin luku välillä. Esimerkiksi seuraavassa taulukossa

Lisätiedot

58131 Tietorakenteet ja algoritmit (kevät 2016) Ensimmäinen välikoe, malliratkaisut

58131 Tietorakenteet ja algoritmit (kevät 2016) Ensimmäinen välikoe, malliratkaisut 58131 Tietorakenteet ja algoritmit (kevät 2016) Ensimmäinen välikoe, malliratkaisut 1. Palautetaan vielä mieleen O-notaation määritelmä. Olkoon f ja g funktioita luonnollisilta luvuilta positiivisille

Lisätiedot

Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI)

Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Jakso 3 Konekielinen ohjelmointi (TTK-91, KOKSI) Muuttujat Tietorakenteet Kontrolli Optimointi Tarkistukset 1 Muuttujan X osoite on 230 Muuttujan X arvo on 12 Symbolin X arvo on 230 Tieto ja sen osoite

Lisätiedot

Kääreluokat (oppikirjan luku 9.4) (Wrapper-classes)

Kääreluokat (oppikirjan luku 9.4) (Wrapper-classes) Kääreluokat (oppikirjan luku 9.4) (Wrapper-classes) Kääreluokista Javan alkeistietotyypit ja vastaavat kääreluokat Autoboxing Integer-luokka Double-luokka Kääreluokista Alkeistietotyyppiset muuttujat (esimerkiksi

Lisätiedot

Algoritmit 2. Luento 3 Ti Timo Männikkö

Algoritmit 2. Luento 3 Ti Timo Männikkö Algoritmit 2 Luento 3 Ti 20.3.2018 Timo Männikkö Luento 3 Järjestäminen eli lajittelu Kekorakenne Kekolajittelu Hajautus Yhteentörmäysten käsittely Ketjutus Algoritmit 2 Kevät 2018 Luento 3 Ti 20.3.2018

Lisätiedot

Java-kielen perusteet

Java-kielen perusteet Java-kielen perusteet Tunnus, varattu sana, kommentti Muuttuja, alkeistietotyyppi, merkkijono, Vakio Tiedon merkkipohjainen tulostaminen Ohjelmointi (ict1tx006) Tunnus (5.3) Javan tunnus Java-kirjain Java-numero

Lisätiedot

Algoritmit 1. Luento 12 Ti Timo Männikkö

Algoritmit 1. Luento 12 Ti Timo Männikkö Algoritmit 1 Luento 12 Ti 19.2.2019 Timo Männikkö Luento 12 Osittamisen tasapainoisuus Pikalajittelun vaativuus Lajittelumenetelmien vaativuus Laskentalajittelu Lokerolajittelu Kantalukulajittelu Algoritmit

Lisätiedot

Binäärihaun vertailujärjestys

Binäärihaun vertailujärjestys Järjestetyn sanakirjan tehokas toteutus: binäärihaku Binäärihaku (esimerkkikuassa aain = nimi) op Eea 5 op 5 op op 8 op 5 6 7 8 op Eea 5 op 5 op op 8 op 5 6 7 8 op Eea 5 op 5 op op 8 op 5 6 7 8 op Eea

Lisätiedot

Algoritmi on periaatteellisella tasolla seuraava:

Algoritmi on periaatteellisella tasolla seuraava: Algoritmi on periaatteellisella tasolla seuraava: Dijkstra(V, E, l, v 0 ): S := { v 0 } D[v 0 ] := 0 for v V S do D[v] := l(v 0, v) end for while S V do valitse v V S jolle D[v] on minimaalinen S := S

Lisätiedot

Listarakenne (ArrayList-luokka)

Listarakenne (ArrayList-luokka) Listarakenne (ArrayList-luokka) Mikä on lista? Listan määrittely ArrayList-luokan metodeita Listan läpikäynti Listan läpikäynti indeksin avulla Listan läpikäynti iteraattorin avulla Listaan lisääminen

Lisätiedot

Sisältö. 22. Taulukot. Yleistä. Yleistä

Sisältö. 22. Taulukot. Yleistä. Yleistä Sisältö 22. Taulukot Yleistä. Esittely ja luominen. Alkioiden käsittely. Kaksiulotteinen taulukko. Taulukko metodin parametrina. Taulukko ja HelloWorld-ohjelma. Taulukko paluuarvona. 22.1 22.2 Yleistä

Lisätiedot

Operaattoreiden ylikuormitus. Operaattoreiden kuormitus. Operaattoreiden kuormitus. Operaattoreista. Kuormituksesta

Operaattoreiden ylikuormitus. Operaattoreiden kuormitus. Operaattoreiden kuormitus. Operaattoreista. Kuormituksesta C++ - perusteet Java-osaajille luento 5/7: operaattoreiden ylikuormitus, oliotaulukko, parametrien oletusarvot, komentoriviparametrit, constant, inline, Operaattoreiden ylikuormitus Operaattoreiden kuormitus

Lisätiedot

Imperatiivisen ohjelmoinnin peruskäsitteet. Meidän käyttämän pseudokielen lauseiden syntaksi

Imperatiivisen ohjelmoinnin peruskäsitteet. Meidän käyttämän pseudokielen lauseiden syntaksi Imperatiivisen ohjelmoinnin peruskäsitteet muuttuja muuttujissa oleva data voi olla yksinkertaista eli primitiivistä (esim. luvut ja merkit) tai rakenteista jolloin puhutaan tietorakenteista. puhuttaessa

Lisätiedot

A TIETORAKENTEET JA ALGORITMIT KORVAAVAT HARJOITUSTEHTÄVÄT 3, DEADLINE KLO 12:00

A TIETORAKENTEET JA ALGORITMIT KORVAAVAT HARJOITUSTEHTÄVÄT 3, DEADLINE KLO 12:00 A274101 TIETORAKENTEET JA ALGORITMIT KORVAAVAT HARJOITUSTEHTÄVÄT 3, DEADLINE 9.2.2005 KLO 12:00 PISTETILANNE: www.kyamk.fi/~atesa/tirak/harjoituspisteet-2005.pdf Kynätehtävät palautetaan kirjallisesti

Lisätiedot

Algoritmit 1. Luento 1 Ti Timo Männikkö

Algoritmit 1. Luento 1 Ti Timo Männikkö Algoritmit 1 Luento 1 Ti 10.1.2017 Timo Männikkö Luento 1 Algoritmi Algoritmin toteutus Ongelman ratkaiseminen Algoritmin tehokkuus Algoritmin suoritusaika Algoritmin analysointi Algoritmit 1 Kevät 2017

Lisätiedot

Algoritmit 2. Luento 14 Ke Timo Männikkö

Algoritmit 2. Luento 14 Ke Timo Männikkö Algoritmit 2 Luento 14 Ke 3.5.2017 Timo Männikkö Luento 14 Ositus ja rekursio Rekursion toteutus Kertaus ja tenttivinkit Algoritmit 2 Kevät 2017 Luento 14 Ke 3.5.2017 2/30 Ositus Tehtävän esiintymä ositetaan

Lisätiedot

Algoritmit 2. Demot Timo Männikkö

Algoritmit 2. Demot Timo Männikkö Algoritmit 2 Demot 1 27.-28.3.2019 Timo Männikkö Tehtävä 1 (a) 4n 2 + n + 4 = O(n 2 ) c, n 0 > 0 : 0 4n 2 + n + 4 cn 2 n n 0 Vasen aina tosi Oikea tosi, jos (c 4)n 2 n 4 0, joten oltava c > 4 Kokeillaan

Lisätiedot

TKT20001 Tietorakenteet ja algoritmit Erilliskoe , malliratkaisut (Jyrki Kivinen)

TKT20001 Tietorakenteet ja algoritmit Erilliskoe , malliratkaisut (Jyrki Kivinen) TKT0001 Tietorakenteet ja algoritmit Erilliskoe 5.1.01, malliratkaisut (Jyrki Kivinen) 1. [1 pistettä] (a) Esitä algoritmi, joka poistaa kahteen suuntaan linkitetystä järjestämättömästä tunnussolmullisesta

Lisätiedot

tietueet eri tyyppisiä tietoja saman muuttujan arvoiksi

tietueet eri tyyppisiä tietoja saman muuttujan arvoiksi tietueet eri tyyppisiä tietoja saman muuttujan arvoiksi ero taulukkoon taulukossa alkiot samantyyppisiä tietueessa alkiot voivat olla erityyppisiä tiedot kuitenkin yhteen kuuluvia ohjelmoinnin perusteet,

Lisätiedot

Tietorakenteet ja algoritmit

Tietorakenteet ja algoritmit Tietorakenteet ja algoritmit Muuttujat eri muisteissa Ohjelman muistialueen layout Paikallisen ja globaalin muuttujan ominaisuudet Dynaamisen muistinkäytön edut Paikallisten muuttujien dynaamisuus ADT

Lisätiedot