algoritmusok s adatszerkezetek
Download
Skip this Video
Download Presentation
Algoritmusok és adatszerkezetek

Loading in 2 Seconds...

play fullscreen
1 / 24

Algoritmusok és adatszerkezetek - PowerPoint PPT Presentation


  • 119 Views
  • Uploaded on

Algoritmusok és adatszerkezetek. PTE-TTK 2008. ősz. Kilián Imre H-7683 Gyűrűfű Cseresznyéskert (20-6655951 ritkán használható) [email protected] Tantárgykövetelmények. Vizsga: szóbeli. (Írásbeli /gépi/ utóvizsga a vizsgaidőszak utolsó hetében)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Algoritmusok és adatszerkezetek' - fisk


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
algoritmusok s adatszerkezetek

Algoritmusok és adatszerkezetek

PTE-TTK 2008. ősz

Kilián Imre

H-7683 GyűrűfűCseresznyéskert(20-6655951 ritkán használható)

[email protected]

tant rgyk vetelm nyek
Tantárgykövetelmények
  • Vizsga: szóbeli. (Írásbeli /gépi/ utóvizsga a vizsgaidőszak utolsó hetében)
  • Gyakjegy: az órákon C nyelvű programokat kell írni, kiegészíteni
algoritmus
Algoritmus
  • Recept
  • Számítási eljárás
  • Filozófia, ami leír
    • Megoldható feladatokat
    • Megfogalmazható problémákat
    • Kifejezhető gondolatokat
  • Fekete doboz

Bemenet-> ALGORITMUS ->Kimenet

algoritmus specifik ci ja
Algoritmus specifikációja
  • Algoritmus: egy függvény, amely
    • Bemenete: értelmezési tartomány (adatszerkezet)
    • Kimenete: az értékkészlet (adatszerkezet)
    • Specifikáció: a függvény definíciója, amely megadja, hogy milyen bemenethez milyen kimenetet kell előállítania.
  • Pl. rendezés: x1,…,xn bemenethez előállítja az x1’,…,xn’ sorozatot, ami a bemenet permutációja, és x1’<=x2’,…,xn-1’<=xn’
algoritmus kifejez se megfogalmaz sa
Algoritmus kifejezése/megfogalmazása
  • Természetes nyelven
  • Pszeudokóddal
  • Blokkdiagrammal
  • Tervezési nyelvvel (UML)
  • Programnyelvvel

Adott specifikációhoz többféle megfogalmazás (megvalósítás) is létezhet

slide6
Természetes nyelven (pongyola kifejezés):
    • Pl. Két szám maximuma: tfh, az első a maximum. Ha a második szám az elsőnél nagyobb lenne, akkor a második a maximum.
  • Pszeudokód (kicsit pongyola)
    • blokkszerkezet (behúzással jelölve)
    • Algol szerű vezérlés
    • Változók, tömbök
    • Objektum-orientált/klasszikus szemlélet
    • Részben természetes nyelv
besz r rendez s pszeudok dja
Beszúró Rendezés pszeudokódja

for j=2 to V.hossza

do kulcs=V(j)

i=j-1

while i>0 és V(i)>kulcs

do V(i+1)=V(i)

i=i-1

V(i+1)=kulcs

besz r rendez s java nyelven
Beszúró Rendezés Java nyelven

public static void BeszuroRendezes(int[] vektor) {

if (vektor.length>1)

for (int j=1; j

int kulcs = vektor[j];

int i=j-1;

while (i>0 && vektor[i]>kulcs) {

vektor[i+1] = vektor[i];

i--;

}

vektor[i+1] = kulcs;

}

}

uml tev kenys g blokk diagram folyamat bra pl besz r rendez s
UML Tevékenység- Blokk-diagram (Folyamatábra) pl: Beszúró rendezés

Bemenet

Elemi részfolyamat

Döntés

Részfolyamat

Vége

llapotdiagram uml besz r rendez s
Állapotdiagram (UML)Beszúró Rendezés

Állapotátmenet[Feltétel]

Állapotok

slide11
Unified Modelling Language
    • Object Management Group (www.omg.org)
    • szabványnak tekinthető tervezési módszertan
    • CASE eszközök (Rational Rose, Visio, NetBeans, stb.)
  • Programnyelvek
    • Blokkszerkezetű/strukturált nyelvek (Algol, Pascal, C, Java, VB)
    • Objektum-orientált nyelvek (Smalltalk, C++, OO-Pascal, Java, VB)
    • Nem hagyományos/újelvű nyelvek (LISP, Prolog)
  • Előadáspéldák: Pszeudokód, Java, VB, (Prolog)
slide12
Szekvenciális algoritmusok tervezési módszerei:((Szuperpárhuzamos))(sejtautomaták, neurális hálók)1. Felbontás (dekompozíció)
  • Felbontás részalgoritmusokra
    • Pl. Palacsintasütés: Tésztakeverés, kisütés.
    • Házépítés: alapozás, falazás, tető, burkolás.
  • Algoritmus=részalgoritmusok+vezérlés.
  • Elemi algoritmusok: tovább már nem bonthatók/amelyek az adott programnyelven egyetlen utasítással megfogalmazhatók.
r szalgoritmusok vez rl se
Részalgoritmusok vezérlése
  • Egymásután következés (szekvencia)
  • Feltételes elágazás (if)
  • Ciklusok (while, for)
  • Részalgoritmus hívás
  • Stb…
