Algoritmusok és adatszerkezetekPTE-TTK 2008. ősz

Kilián ImreKilián ImreH-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)

• Gyakjegy: az órákon C nyelvű programokat kell írni, kiegészíteni

Algoritmus

• Recept• Számítási eljárás• Filozófia, ami leír

– Megoldható feladatokat– Megfogalmazható problémákat– Kifejezhető gondolatokat

• Fekete dobozBemenet-> ALGORITMUS ->Kimenet

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

• 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

• 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

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

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

x1,...,xnszámsorozat

rendezett ésrendezetlen

szétválasztása

Készvan még

rendezetlen?nincs

Következőrendezetlen elem

van

Elembeszúrása arendezettek

közé

Bemenet

Elemi részfolyamat

Részfolyamat

Döntés

Vége

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

Kezdet

RendezettÉsRendezetlenSzétválasztva

Kész

ElsőRendezetlenLeválasztva

befejezés[ Rendezetlen üres ]

ElsőRendezetlenLeválasztása[ Rendezetlen nem üres ]

ElemBeszúrása

Állapotok

Állapotátmenet[Feltétel]

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

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

Alapozás

Falazás

Tető

Burkolás

AlapKész

FalKész

TetőKész

Burkolat kész

Kezdet

Kész

1. Egymásután következés (szekvencia)

2. Feltételes elágazás (if)3. Ciklusok (while, for)4. Részalgoritmus hívás5. Stb…

2. Rekurzió (önhivatkozás)

• Rekurzív programozás elvei:1. A legegyszerűbb esetre megoldást adunk

2. A feladatot felbontjuk két vagy több, egyszerűbben, de UGYANILYEN MÓDON megoldható esetre (rekurzív hívás)

public static int RFactorial(int n) {

if (n==0) return 1;

return RFactorial(n-1)*n;

}

public static int CFactorial(int n) {

int fac=1;

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

fac = fac*i;

return fac;

}

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

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

1. A listát megfelezzük2. Az első részlistát összefésülve rendezzük3. A második részlistát összefésülve

rendezzük4. A 2 és 3 pontok eredményeit

összefésüljük.5. Az összefésülés eredménye a rendezett

lista

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

• 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

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;

}

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

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

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

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

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

5 2 6 4 1 3 2 6

Összefésülő rendezés hatékonyságvizsgálata

• Idő/sorozathossz függvény T(n)1. T(1)=c1 egyelemű sorozat

rendezése állandó

2. Tfelosztás(n)=c2 sorozat felosztása állandó

3. Turalkodás(n)=2*T(n/2) 2*félsorozat ideje

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