Algoritmusok s adatszerkezetek
This presentation is the property of its rightful owner.
Sponsored Links
1 / 24

Algoritmusok és adatszerkezetek PowerPoint PPT Presentation


  • 77 Views
  • Uploaded on
  • Presentation posted in: General

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)

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


Algoritmusok s adatszerkezetek

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

}

}


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


Algoritmusok s adatszerkezetek

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


Algoritmusok s adatszerkezetek

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

}


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)=c1egyelemű 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*nrekurzív egyenlet

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


  • Login