1 / 24

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ó) kilian@gamma.ttk.pte.hu. Tantárgykövetelmények. Vizsga: szóbeli. (Írásbeli /gépi/ utóvizsga a vizsgaidőszak utolsó hetében)

fisk
Download Presentation

Algoritmusok és adatszerkezetek

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Algoritmusok és adatszerkezetek PTE-TTK 2008. ősz Kilián Imre H-7683 GyűrűfűCseresznyéskert(20-6655951 ritkán használható) kilian@gamma.ttk.pte.hu

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

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

  4. 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’

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

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

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

  8. Beszúró Rendezés Java nyelven public static void BeszuroRendezes(int[] vektor) { if (vektor.length>1) for (int j=1; j<vektor.length; 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; } }

  9. UML Tevékenység- Blokk-diagram (Folyamatábra) pl: Beszúró rendezés Bemenet Elemi részfolyamat Döntés Részfolyamat Vége

  10. Állapotdiagram (UML)Beszúró Rendezés Állapotátmenet[Feltétel] Állapotok

  11. 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)

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

  13. 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…

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

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

  16. 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é

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

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

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

  20. 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)

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

  22. 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<vektor.length; 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; }

  23. Ö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

  24. Ö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

More Related