CS-A1140 Tietorakenteet ja algoritmit
|
|
- Kirsi Salminen
- 7 vuotta sitten
- Katselukertoja:
Transkriptio
1 CS-A1140 Tietorakenteet ja algoritmit Kierros 1: Algoritmianalyysin ja tietorakenteiden perusteita Tommi Junttila Aalto-yliopisto Perustieteiden korkeakoulu Tietotekniikan laitos Syksy 2016
2 Materiaalia kirjassa Introduction to Algorithms, 3rd ed. (online via Aalto lib): Funktioiden kasvunopeuksista: Luku 3 Perustietorakenteita: Kappaleet Dynaamiset taulukot: Kappale /55
3 Algoritmien kuvauksista Erittäin abstraktilla tasolla algoritmi voidaan nähdä menetelmänä, joka muuntaa syötteen halutuksi tulokseksi input algorithm output Esimerkiksi järjestämisalgoritmi muuntaa mielivaltaisen taulukon (mahdollisesti toiseksi) taulukoksi, jossa samat alkiot ovat suuruusjärjestyksessä Monissa tapauksissa on parempi kuvata algoritmi joko luonnollisella kielellä tai pseudokoodina sen sijaan, että esittäisi jollakin tietyllä ohjelmointikielellä tehdyn toteutuksen 3/55
4 Tarkastellaan esimerkkinä ICS-A1120 Ohjelmointi 2 -kurssilla esitettyä puolitushakualgoritmia Se saa syötteenään järjestetyn taulukon A ja alkion e ja selvittää, esiintyykö alkio taulukossa Voisimme kuvata algoritmin luonnollisella kielellä esimerkiksi seuraavasti: 1. Tarkastellaan aluksi koko taulukkoa 2. Jos taulukko on tyhjä, palauta false 3. Jos taulukon keskimmäinen alkio on e, palauta true 4. Muutoin jos keskimmäinen alkio oli suurempi kuin e, palaa kohtaan 2 mutta tarkastele vain osataulukkoa, joka sisältää nykyisen taulukon alkuosan alusta keskipisteeseen asti (muttei sisältäen keskipistettä) 5. Muutoin keskimmäinen alkio on pienempi kuin e ja palataan kohtaan 2 mutta tarkastellen osataulukkoa alkaen keskipisteestä seuraavasta alkiosta ja päättyen viimeiseen alkioon 4/55
5 Algoritmin kuvaus pseudokoodina: // Search for the element e in the sorted array A binary-search(a, e): i search(a, e, 1, A.length) if A[i] = e: return true else: return false // A helper function: search for the index of e in the sub-array A[lo,...,hi] search(a, e, lo, hi): if hi lo: return lo // sub-array of size 1 or less? mid lo + (hi lo)/2 if A[mid] = e: return mid else if A[mid] < e: return search(a, e, mid + 1, hi) else: return search(a, e, lo, mid 1) Huomioitavaa: monesti taulukon inddeksointi alkaa indeksillä 1 pseudokoodissa ja matemaattisessa notaatiossa mutta indeksillä 0 monessa oikeassa ohjelmointikielissä Tämä tulee ottaa huomioon toteutettaessa kirjasta, wikipediasta jne löytyviä algoritmeja 5/55
6 Eräs toteutus Scalalla: def binarysearch [ T <% Ordered [ T ] ] ( s : IndexedSeq [ T ], v : T ) : Boolean = { def i n n e r ( s t a r t : I n t, end : I n t ) : I n t = { i f (! ( s t a r t < end ) ) s t a r t else { val mid = s t a r t + ( ( end s t a r t ) / 2) val cmp = v compare s ( mid ) i f (cmp == 0) mid / / v == s ( mid ) else i f (cmp < 0) i n n e r ( s t a r t, mid 1) / / v < s ( mid ) else i n n e r ( mid+1, end ) / / v > s ( mid ) } } i f ( s. length == 0) false else s ( i n n e r ( 0, s. length 1) ) == v } 6/55
7 Algoritmianalyysin perusteita 7/55
8 Resurssityyppejä ja ominaisuuksia Tavoitteena on saada aikaan algoritmeja, jotka käyttävät annettuja resursseja tehokkaasti Tyypillisiä resursseja ja ominaisuuksia ovat ajoaika muistin käyttö rinnakkaistuvuus levyn ja verkon käyttö välimuistin käytön tehokkuus (esim. cache-oblivious algorithms)... Luonnollisesti joskus pitää tehdä kompromisseja: esimerkiksi algoritmi voi käyttää vähemmän muistia mutta olla ajoajaltaan hitaampi kuin toinen saman asian tekevä algoritmi Tällä kurssilla keskitytään pääsääntöisesti ajoaikaan Tarkastelemme algoritmin/ohjelman ajoaikaa funktiona f (n) suhteessa syötteen kokoon tai johonkin muuhun mielenkiintoiseen parametriin n Sekä n että f (n) oletetaan yleensä ei-negatiivisiksi ja n on yleensä kokonaisluku 8/55
9 O-notaatio Tarkastellaan funktioiden asymptoottista kasvua Tätä varten käytetään O-notaatiota ja sen variantteja Se on matemaattinen työkalu, joka abstrahoi pois Määritelmä pienet n:n arvot eli pienet syötteet, sekä vakiotekijät, jotka riippuvat esimerkiksi kellotaajuudesta tai muistiväylän leveydestä Merkitään f (n) = O(g(n)) jos on olemassa vakiot c,n 0 > 0 siten, että f (n) cg(n) kaikille n n 0. Tällöin f (n) kasvaa korkeintaan yhtä nopeasti kuin g(n) (kun tarkastelemme tarpeeksi suuria n:n arvoja) Muistutus: f (n) ja g(n) ovat ei-negatiivisia 9/55
10 10n = O(n), 10n = O(n 2 ) ja 10n = O(2 0.1n ) n 2 + 5n = O(n 2 ) ja n 2 + 5n = O(2 0.1n ) mutta n 2 + 5n O(n) 2 0.1n O(n) ja 2 0.1n O(n 2 ) 10/55
11 Tyypillisiä funktioluokkia: O(1) vakio O(log n) logaritminen O(n) lineaarinen O(nlogn) kvasilineaarinen, n log n (O(logn!) = O(nlogn)) O(n 2 ) neliöllinen O(n 3 ) kuutiollinen O(n k ) polynominen, k 0 O(c n ) eksponentiaalinen, c > 1 O(n!) kertoma Vakio-, logaritmiset, lineaariset, kvasilineaariset, neliölliset ja kuutiolliset funktiot ovat siis kaikki polynomisia funktioita Logaritmit ovat kannassa 2 jollei toisin mainita (mutta tällä ei yleisesti väliä koska log c n = log 2 n log 2 c kaikille c > 1) 11/55
12 Algoritmin/ohjelman pahimman tapauksen ajoaika on O(f (n)) jos g(n) = O(f (n)), missä funktio g(n) on pisin ajoaika mille tahansa syötteelle kokoa n Yleensä sanonta algoritmin ajoaika on O(f (n)) tarkoittaa pahimman tapauksen ajoaikaa Voidaan myös tarkastella parhaan tapauksen ajoaikaa, joka saadaan vastaavasti tarkastelemalla kaikkien n:n kokoisten syötteiden pienintä ajoaikaa keskimääräistä ajoaikaa, missä tarkastellaan n:n kokoisten syötteiden (joko kaikkien tai jostakin tyypillisestä joukosta valittujen) odotettua ajoaikaa 12/55
13 Esimerkki: Tarkastellaan lineaarihakualgoritmia, joka tarkastaa kuuluuko alkio e järjestämättömään taulukkoon A käymällä sen alkiot läpi kunnes e löytyy tai kaikki taulukon n alkiota on käyty läpi. Olettaen, että alkion haku taulukosta ja alkioiden vertailu ovat vakioaikaisia operaatioita, pahimman tapauksen ajoaika on O(n) koska e voi olla taulukon viimeinen alkio tai puuttua taulukosta, jolloin kaikki n alkiota käydään läpi parhaan tapauksen ajoaika on O(1) koska e voi olla taulukon ensimmäinen alkio 13/55
14 Esimerkki: neliömatriisien (suoraviivainen) kertominen Analysoidaan kertolaskumetodin * asymptoottista ajoaikaa Ensin tulosmatriisin result alustus vie ajan O(n 2 ) koska sen n n alkiota varataan ja alustetaan arvolla 0 class Matrix ( val n : I n t ) { r e q u i r e ( n > 0, " n must be p o s i t i v e " ) val e n t r i e s = new Array [ Double ] ( n * n ) / * * Access elements by w r i t i n g m( i, j ) * / def apply ( row : I n t, column : I n t ) = { e n t r i e s ( row * n + column ) } / * * Set elements by w r i t i n g m( i, j ) = v * / def update ( row : I n t, c o l : I n t, val : Double ) { e n t r i e s ( row * n + c o l ) = val } / * * Returns the product of t h i s and t h a t * / def * ( t h a t : M atrix ) : M atrix = { r e q u i r e ( n == t h a t. n ) val r e s u l t = new Matrix ( n ) for ( row < 0 u n t i l n ; column < 0 u n t i l n ) { var v = 0.0 for ( i < 0 u n t i l n ) v += this ( row, i ) * t h a t ( i, column ) r e s u l t ( row, column ) = v } r e s u l t } } 14/55
15 Esimerkki: neliömatriisien (suoraviivainen) kertominen Uloin silmukka käy läpi muuttujalle row arvot 0,1,...,n 1 Keskimmäinen: col arvot 0,1,...,n 1 Sisin: i arvot 01,...,n 1 Sisimmässä silmukassa arvojen hakeminen ja kertolasku ovat vakioaikaisia toimintoja Metodin * ajoaika on O(n 2 + n 3 ) = O(n 3 ) class Matrix ( val n : I n t ) { r e q u i r e ( n > 0, " n must be p o s i t i v e " ) val e n t r i e s = new Array [ Double ] ( n * n ) / * * Access elements by w r i t i n g m( i, j ) * / def apply ( row : I n t, column : I n t ) = { e n t r i e s ( row * n + column ) } / * * Set elements by w r i t i n g m( i, j ) = v * / def update ( row : I n t, c o l : I n t, val : Double ) { e n t r i e s ( row * n + c o l ) = val } / * * Returns the product of t h i s and t h a t * / def * ( t h a t : M atrix ) : M atrix = { r e q u i r e ( n == t h a t. n ) val r e s u l t = new Matrix ( n ) for ( row < 0 u n t i l n ; column < 0 u n t i l n ) { var v = 0.0 for ( i < 0 u n t i l n ) v += this ( row, i ) * t h a t ( i, column ) r e s u l t ( row, column ) = v } r e s u l t } } 15/55
16 Θ-, Ω, o- ja ω-notaatiot O-notaation lisäksi yleisesti käytettyjä ovat seuraavat: f (n) = Ω(g(n)) jos g(n) = O(f (n)) f kasvaa vähintään yhtä nopeasti kuin g f (n) = Θ(g(n)) jos f (n) = O(g(n)) ja g(n) = O(f (n)) f ja g kasvavat yhtä nopeasti Lisäksi Määritelmä Merkitään f (n) = o(g(n)) jos kaikille vakioille c > 0 on olemassa vakio n 0 > 0 siten että f (n) < cg(n) kaikille n n 0. Jos f (n) = o(g(n)), niin f kasvaa hitaammin kuin g f (n) = ω(g(n)) jos g(n) = o(f (n)), f kasvaa nopeammin kuin g 16/55
17 Rekursio ja rekursioyhtälöt 17/55
18 Rekursiivisille ohjelmille asymptoottisen ajoajan analysointi suoraan (pseudo)koodista voi olla haastavampaa Esimerkki: Ojelmointi 2-kurssilta: binäärihakualgoritmin toteutus Scalalla def binarysearch [ T <% Ordered [ T ] ] ( s : IndexedSeq [ T ], v : T ) : Boolean = { def i n n e r ( s t a r t : I n t, end : I n t ) : I n t = { i f (! ( s t a r t < end ) ) s t a r t else { val mid = s t a r t + ( ( end s t a r t ) / 2) val cmp = v compare s ( mid ) i f (cmp == 0) mid / / v == s ( mid ) else i f (cmp < 0) i n n e r ( s t a r t, mid 1) / / v < s ( mid ) else i n n e r ( mid+1, end ) / / v > s ( mid ) } } i f ( s. length == 0) false else s ( i n n e r ( 0, s. length 1) ) == v } 18/55
19 Toisaalta ajoaika-analyysi vastaavasta ei-rekursiivisesta koodista voi olla vähintään yhtä haastavaa, jos ei vaikeampaakin... Esimerkki: ei-rekursiivinen versio binäärihakualgoritmista: def b i n a r y S e a r c h I t e r [ T <% Ordered [ T ] ] ( s : IndexedSeq [ T ], v : T ) : Boolean = { i f ( s. length == 0) return false var s t a r t = 0 var end = s. length 1 while ( s t a r t < end ) { val mid = s t a r t + ( ( end s t a r t ) / 2) val cmp = v compare s ( mid ) i f (cmp == 0) { s t a r t = mid ; end = mid } else i f (cmp < 0) end = mid 1 / / v < s ( mid ) else s t a r t = mid+1 / / v > s ( mid ) } return s ( s t a r t ) == v } 19/55
20 Rekursiivisten ohjelmien ajoajoille T(n) voidaan usein muodostaa rekursioyhtälö (engl. recurrence equation) muotoa T(n) =... missä n on parametri, joka liittyy usein jotenkin sen hetkisen rekursiivisen kutsun tarkasteleman osasyötteen kokoon tms, ja yhtälön oikea puoli riippuu rekursiivisesti pienempien osaongelmien ajoajasta T(n ) ja muista termeistä Lisäksi täytyy luonnollisesti ilmaista perustapaukset, yleensä T(0) tai T(1), jotka eivät riipu muista arvoista T(n ) Saatu rekursioyhtälö ratkaistaan jollain tavalla Huom: T(n) ei ole funktion/metodin laskema arvo vaan (arvio) sen ajoajasta syötteellä, jonka koko on n 20/55
21 Esimerkki: Binäärihakualgoritmin rekursiivinen osa tarkastelee osataulukoita, joiden koko on n (end - start + 1 Scala-toteutuksessa). Kun n 1, niin rekursio päättyy n > 1, niin tehtdään alkioiden vertailu ja haku joko päättyy koska haettu alkio löytyi, tai kutsutaan samaa funktiota rekursiivisesti osataulukolla, jonka koko on n/2 Jos oletetaan taulukon alkioiden käsittely ja alkioiden vertailu vakioaikaisiksi operaatioiksi, niin saadaan rekursioyhtälöt T(0) = T(1) = d ja T(n) = c + T( n/2 ) missä d ja c ovat vakioita, jotka kertovat indeksien vertailuun, alkioden hakemiseen jne menevän ajan Huomaa, että tässä T(n) on pahimman tapauksen arvio ajoajalle (suoritetuille käskyille tms) koska olemme jättäneet siinä huomioimatta tapauksen, jossa alkio löytyy taulukosta ennen kuin tarkasteltavan osataulukon koko on 1 21/55
22 Ratkaistaan rekursiöyhtälöt T(0) = T(1) = d ja T(n) = c + T( n/2 ) Oletetaan, että n on kahden potenssi eli muotoa n = 2 k jollekin einegatiiviselle kokonaisluvulle k. Tällöin T(2 k ) = c + T(2 k 1 ) = c + (c + T(2 k 2 )) =... = kc + T(2 0 ) = ck + d Koska n = 2 k, joten k = log 2 n, ja c sekä d ovat vakioita, saadaan T(n) = T(2 k ) = ck + d = clog 2 n + d = O(log 2 n) Kun n ei ole kahden potenssi, niin T(n) T(2 log 2 n ) = d +c log 2 n d + c(1 + log 2 n) = O(log 2 n) koska T(n) on monotonisesti kasvava. 22/55
23 Käytettäessä O-notaatiota yksittäisiä vakioita voidaan usein poistaa jo alkuvaiheessa korvaamalla ne vakiolla 1. Binäärihakuesimerkissä rekursioyhtälö voisi siis olla T(0) = T(1) = 1 ja T(n) = 1 + T( n/2 ). Tämän ratkaisuksi saadaan jälleen T(n) = O(log 2 n). Usein käytetään myös seuraavaa merkintää T(0) = T(1) = O(1) ja T(n) = O(1) + T( n/2 ). 23/55
24 Ajoajan (suoritettujen käskyjen määrän) lisäksi myös muista algoritmien ominaisuuksista voidaan tehdä vastaavia analyyseja Jos esimerkiksi alkioiden vertailu ei olekaan vakioaikaista vaan vie enemmän resursseja, voi olla kiinnostavaa vertailla eri hakuja järjestämisalgoritmien suorittamaa vertailujen määrää Esimerkki: Binäärihaun suorittamien vertailujen asymptoottiselle lukumäärälle saadaan jälleen rekursioyhtälö T(0) = T(1) = 1 and T(n) = T( n/2 ) + 1 missä n on syötetaulukon koko. Täten T(n) = O(log 2 n). Järjestämisalgoritmien yhteydessä seuraavalla kierroksella nähdään hieman monimutkaisempia rekursioyhtälöitä 24/55
25 Esimerkki: Potenssiin korottaminen neliöön korottamalla Tarkastellaan algoritmia, joka suorittaa potenssiin korottamisen x n mod 2 64 käyttämällä yhtälöä x n = k 1 i=0 xn i2 i, missä n k 1 n k 2...n 1 n 0 on luvun n binääriesitys Esimerkiksi x 71 = x 1 x 2 x 4 x 64 = x 20 x 21 x 22 x 26 Algoritmi käyttää iteratiivista neliöön korottamista: alkaen arvosta x 20 = x, se muodostaa aina seuraavan neliön x 2i+1 = x 2i x 2i. def pow( x : Long, n : Long ) : Long = { r e q u i r e ( n >= 0) i f ( n == 0) 1 else i f ( n == 1) x else i f ( ( n & 0x01 ) == 1) x * pow( x * x, n / 2 ) else pow( x * x, n / 2 ) } Suhteessa muuttujan n arvoon saadaan ajoajalle rekursioyhtälöt T(0) = T(1) = 1 ja T(n) = 1 + T(n/2). Täten T(n) = O(log 2 n). 25/55
26 Esimerkki: Tarkastellaan Ohjelmointi 2-kurssilta tuttua osajoukko-ongelmaa Annettuna joukko S = {v 1,...,v n } kokonaislukuja ja tavoiteluku t. Onko olemassa osajoukkoa S S siten, että v S v = t? ja (erittäin yksinkertaista) rekursiivista Scala-ohjelmaa sen ratkaisemiseksi: def subsetsum ( s : L i s t [ I n t ], t : I n t ) : Option [ L i s t [ I n t ] ] = { i f ( t == 0) return Some( N i l ) i f ( s. isempty ) return None val solnotincluded = subsetsum ( s. t a i l, t ) i f ( solnotincluded. nonempty ) return solnotincluded val s o l I n c l u d e d = subsetsum ( s. t a i l, t s. head ) i f ( s o l I n c l u d e d. nonempty ) return Some( s. head : : s o l I n c l u d e d. get ) return None } 26/55
27 Muodostetaan rekursiivisen ohjelman ajoaikaa kuvaavat rekursioyhtälöt parametrin n ollessa joukon alkioiden lukumäärä Pahimman tapauksen analyysissä ratkaisua ei löydy ja rekursio päättyy aina vasta kun tarkasteltava joukko on tyhjä Jokaisella rekursiivisella kutsukerralla ohjelma suorittaa joitain vakioaikaisia operaatioita ja sitten kaksi rekursiivista kutsua joukolla, josta on poistettu yksi alkio Täten saadaan rekursioyhtälöt T(0) = 1 ja T(n) = 1 + T(n 1) + T(n 1) = 1 + 2T(n 1) Kirjoitetaan yhtälö T(n) suoraviivaisesti auki ja saadaan T(n) = 1 + 2T(n 1) = 1 + 2(1 + 2T(n 2)) = (1 + 2T(n 3)) =... = n i=0 2i = 2 n+1 1 = Θ(2 n ) Eli pahimmassa tapauksessa ohjelman ajoaika on eksponentiaalinen Parhaassa (oletettavasti tosin hyvin harvinaisessa) tapauksessa tavoiteluku t on 0 ja ohjelman suoritus päättyy vakioajassa 27/55
28 Kokeellinen analyysi 28/55
29 Matemaattisen analyysin lisäksi voidaan (ja kannattaa) suorittaa myös kokeellista suorituskykyanalyysiä Voidaan vaikkapa ottaa kaksi toteutusta samasta tai eri algoritmista, jotka laskevat saman asian, ajaa näitä totetuksia jollain hyvin valitulla syötejoukolla ja vertailla mitattuja ajoaikoja Voitaisiin myös vaikkapa instrumentoida algoritmin toteutuskoodia niin, että se laskee esimerkiksi kaikki tehdyt vertailuoperaatiot ajon aikana ja kokeellisesti tarkastella saatujen määrien minimi-, keski- ja maksimiarvoja käyttää jotain profilointityökalua (kuten valgrind C/C++/konekieliohjelmille) saadaksemme selville välimuistiviittausten epäonnistumismäärät jne 29/55
30 Yksinkertainen ajoajan mittaaminen Kuten nähtiin Ohjelmointi 2-kurssilla, funktioiden ajoajan mittaus on periaatteessa melko helppoa 1 import java. lang. management. { ManagementFactory, ThreadMXBean } package object t i m e r { val bean : ThreadMXBean = ManagementFactory. getthreadmxbean ( ) def getcputime = i f ( bean. iscurrentthreadcputimesupported ( ) ) bean. getcurrentthreadcputime ( ) else 0 def measurecputime [ T ] ( f : => T ) : ( T, Double ) = { val s t a r t = getcputime val r = f val end = getcputime ( r, ( end s t a r t ) / ) } def measurewallclocktime [ T ] ( f : => T ) : ( T, Double ) = { val s t a r t = System. nanotime val r = f val end = System. nanotime ( r, ( end s t a r t ) / ) } } 1 Prosessoriajan (CPU time) sijaan tulee käyttää seinäkelloaikaa (wall clock time) rinnakkaisohjelmien ajankäyttöä mitattaessa koska getcurrentthreadcputime mittaa vain yhden säikeen prosessoriaikaa 30/55
31 Valitettavasti asia ei ole ihan näin suoraviivainen tarkastellaan seuraavaa koodia, joka järjestää 20 taulukkoa, joissa jokaisessa kokonaislukua import timer. _ val a = new Array [ I n t ](10000) val rand = new scala. u t i l. Random ( ) val times = scala. c o l l e c t i o n. mutable. A r r a y B u f f e r [ Double ] ( ) for ( t e s t < 0 u n t i l 20) { for ( i < 0 u n t i l a. length ) a ( i ) = rand. n e x t I n t val (dummy, t ) = measurecputime { a. sorted } times += t } p r i n t l n ( times. mkstring ( ", " ) ) Tuloksena saadaan seuraavat ajoajat , , , , , , , , , , , , , , , , , , , Mitataan saman koodin suoritusta samankaltaisilla syötteillä mutta ajoaika tippuu kymmenesosaan joidenkin toistojen jälkeen? 31/55
32 Yllä oleva käytös voidaan selittää seuraavasti Scala-ohjelmat käännetään Java-tavukoodiksi Java-tavukoodia ajetaan Java-virtuaalikoneessa (Java virtual machine, JVM) Suoritus voi alkaa tulkitussa moodissa Osia koodista voidaan jossain vaiheessa kääntää alla olevan koneen konekoodiksi suorituksen aikana (just-in-time compilation) Käännettyä koodia voidaan optimoida ajon aikana Roskankeruuta (garbage collection) voi tapahtua ajon aikana Erityisesti lyhyiden ajoaikojen tulkinnassa kannattaa olla varovainen Pidempien ajoaikojen yhteydessä ilmiöt eivät tule suhteellisesti niin voimakkaasti esille ajoajan heilumisena 32/55
33 ScalaMeter Kuten nähtiin, tulkittujen ja virtuaalikoneissa ajettavien ohjelmien suorituskykyanalyysin tekeminen luotettavasti voi olla vaikeaa, erityisesti jos ajoajat ovat lyhyitä Tällä kurssilla käytetään joissain paikoin ScalaMeter-työkalua ( Se yrittää ottaa nämä virtuaalikoneisiin ja roskankeräämiseen liittyvät piirteet huomioon mm. lämmittelemällä virtuaalikonetta ja käyttämällä tilastollisia menetelmiä Lisää tietoa löytyy työkalun dokumentaatiosta ja artikkelista A. Georges et al: Statistically rigorous java performance evaluation, Proc. OOPSLA 2007, pp /55
34 Joitakin perustietorakenteita 34/55
35 Kerrataan joitain tietorakenteita ja... tutustutaan joihinkin toisiin yksinkertaisiin lineaarisiin rakenteisiin Nämä eivät ole vain Scalassa käytettyjä rakenteita Tarkastellaan, minkä operaatioiden tehokasta toteutusta rakenteet tukevat Tällaista tehokkaiden operaatioiden joukkoa (ja niiden toiminnan määrittelyä) sanotaan usein abstraktiksi tietotyypiksi 35/55
36 Taulukot Sisäänrakennettu tyyppi useimmissa ohjelmointikielissä (Java-virtuaalikone, C/C++ jne) Sekvenssi, jossa n alkiota Vakioaikainen alkioiden luku ja kirjoitus Alkion etsiminen vie pahimmassa tapauksessa ajan Θ(n) (jos taulukkoa ei ole järjestetty binäärihakua varten tms) Taulukon koko n määrätään jo luomisvaiheessa, kun sille varataan yhtäjaksoinen muistijakso Alkioita ei voi lisätä tämän jälkeen alkuun tai loppuun taulukon kokoa kasvattaen. Jos näin tahdotaan tehdä, pitää varata uusi isompi taulukko ja kopioida vanha taulukko sekä uusi alkio siihen; tämän aikavaatimus on jälleen Θ(n) 36/55
37 Java- ja Scala-kielissä taulukon alkio ovat joko alkeistyyppejä (Int, Long jne) tai viittauksia olioihin, jotka sijaitsevat toisaalla muistissa Esimerkki: oliokaavio taulukolle kokonaislukuja (vasemmalla) ja taulukolle kokonaislukupareja (oikealla) Array[Int] Array[MinMaxPair] arr arr MinMaxPair MinMaxPair Oikeanpuoleisen taulukon kolmas alkio on null-viittaus, joka ei viittaa yhteenkään olioon Toiset ohjelmointikielet, kuten C ja C++, sallivat taulukoiden sisältää myös rakenteellisia olioita min 10 max 32 min 21 max 42 37/55
38 Dynaamiset taulukot ArrayBuffer Scalassa, vector C++-kielen standardikirjastossa Mahdollistavat kuoletetun vakioaikaisen alkioiden lisäämisen taulukon loppuun Idea: varataan hieman tarvetta suurempi taulukko a ja muistetaan taulukon a kapasiteetti c eli taulukon koko 2 ja taulukon tämänhetkinen koko s eli kuinka moni c:stä alkiosta on itse asiassa käytössä alla olevassa taulukossa a Alkion lisääminen dynaamisen taulukon loppuun: jos s < c, niin alkio kirjoitetaan taulukon a kohtaan s ja muuttujaa s kasvatetaan yhdellä, tai jos s = c, 1. varataan uusi taulukko kokoa c α, missä α > 1 on kasvukerroinvakio (yleensä 2), 2. kopioidaan vanhan taulukon alkiot uuden alkuun ja 3. asetetaan c = c α, kirjoitetaan alkio kohtaan s uudessa taulukossa ja kasvatetaan muuttujaa s ydellä 2 Java- ja Scala-kielissä tämä on sisäänrakennettu mutta esim. C/C++ -kielissä taulukot eivät sisällä mitään tämänkaltaista lisätietoa 38/55
39 Esimerkki: Alkion lisääminen täyteen dynaamiseen taulukkoon Luvun 21 lisääminen alla olevaan täyteen dynaamiseen taulukkoon ResizableArray[Int] cap size array arr 4 4 Array[Int] käynnistää laajennusoperaation ja tuloksena saadaan ResizableArray[Int] cap size array arr 8 5 Array[Int] Array[Int] Vanhan taulukon muistin vapauttamisesta huolehtii joko roskankeräämisalgoritmi (Java, Scala, Python) tai lisäyksen suorittava kirjastokoodi (C, C++ jne) 39/55
40 Esimerkki: alkioiden lisääminen ArrayBuffer-luokassa, lähdekoodia luokista ArrayBuffer ja ResizableArray / * * Appends a s i n g l e element to t h i s b u f f e r and r e t u r n s * the i d e n t i t y of the b u f f e r. I t takes constant amortized time. * / def +=(elem : A) : this. type = { ensuresize ( size0 + 1) array ( size0 ) = elem. asinstanceof [ AnyRef ] size0 += 1 this } / * * Ensure t h a t the i n t e r n a l array has at l e a s t n c e l l s. * / protected def ensuresize ( n : I n t ) { val arraylength : Long = array. length / / Use a Long to prevent overflows i f ( n > arraylength ) { var newsize : Long = arraylength * 2 while ( n > newsize ) newsize = newsize * 2 / / Clamp newsize to I n t. MaxValue i f ( newsize > I n t. MaxValue ) newsize = I n t. MaxValue val newarray : Array [ AnyRef ] = new Array ( newsize. t o I n t ) scala. compat. Platform. arraycopy ( array, 0, newarray, 0, size0 ) array = newarray } } 40/55
41 Taulukon koon kasvattaminen kertoo sen koon vakiolla α ja täten taulukkojen koko kasvaa eksponentiaalisesti Eikö eksponentiaalinen kasvu ole huono asia? Ei tässä tapauksessa: jos vain lisäämme alkioita, niin taulukon täyttöaste on aina vähintään 1 α. Jos α = 2, niin tuhlataan vain korkeintaan sama määrä muistia mitä käytetään alkioiden tallentamiseen Verrataan tätä linkitettyihin listoihin, joissa jokainen solu sisältää ainakin yhden talletetun alkion ja viittauksen seuraavaan soluun listassa 3 linkitetyt listat tuhlaavat myös suurinpiirtein saman määrän muistia 3 Java- ja Scala-kielissä solu sisältää myös luokkatietoa 41/55
42 Miksi valittiin eksponentiaalinen kasvattaminen eikä vain taulukon koon kasvattamista jollain kohtuullisen isolla määrällä, esim. 1024, alkioita? Koska eksponentiaalinen kasvattaminen mahdollistaa lisäysten vaatiman ajoajan kuolettamisen vakioaikaiseksi Eli jos lisäämme n alkiota dynaamiseen taulukkoon, niin jotkut lisäämiset eli ne, joilla kasvattaminen tapahtuu, ovat ajoajallisesti kalliita koska joudutaan varaamaan muistia ja kopioimaan alkioita, mutta kokonaisajoaika kuoletettuna jokaiselle lisäämiselle on vakio. 42/55
43 Tarkastellaan jokaisella lisäyksellä tehtyjen muistioperaatioiden määrää (tämä on lineaarisessa suhteessa ajoaikaan) Oletetaan, että α = 2, ollaan jo lisätty n alkiota alkuaan tyhjään dynaamiseen taulukkoon ja taulukon kokoa joudutaan kasvattamaan kun lisätään seuraava alkio Niiden ylimääräisten muistioperaatioiden määrä, jotka joudutaan tekemään kopioitaessa edellisen taulukon alkioita uusiin tällä ja kaikilla edellisillä lisäyksillä yhteensä saadaan rekursioyhtälöstä T(d) = 0 ja T(n) = n + T(n/2), missä d on taulukon alkukoko. Nyt T(n) n + T(n/2) n + n/2 + n/4 + n/8... 2n Lisätään tähän vielä 1 muistioperaatio per lisäys (uuden alkion kirjoittaminen) ja saadaan, että muistioperaatioiden määrä kuoletettuna jokaiselle lisäykselle on 2n+n n = 3 Vastaavasti jokaiselle kasvukerroinvakiolle α > 1 saataisiin lisäkustannukseksi korkeintaan n i=0 1 = n 1 = n α α i 1 α 1 α 1 = O(n) ja kuoletettu kustannus täten jälleen vakio Esim. kun α = 1.1, niin kuoletettu kustannus lisäyksille on = 12 muistioperaatiota 43/55
44 Kasvukerroinvakiolle 2 voidaan edellä esitettyä analyysiä visualisoida graafisestikun lisätään 9 alkiota dynaamiseen taulukkoon, jonka koko on alussa 1: arr ResizableArray[T ] cap size array c s Array[T ] 0 e0 1 e1 2 e2 3 e3 4 e4 5 e5 6 e6 7 e e8 Siniset pallurat ovat normaaleja muistiperaatioita, jotka johtuvat uuden alkio kirjoittamisesta, punaiset edellisten laajennusten kopiointioperaatioista ja pinkit nykyisen laajennuksen kopioinnista Jos romautetaan punaiset tornit oikealle ja pinkki vasemmalle, saadaan arr ResizableArray[T ] cap size array c s Array[T ] 0 e0 1 e1 2 e2 3 e3 4 e4 5 e5 6 e6 7 e e8 mistä näkyy, että jokaiselle lisäykselle kuoleentuu 3 palluraa 44/55
45 Tulisiko dynaamisen taulukon kokoa supistaa jos siinä on, poistojen jälkeen, vähän alkioita kapasiteettiin nähden? Kyllä, tämä voidaan tehdä niin, että sekä taulukon loppuun tehtyjen lisäysten että poistojen kuoletettu ajoaika pysyy vakiona Mutta supistuksen käynnistävä täyttöasteen c s ala-arvo saa olla korkeintaan kasvukerroinvakion käänteisluku. Eli esim. jos taulukon kokoa kasvatetaan kaksinkertaiseksi lisäyksen yhteydessä ja sen jälkeen heti poistetaan alkio lopusta, niin taulukon kokoa ei tule supistaa heti Jos kasvukerroinvakio on 2.0 ja supistusvakio 0.25, niin lisäys- ja poisto-operaatiot ovat kuoletetusti vakioaikaisia, ks. luku 17.4 kirjassa Introduction to Algorithms, 3rd ed. (online via Aalto lib) 45/55
46 Linkitetyt listat Kertausta Ohjelmointi 2-kurssin rekursio -kierrokselta: muuttumattomat linkitetyt listat Listoja ei muokata luomisen jälkeen, solut voivat olla jaettuja usean listan kesken Alkioiden lisääminen alkuun on vakioaikaista, loppuun lineaariaikaista Esimerkki: Muutumattomat linkitetyt listat Linkitetty lista l: Cons Cons Cons Nil value l 10 next value 21 next value 33 next 46/55
47 Linkitetyt listat Kertausta Ohjelmointi 2-kurssin rekursio -kierrokselta: muuttumattomat linkitetyt listat Listoja ei muokata luomisen jälkeen, solut voivat olla jaettuja usean listan kesken Alkioiden lisääminen alkuun on vakioaikaista, loppuun lineaariaikaista Esimerkki: Muutumattomat linkitetyt listat Lista k, joka on listan l häntä : Cons Cons Cons Nil value l 10 next value 21 next value 33 next k 47/55
48 Linkitetyt listat Kertausta Ohjelmointi 2-kurssin rekursio -kierrokselta: muuttumattomat linkitetyt listat Listoja ei muokata luomisen jälkeen, solut voivat olla jaettuja usean listan kesken Alkioiden lisääminen alkuun on vakioaikaista, loppuun lineaariaikaista Esimerkki: Muutumattomat linkitetyt listat Lista m, joka saatu listasta l lisäämällä 11 alkion 21 jälkeen: l Cons value 10 next Cons value 21 next Cons value 33 next Nil k m Cons Cons Cons value next value next value next /55
49 Linkitetyistä listoista on myös muuttuvatilainen versio Soluja ei nyt jaeta eri listojen kesken Alkioiden lisäys listaan voidaan tehdä varaamalla uusi solu ja muokkaamalla listan solujen viittauksia Jos viittaus listan viimeiseen soluun pidetään muistissa, voidaan myös listan loppuun lisätä alkioita vakioajassa Listan alkioiden lukumäärää voidaan myös pitää muistissa, jolloin pituuskyselyt ovat vakioaikaisia Esimerkki: Muuttuvatilaiset linkitetyt listat Muuttuvatilainen linkitetty lista: l List n first last 3 Entry Entry Entry value next value next value next /55
50 Linkitetyistä listoista on myös muuttuvatilainen versio Soluja ei nyt jaeta eri listojen kesken Alkioiden lisäys listaan voidaan tehdä varaamalla uusi solu ja muokkaamalla listan solujen viittauksia Jos viittaus listan viimeiseen soluun pidetään muistissa, voidaan myös listan loppuun lisätä alkioita vakioajassa Listan alkioiden lukumäärää voidaan myös pitää muistissa, jolloin pituuskyselyt ovat vakioaikaisia Esimerkki: Muuttuvatilaiset linkitetyt listat Sama lista sen jälkeen kun on lisätty 11 alkion 21 jälkeen: l List n first last 4 Entry Entry Entry Entry value next value next value next value next /55
51 Kahteen suuntaan linkitetyt listat ovat edellisen laajennus, jossa jokainen solu sisältää myös viittauksen edelliseen soluun Tällaisia listoja voidaan käydä läpi tehokkaasti myös käänteisessä järjestyksessä Esimerkki: Muuttuvatilainen kahteen suuntaan linkitetty lista Edellisen esimerkin listan kahteen suuntaan linkitetty versio: List l n first last 4 Entry Entry Entry Entry prev prev prev prev value next value next value next value 33 next Jos saadaan viittaus johonkin listan soluun, niin solun poistaminen samoin kuin alkion lisääminen juuri ennen sitä tai sen jälkeen on helppoa johtuen viittauksista edeltävään ja seuraavaan soluun 51/55
52 Muuttuvatilaiset lista Scala-kielessä: ListBuffer (lähdekoodi) Aiemmat versiot LinkedList ja DoubleLinkedList eivät ole enää suositeltuja C++-kielessä luokka list toteuttaa kahteen suuntaan linkitetyt listat 52/55
53 Jonot Jonot (engl. queue) viittaavat yleensä ensin sisään, ensin ulos -jonoihin (engl. first-in-first-out, FIFO) Perusoperaatiot ovat enqueue, joka lisää alkion jonon loppuun ja dequeue, joka poistaa alkion jonon alusta Tällaiset jonot on helppo toteuttaa kahteen suuntaan linkitetyillä listoilla niin, että sekä enqueue- ja dequeue-operaatiot ovat vakioaikaisia Scalassa muutuvatilainen Queue on toteutettu linkitetyillä listoilla (sisäinen MutableList-luokka) C++-kielen standardikirjastossa queue-luoka toteuttaa jonot ( enqueue on push ja dequeue on pop ) 53/55
54 Pinot Pinot ovat jonojen tapaisia mutta viimeksi sisään, ensin ulos -jonokurilla (engl. last-in-first-out, LIFO) Perusoperaatiot ovat push, joka laittaa alkion pinon päälle ja pop, joka poistaa pinon päällimmäisen alkion Pinot on myös samoin helppo toteuttaa linkitettyjen listojen tai dynaamisten taulukoiden avulla Scalassa sekä muuttumattomat että muuttuvatilaiset pinot on toteutettu listojen avulla C++-kielessä: stack-luokka 54/55
55 Lisää tietorakenteita seuraavilla kierroksilla! 55/55
Kierros 1: Algoritmianalyysin ja tietorakenteiden perusteita
Kierros 1: Algoritmianalyysin ja tietorakenteiden perusteita Tommi Junttila Aalto University School of Science Department of Computer Science CS-A1140 Data Structures and Algorithms Autumn 2017 Tommi Junttila
LisätiedotA274101 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ätiedotAlgoritmit 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ätiedotTietorakenteet 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ätiedotTietorakenteet 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ätiedotAlgoritmit 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ätiedot4 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ätiedotf(n) = Ω(g(n)) jos ja vain jos g(n) = O(f(n))
Määritelmä: on O(g(n)), jos on olemassa vakioarvot n 0 > 0 ja c > 0 siten, että c g(n) kun n > n 0 O eli iso-o tai ordo ilmaisee asymptoottisen ylärajan resurssivaatimusten kasvun suuruusluokalle Samankaltaisia
LisätiedotAlgoritmit 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ätiedot811312A 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ätiedotPino 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ätiedotTieto- ja tallennusrakenteet
Tieto- ja tallennusrakenteet Sisältö Tyyppi, abstrakti tietotyyppi, abstraktin tietotyypin toteutus Tallennusrakenteet Taulukko Linkitetty rakenne Abstraktit tietotyypit Lista (Puu) (Viimeisellä viikolla)
Lisätiedot58131 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ätiedotAlgoritmit 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ätiedotAlgoritmit 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ätiedotTietorakenteet, 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ätiedotAlgoritmit 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ätiedotAlgoritmit 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ätiedotuseampi ns. avain (tai vertailuavain) esim. opiskelijaa kuvaavassa alkiossa vaikkapa opintopistemäärä tai opiskelijanumero
Alkioiden avaimet Usein tietoalkioille on mielekästä määrittää yksi tai useampi ns. avain (tai vertailuavain) esim. opiskelijaa kuvaavassa alkiossa vaikkapa opintopistemäärä tai opiskelijanumero 80 op
LisätiedotAlgoritmit 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ätiedot811312A 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ätiedotAlgoritmit 1. Luento 5 Ti Timo Männikkö
Algoritmit 1 Luento 5 Ti 24.1.2017 Timo Männikkö Luento 5 Järjestetty lista Järjestetyn listan operaatiot Listan toteutus taulukolla Binäärihaku Binäärihaun vaativuus Algoritmit 1 Kevät 2017 Luento 5 Ti
Lisätiedot2. Perustietorakenteet
2. Perustietorakenteet Tässä osassa käsitellään erilaisia perustietorakenteita, joita algoritmit käyttävät toimintansa perustana. Aluksi käydään läpi tietorakenteen abstrakti määritelmä. Tämän jälkeen
Lisätiedot18. 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ätiedotAlgoritmit 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ätiedotTietorakenteet ja algoritmit
Tietorakenteet ja algoritmit Rekursio Rekursion käyttötapauksia Rekursio määritelmissä Rekursio ongelmanratkaisussa ja ohjelmointitekniikkana Esimerkkejä taulukolla Esimerkkejä linkatulla listalla Hanoin
LisätiedotTietorakenteet 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ätiedotSisä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ätiedotALGORITMIT 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ätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 11.2.2009 T-106.1208 Ohjelmoinnin perusteet Y 11.2.2009 1 / 33 Kertausta: listat Tyhjä uusi lista luodaan kirjoittamalla esimerkiksi lampotilat = [] (jolloin
LisätiedotAlgoritmit 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ätiedotAlgoritmit 1. Luento 14 Ke 25.2.2015. Timo Männikkö
Algoritmit 1 Luento 14 Ke 25.2.2015 Timo Männikkö Luento 14 Heuristiset menetelmät Heuristiikkoja kapsäkkiongelmalle Kauppamatkustajan ongelma Lähimmän naapurin menetelmä Kertaus ja tenttivinkit Algoritmit
Lisätiedot811312A Tietorakenteet ja algoritmit, , Harjoitus 3, Ratkaisu
811312A Tietorakenteet ja algoritmit, 2018-2019, Harjoitus 3, Ratkaisu Harjoituksessa käsitellään algoritmien aikakompleksisuutta. Tehtävä 3.1 Kuvitteelliset algoritmit A ja B lajittelevat syötteenään
LisätiedotAlgoritmit 2. Luento 1 Ti Timo Männikkö
Algoritmit 2 Luento 1 Ti 14.3.2017 Timo Männikkö Luento 1 Algoritmi Algoritmin valinta Algoritmin analysointi Algoritmin suoritusaika Peruskertaluokkia Kertaluokkamerkinnät Kertaluokkien ominaisuuksia
Lisätiedot1.4 Funktioiden kertaluokat
1.4 Funktioiden kertaluokat f on kertaluokkaa O(g), merk. f = O(g), jos joillain c > 0, m N pätee f(n) cg(n) aina kun n m f on samaa kertaluokkaa kuin g, merk. f = Θ(g), jos joillain a, b > 0, m N pätee
LisätiedotTIETORAKENTEET 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ätiedotKaksiloppuinen 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ätiedot2. Seuraavassa kuvassa on verkon solmujen topologinen järjestys: x t v q z u s y w r. Kuva 1: Tehtävän 2 solmut järjestettynä topologisesti.
Tietorakenteet, laskuharjoitus 11, ratkaisuja 1. Leveyssuuntaisen läpikäynnin voi toteuttaa rekursiivisesti käsittelemällä jokaisella rekursiivisella kutsulla kaikki tietyllä tasolla olevat solmut. Rekursiivinen
Lisätiedot(p j b (i, j) + p i b (j, i)) (p j b (i, j) + p i (1 b (i, j)) p i. tähän. Palaamme sanakirjaongelmaan vielä tasoitetun analyysin yhteydessä.
Loppu seuraa suoralla laskulla: n n Tave TR = p j (1 + b (i, j)) j=1 = 1 + 1 i
LisätiedotAlgoritmit 1. Luento 10 Ke Timo Männikkö
Algoritmit 1 Luento 10 Ke 14.2.2018 Timo Männikkö Luento 10 Algoritminen ongelmanratkaisu Suunnittelumenetelmät Raaka voima Järjestäminen eli lajittelu Kuplalajittelu Lisäyslajittelu Valintalajittelu Permutaatiot
LisätiedotAlgoritmit 1. Luento 11 Ti Timo Männikkö
Algoritmit 1 Luento 11 Ti 14.2.2017 Timo Männikkö Luento 11 Algoritminen ongelmanratkaisu Osittaminen Lomituslajittelu Lomituslajittelun vaativuus Rekursioyhtälöt Pikalajittelu Algoritmit 1 Kevät 2017
LisätiedotKää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ätiedotList-luokan soveltamista. Listaan lisääminen Listan läpikäynti Listasta etsiminen Listan sisällön muuttaminen Listasta poistaminen Listan kopioiminen
1 List-luokan soveltamista List-luokan metodeja Listaan lisääminen Listan läpikäynti Listasta etsiminen Listan sisällön muuttaminen Listasta poistaminen Listan kopioiminen 1 List-luokan metodeja List-luokan
LisätiedotAlgoritmit 1. Luento 12 Ke Timo Männikkö
Algoritmit 1 Luento 12 Ke 15.2.2017 Timo Männikkö Luento 12 Pikalajittelu Pikalajittelun vaativuus Osittamisen tasapainoisuus Lajittelumenetelmien vaativuus Laskentalajittelu Lokerolajittelu Kantalukulajittelu
LisätiedotOhjelmoinnin peruskurssi Y1
Ohjelmoinnin peruskurssi Y1 CSE-A1111 30.9.2015 CSE-A1111 Ohjelmoinnin peruskurssi Y1 30.9.2015 1 / 27 Mahdollisuus antaa luentopalautetta Goblinissa vasemmassa reunassa olevassa valikossa on valinta Luentopalaute.
LisätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 2.3.2009 T-106.1208 Ohjelmoinnin perusteet Y 2.3.2009 1 / 28 Puhelinluettelo, koodi def lue_puhelinnumerot(): print "Anna lisattavat nimet ja numerot." print
Lisätiedot1.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ätiedotAbstraktit tietotyypit. TIEA341 Funktio ohjelmointi 1 Syksy 2005
Abstraktit tietotyypit TIEA341 Funktio ohjelmointi 1 Syksy 2005 Data abstraktio Abstraktio on ohjelmoinnin tärkein väline Data abstraktio abstrahoi dataa Abstrakti tietotyyppi Koostuu kolmesta asiasta:
LisätiedotA274101 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ätiedotDiskreetin matematiikan perusteet Laskuharjoitus 2 / vko 9
Diskreetin matematiikan perusteet Laskuharjoitus 2 / vko 9 Tuntitehtävät 9-10 lasketaan alkuviikon harjoituksissa ja tuntitehtävät 13-14 loppuviikon harjoituksissa. Kotitehtävät 11-12 tarkastetaan loppuviikon
Lisätiedotlä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ätiedotAlgoritmit 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ätiedot815338A Ohjelmointikielten periaatteet Harjoitus 6 Vastaukset
815338A Ohjelmointikielten periaatteet 2015-2016. Harjoitus 6 Vastaukset Harjoituksen aiheena on funktionaalinen ohjelmointi Scheme- ja Haskell-kielillä. Voit suorittaa ohjelmat osoitteessa https://ideone.com/
LisätiedotKierros 2: Järjestämisalgoritmeja
Kierros : Järjestämisalgoritmeja Tommi Junttila Aalto University School of Science Department of Computer Science CS-A4 Data Structures and Algorithms Autumn 7 Tommi Junttila (Aalto University) Kierros
Lisätiedot58131 Tietorakenteet ja algoritmit (syksy 2015)
58131 Tietorakenteet ja algoritmit (syksy 2015) Harjoitus 2 (14. 18.9.2015) Huom. Sinun on tehtävä vähintään kaksi tehtävää, jotta voit jatkaa kurssilla. 1. Erään algoritmin suoritus vie 1 ms, kun syötteen
Lisätiedot58131 Tietorakenteet (kevät 2009) Harjoitus 9, ratkaisuja (Antti Laaksonen)
58131 Tietorakenteet (kevät 2009) Harjoitus 9, ratkaisuja (Antti Laaksonen) 1. Lisäysjärjestämisessä järjestetään ensin taulukon kaksi ensimmäistä lukua, sitten kolme ensimmäistä lukua, sitten neljä ensimmäistä
LisätiedotOhjelmoinnin peruskurssien laaja oppimäärä
Ohjelmoinnin peruskurssien laaja oppimäärä Keskeneräinen luento 3: Listat (mm. SICP 22.2.3) Riku Saikkonen 31. 10. 2011 Sisältö 1 Linkitetyt listat 2 Linkitetyt listat (SICP 2.1.1, 2.2.1) funktionaalinen
LisätiedotAlgoritmianalyysin 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ätiedot811312A Tietorakenteet ja algoritmit Kertausta kurssin alkuosasta
811312A Tietorakenteet ja algoritmit 2016-2017 Kertausta kurssin alkuosasta II Algoritmien analyysi: oikeellisuus Algoritmin täydellinen oikeellisuus = Algoritmi päättyy ja tuottaa määritellyn tuloksen
LisätiedotMS-A0401 Diskreetin matematiikan perusteet
MS-A0401 Diskreetin matematiikan perusteet Osa 2: Relaatiot ja funktiot Riikka Kangaslampi Syksy 2017 Matematiikan ja systeemianalyysin laitos Aalto-yliopisto Relaatiot Relaatio Määritelmä 1 Relaatio joukosta
LisätiedotAlgoritmit 1. Demot Timo Männikkö
Algoritmit 1 Demot 1 25.-26.1.2017 Timo Männikkö Tehtävä 1 (a) Algoritmi, joka laskee kahden kokonaisluvun välisen jakojäännöksen käyttämättä lainkaan jakolaskuja Jaettava m, jakaja n Vähennetään luku
LisätiedotOhjelmoinnin peruskurssien laaja oppimäärä
Ohjelmoinnin peruskurssien laaja oppimäärä Luento 2: SICP kohdat 22.2.3 Riku Saikkonen 2. 11. 2010 Sisältö 1 Linkitetyt listat 2 Listaoperaatioita 3 Listarakenteet 4 Gambit-C:n Scheme-debuggeri Linkitetyt
LisätiedotAlgoritmit 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ätiedotTietorakenteet (syksy 2013)
Tietorakenteet (syksy 2013) Harjoitus 1 (6.9.2013) Huom. Sinun on osallistuttava perjantain laskuharjoitustilaisuuteen ja tehtävä vähintään kaksi tehtävää, jotta voit jatkaa kurssilla. Näiden laskuharjoitusten
LisätiedotKierros 6: Dynaaminen ohjelmointi ja ahneet algoritmit
Kierros 6: Dynaaminen ohjelmointi ja ahneet algoritmit Tommi Junttila Aalto University School of Science Department of Computer Science CS-A1140 Data Structures and Algorithms Autumn 2017 Tommi Junttila
Lisätiedot5 Kertaluokkamerkinnät
TIE-20100 Tietorakenteet ja algoritmit 75 5 Kertaluokkamerkinnät Tässä luvussa käsitellään asymptoottisessa analyysissa käytettyjä matemaattisia merkintätapoja Määritellään tarkemmin Θ, sekä kaksi muuta
LisätiedotLuku 3. Listankäsittelyä. 3.1 Listat
Luku 3 Listankäsittelyä Funktio-ohjelmoinnin tärkein yksittäinen tietorakenne on lista. Listankäsittely on paitsi käytännöllisesti oleellinen aihe, se myös valaisee funktio-ohjelmoinnin ideaa. 3.1 Listat
LisätiedotTietorakenteet ja algoritmit syksy Laskuharjoitus 1
Tietorakenteet ja algoritmit syksy 2012 Laskuharjoitus 1 1. Tietojenkäsittelijä voi ajatella logaritmia usein seuraavasti: a-kantainen logaritmi log a n kertoo, kuinka monta kertaa luku n pitää jakaa a:lla,
LisätiedotKierros 4: Binäärihakupuut
Kierros 4: Binäärihakupuut Tommi Junttila Aalto University School of Science Department of Computer Science CS-A1140 Data Structures and Algorithms Autumn 2017 Tommi Junttila (Aalto University) Kierros
LisätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 10.2.2010 T-106.1208 Ohjelmoinnin perusteet Y 10.2.2010 1 / 43 Kertausta: listat Tyhjä uusi lista luodaan kirjoittamalla esimerkiksi lampotilat = [] (jolloin
LisätiedotHarjoitustyö: virtuaalikone
Harjoitustyö: virtuaalikone Toteuta alla kuvattu virtuaalikone yksinkertaiselle olio-orientoituneelle skriptauskielelle. Paketissa on testaamista varten mukana kaksi lyhyttä ohjelmaa. Ohjeita Noudata ohjelman
Lisätiedot811312A Tietorakenteet ja algoritmit, , Harjoitus 5, Ratkaisu
1312A Tietorakenteet ja algoritmit, 2016-2017, Harjoitus 5, Ratkaisu Harjoituksen aihe ovat hash-taulukot ja binääriset etsintäpuut Tehtävä 5.1 Tallenna avaimet 10,22,31,4,15,28,17 ja 59 hash-taulukkoon,
LisätiedotTKT20001 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ätiedotCS-A1140 Tietorakenteet ja algoritmit
CS-A1140 Tietorakenteet ja algoritmit Kierros 2: Järjestämisalgoritmeja Tommi Junttila Aalto-yliopisto Perustieteiden korkeakoulu Tietotekniikan laitos Syksy 2016 Materiaali Kirjassa Introduction to Algorithms,
LisätiedotCS-A1140 Tietorakenteet ja algoritmit
CS-A1140 Tietorakenteet ja algoritmit Kierros 6: Dynaaminen ohjelmointi ja ahneet algoritmit Tommi Junttila Aalto-yliopisto Perustieteiden korkeakoulu Tietotekniikan laitos Syksy 2016 Materiaalia kirjassa
LisätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 1.4.2009 T-106.1208 Ohjelmoinnin perusteet Y 1.4.2009 1 / 56 Tentti Ensimmäinen tenttimahdollisuus on pe 8.5. klo 13:00 17:00 päärakennuksessa. Tämän jälkeen
LisätiedotTietorakenteet. JAVA-OHJELMOINTI Osa 5: Tietorakenteita. Sisällys. Merkkijonot (String) Luokka String. Metodeja (public)
Tietorakenteet JAVA-OHJELMOINTI Osa 5: Tietorakenteita Eero Hyvönen Tietojenkäsittelytieteen laitos Helsingin yliopisto Olioita ja tietoja voidaan organisoida määrämuotoisiksi tietorakenteiksi Hyödyllisiä
LisätiedotTietorakenteet, laskuharjoitus 1,
Tietorakenteet, laskuharjoitus 1, 19.-22.1 Huom: laskarit alkavat jo ensimmäisellä luentoviikolla 1. Taustaa http://wiki.helsinki.fi/display/mathstatkurssit/matukurssisivu Halutaan todistaa, että oletuksesta
LisätiedotAlgoritmit 1. Luento 10 Ke 11.2.2015. Timo Männikkö
Algoritmit 1 Luento 10 Ke 11.2.2015 Timo Männikkö Luento 10 Algoritminen ongelman ratkaisu Suunnittelumenetelmät Raaka voima Järjestäminen eli lajittelu Kuplalajittelu Väliinsijoituslajittelu Valintalajittelu
LisätiedotOhjelmoinnin peruskurssien laaja oppimäärä
Ohjelmoinnin peruskurssien laaja oppimäärä Luento 4: Symbolit, derivojaesimerkki, kierroksen 1 ratkaisut (mm. SICP 2.32.3.2) Riku Saikkonen 1. 11. 2011 Sisältö 1 Symbolit ja sulkulausekkeet 2 Lisää Schemestä:
LisätiedotOhjelmoinnin peruskurssien laaja oppimäärä
Ohjelmoinnin peruskurssien laaja oppimäärä Luento 5: Sijoituslause, SICP-oliot, tietorakenteen muuttaminen (mm. SICP 33.1.3, 3.33.3.2) Riku Saikkonen 6. 11. 2012 Sisältö 1 Muuttujan arvon muuttaminen:
Lisätiedot1. (a) Seuraava algoritmi tutkii, onko jokin luku taulukossa monta kertaa:
Tietorakenteet, laskuharjoitus 10, ratkaisuja 1. (a) Seuraava algoritmi tutkii, onko jokin luku taulukossa monta kertaa: SamaLuku(T ) 2 for i = 1 to T.length 1 3 if T [i] == T [i + 1] 4 return True 5 return
LisätiedotRakenteiset 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ätiedotJohdatus diskreettiin matematiikkaan Harjoitus 5, Ratkaise rekursioyhtälö
Johdatus diskreettiin matematiikkaan Harjoitus 5, 14.10.2015 1. Ratkaise rekursioyhtälö x n+4 2x n+2 + x n 16( 1) n, n N, alkuarvoilla x 1 2, x 2 14, x 3 18 ja x 4 42. Ratkaisu. Vastaavan homogeenisen
LisätiedotOperaattoreiden 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ätiedotITKP102 Ohjelmointi 1 (6 op)
ITKP102 Ohjelmointi 1 (6 op) Tentaattori: Antti-Jussi Lakanen 7. huhtikuuta 2017 Vastaa kaikkiin tehtäviin. Tee jokainen tehtävä erilliselle konseptiarkille. Kirjoittamasi luokat, funktiot ja aliohjelmat
LisätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 15.3.2010 T-106.1208 Ohjelmoinnin perusteet Y 15.3.2010 1 / 56 Tiedostoista: tietojen tallentaminen ohjelman suorituskertojen välillä Monissa sovelluksissa ohjelman
LisätiedotAlgoritmit 1. Demot Timo Männikkö
Algoritmit 1 Demot 1 31.1.-1.2.2018 Timo Männikkö Tehtävä 1 (a) Algoritmi, joka tutkii onko kokonaisluku tasan jaollinen jollain toisella kokonaisluvulla siten, että ei käytetä lainkaan jakolaskuja Jaettava
LisätiedotSTL:n uudistukset. Seppo Koivisto TTY Ohjelmistotekniikka
STL:n uudistukset Seppo Koivisto TTY Ohjelmistotekniikka 2012-05-04 Sisältö 1 Muutokset säiliöihin ja uudet säiliötyypit 2 3 4 5 STL:n säiliöt Viitteet ja osoittimet ovat muuttuneet: Allocator::reference
Lisätiedotja λ 2 = 2x 1r 0 x 2 + 2x 1r 0 x 2
Johdatus diskreettiin matematiikkaan Harjoitus 4, 7.10.2015 1. Olkoot c 0, c 1 R siten, että polynomilla r 2 c 1 r c 0 on kaksinkertainen juuri. Määritä rekursioyhtälön x n+2 = c 1 x n+1 + c 0 x n, n N,
LisätiedotKysymyksiä 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ätiedot811312A 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ätiedot7/20: Paketti kasassa ensimmäistä kertaa
Ohjelmointi 1 / syksy 2007 7/20: Paketti kasassa ensimmäistä kertaa Paavo Nieminen nieminen@jyu.fi Tietotekniikan laitos Informaatioteknologian tiedekunta Jyväskylän yliopisto Ohjelmointi 1 / syksy 2007
LisätiedotTietorakenteet 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ätiedotOhjelmoinnin perusteet Y Python
Ohjelmoinnin perusteet Y Python T-106.1208 17.2.2010 T-106.1208 Ohjelmoinnin perusteet Y 17.2.2010 1 / 41 Sanakirja Monissa sovelluksissa on tallennettava rakenteeseen avain arvo-pareja. Myöhemmin rakenteesta
LisätiedotListarakenne (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ätiedotOsoitin ja viittaus C++:ssa
Osoitin ja viittaus C++:ssa Osoitin yksinkertaiseen tietotyyppiin Osoitin on muuttuja, joka sisältää jonkin toisen samantyyppisen muuttujan osoitteen. Ohessa on esimerkkiohjelma, jossa määritellään kokonaislukumuuttuja
Lisätiedot811312A Tietorakenteet ja algoritmit , Harjoitus 2 ratkaisu
811312A Tietorakenteet ja algoritmit 2017-2018, Harjoitus 2 ratkaisu Harjoituksen aiheena on algoritmien oikeellisuus. Tehtävä 2.1 Kahvipurkkiongelma. Kahvipurkissa P on valkoisia ja mustia kahvipapuja,
LisätiedotJakso 4 Aliohjelmien toteutus
Jakso 4 Aliohjelmien toteutus Tyypit Parametrit Aktivointitietue (AT) AT-pino Rekursio 1 Aliohjelmatyypit (2) Korkean tason ohjelmointikielen käsitteet: aliohjelma, proseduuri parametrit funktio parametrit,
LisätiedotOhjelmointi 1 C#, kevät 2013, 2. tentti
ITKP102 Ohjelmointi 1 C# 15.5.2013 1 / 6 Ohjelmointi 1 C#, kevät 2013, 2. tentti Tentaattori Antti-Jussi Lakanen Tässä tentissä saa olla mukana omia muistiinpanoja yhden arkin verran. Tentin valvojalla
Lisätiedot