Algoritmusok és adatszerkezetek

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