2 rekurzi nhivatkoz s
2. Rekurzió (önhivatkozás)
  • Rekurzív programozás elvei:
    • A legegyszerűbb esetre megoldást adunk
    • A feladatot felbontjuk két vagy több, egyszerűbben, de UGYANILYEN MÓDON megoldható esetre (rekurzív hívás)

public static int CFactorial(int n) {

int fac=1;

for (int i=1; i<=n; i++)

fac = fac*i;

return fac;

}

public static int RFactorial(int n) {

if (n==0) return 1;

return RFactorial(n-1)*n;

}

3 indukci n vekm nyes
3. Indukció (növekményes)
  • Lineáris szerkezetekre (listákra, vektorokra stb., egész számokra) alkalmas
  • Az indukció hasonlít a rekurzióra, de egyszerűbb
    • A legegyszerűbb esetre megoldást adunk
    • Más eseteket visszavezetünk az eggyel egyszerűbb esetekre
4 divide et impera oszd meg s uralkodj
4. „Divide et impera” - Oszd meg és uralkodj
  • Felosztjuk a problémát két vagy több (közel egyenlő súlyú/bonyolultságú) részproblémára
  • Uralkodunk: amikor a részproblémákat megoldjuk
  • Összevonjuk a részproblémák megoldásának eredményeit az eredeti probléma eredményévé
mi a k l nbs g
Mi a különbség?
  • Ciklusos megoldás: Lineáris szerkezetekre, hagyományos megoldás
  • Divide et impera: nem lineáris szerkezetekre, a felosztás egyenlő súly alapján történik
  • Rekurzió: mindezek technikai megoldása
    • helyettesítheti a ciklusos megoldást is
    • megvalósíthatja az „oszd meg és uralkodj” elvet is
oszd meg s uralkodj pl sszef s l rendez s
Oszd meg és uralkodj: Pl. Összefésülő rendezés
  • A listát megfelezzük
  • Az első részlistát összefésülve rendezzük
  • A második részlistát összefésülve rendezzük
  • A 2 és 3 pontok eredményeit összefésüljük.
  • Az összefésülés eredménye a rendezett lista
algoritmusok elemz se hat konys gvizsg lat
Algoritmusok elemzése (Hatékonyságvizsgálat)
  • Cél: az algoritmus futásához szükséges erőforrások/költség előrejelzése
    • Számítási/futási idő (elemi lépések száma)
    • Tárigény
    • Sávszélesség
    • Minimális processzorsebesség stb.
  • Feladatok:
    • Legrosszabb eset (worst case)
    • Átlagos eset (várható érték)
    • Növekedési rend
tipikus hib k
Tipikus hibák
  • Futási idő alulbecslése
  • Tárterület alulbecslése
  • Fogalom: kombinatorikai robbanás (sakktábla)

Növekedési rend

  • Költség becslése (leggyakrabban) a bemenő adatok (leggyakrabban méretének) függvényében
  • Elsősorban nagyon nagy változóértékekre
  • Konstans szorzótényezőtől függetlenül
  • Legmagasabb kitevőjű tagra
  • Jelölés (több is van): Θ(f(bemenet))
  • Pl. Θ(n2), Θ(log(n)), Θ(an)
besz r rendez s bra
Beszúró rendezés (ábra)
  • 5 - 2 6 4 1 3 2 6
  • 2 5 – 6 4 1 3 2 6
  • 2 5 6 – 4 1 3 2 6
  • 2 4 5 6 – 1 3 2 6
  • 1 2 4 5 6 – 3 2 6
  • 1 2 3 4 5 6 – 2 6
  • 1 2 2 3 4 5 6 - 6

Sebessége attól is függ, hogy mennyire rendezett a bemeneti lista…

Ha teljesen, akkor T(n) = Θ(n)

Egyébként: T(n) = Θ(n2)

besz r rendez s hat konys gvizsg lata
Beszúró rendezés hatékonyságvizsgálata

Ciklus időszükséglete (ha a ciklusszám=bemenő hossz):

T(n) = (c1+c2)+ (c1+c2*2) + … + c1+(c2*(n-1)) = c1*(n-1) +c2*(1+2+…+(n-1)) = c1*(n-1)+c2*n*(n-1)/2 = Θ(n2)

T(n) = c1*n * Tciklusmag(n)

Tciklusmag(n) = c2*n/2

T(n) = c1*c2/2*n*n

 T(n) = Θ(n2)

négyzetes algoritmus

for (int j=1; j

int kulcs = vektor[j];

int i=j-1;

while (i>0 && vektor[i]>kulcs) {

vektor[i+1] = vektor[i];

i--;

}

vektor[i+1] = kulcs;

}

sszef s l rendez s bra
Összefésülő rendezés (ábra)

1, 2, 2, 3, 4, 5, 6, 6

1, 2, 3, 6

2, 4, 5, 6

2, 6

2, 5

4, 6

1, 3

5

2

6

4

1

3

2

6

sszef s l rendez s hat konys gvizsg lata
Összefésülő rendezés hatékonyságvizsgálata
  • Idő/sorozathossz függvény T(n)
    • T(1)=c1 egyelemű sorozat rendezése állandó
    • Tfelosztás(n)=c2 sorozat felosztása állandó
    • Turalkodás(n)=2*T(n/2) 2*félsorozat ideje
    • Tösszefésül(n)=c3*n

T(1) = c1.

T(n) = c2+2T(n/2)+ c3*n rekurzív egyenlet

T(n) = Θ (n*log(n)) bizonyítás nélkül

ad