NEUMANN JÁNOS INFORMATIKAI KAR Sergyán Szabolcs Algortmusok, adatszerkezetek I. ÓE-NIK 5014 Budapest, 2015.
Készült az Óbuda Egyetem án az ÓE-NIK 5014. sz. jegyzetszerződés kereten belül 2014-ben. Szerző: Dr. Sergyán Szabolcs egyetem docens sergyan.szabolcs@nk.un-obuda.hu Lektor: Dr. Vámossy Zoltán egyetem docens vamossy.zoltan@nk.un-obuda.hu 2.0.3. verzó 2016. február 16. A jegyzet legfrssebb változata letölthető az alább címről: http://users.nk.un-obuda.hu/sergyan/programozas1jegyzet.pdf Ez a jegyzet L A TEX segítségével készült. Copyrght c Sergyán Szabolcs, 2015 A mű egyén tanulmányozás céljára szabadon letölthető. Mnden egyéb felhasználás csak a szerző írásos engedélyével lehetséges.
Tartalomjegyzék Bevezetés 4 1. Algortmusok alapja 6 1.1. Algortmus fogalma........................................ 6 1.2. Változók, típusok és kfejezések................................. 8 1.3. Tömbök.............................................. 10 1.4. Vezérlés szerkezetek....................................... 11 1.5. Algortmusok leírása, pszeudokód................................ 15 1.6. Hatékonyság, futás dő elemzése................................ 17 2. Programozás tételek 20 2.1. Egyszerű programozás tételek.................................. 21 2.1.1. Sorozatszámítás programozás tétel........................... 21 2.1.2. Eldöntés programozás tétel............................... 23 2.1.3. Kválasztás programozás tétel............................. 27 2.1.4. Lneárs keresés programozás tétel........................... 28 2.1.5. Megszámlálás programozás tétel............................ 31 2.1.6. Maxmumkválasztás programozás tétel........................ 33 2.2. Összetett programozás tételek................................. 35 2.2.1. Másolás programozás tétel............................... 35 2.2.2. Kválogatás programozás tétel............................. 37 2.2.3. Szétválogatás programozás tétel............................ 41 2.2.4. Metszet programozás tétel............................... 50 2.2.5. Unó programozás tétel................................. 54 2.2.6. Összefuttatás programozás tétel............................ 61 2.3. Programozás tételek összeépítése................................ 67 2.3.1. Másolás és sorozatszámítás összeépítése........................ 68 2.3.2. Másolás és maxmumkválasztás összeépítése..................... 70 2.3.3. Megszámolás és keresés összeépítése.......................... 74 2.3.4. Maxmumkválasztás és kválogatás összeépítése.................... 76 2.3.5. Kválogatás és sorozatszámítás összeépítése...................... 80 2.3.6. Kválogatás és maxmumkválasztás összeépítése................... 82 2.3.7. Kválogatás és másolás összeépítése........................... 85 3. Rendezések 87 3.1. Egyszerű cserés rendezés..................................... 89 3.2. Mnmumkválasztásos rendezés................................. 92 3.3. Buborékrendezés......................................... 97 3.4. Javított buborékrendezés.................................... 101 3.5. Bellesztéses rendezés....................................... 105 3.6. Javított bellesztéses rendezés.................................. 109 3.7. Shell rendezés........................................... 114 1
4. Rekurzív algortmusok 121 4.1. Faktoráls számítás....................................... 122 4.2. Rekurzív algortmusok jellemző................................. 126 4.3. Fbonacc sorozat......................................... 127 4.4. Hatványozás rekurzívan..................................... 131 4.5. Hano tornya........................................... 135 4.6. Egyszerű programozás tételek rekurzív megvalósítása.................... 139 4.6.1. Sorozatszámítás..................................... 139 4.6.2. Lneárs keresés...................................... 144 4.6.3. Megszámlálás....................................... 147 4.6.4. Maxmumkválasztás................................... 152 5. Rendezett tömbök 157 5.1. Keresések rendezett tömbökben................................. 158 5.1.1. Lneárs keresés...................................... 159 5.1.2. Logartmkus keresés................................... 161 5.2. Programozás tételek rendezett tömbökben.......................... 173 5.2.1. Eldöntés.......................................... 174 5.2.2. Kválasztás........................................ 176 5.2.3. Kválogatás........................................ 177 5.2.4. Megszámlálás....................................... 181 5.3. Halmazok............................................. 182 5.3.1. Halmaztulajdonság vzsgálata.............................. 183 5.3.2. Halmaz létrehozása.................................... 184 5.3.3. Tartalmazás vzsgálata.................................. 186 5.3.4. Részhalmaz........................................ 187 5.3.5. Unó............................................ 190 5.3.6. Metszet.......................................... 191 5.3.7. Különbség......................................... 192 5.3.8. Szmmetrkus dfferenca................................. 193 6. Oszd meg és uralkodj! elvű algortmusok 195 6.1. Maxmumkválasztás....................................... 196 6.2. Összefésülő rendezés....................................... 203 6.3. Gyorsrendezés........................................... 209 6.4. A k-adk legksebb elem kválasztása.............................. 218 7. Optmalzálás problémák 222 7.1. Dnamkus programozás..................................... 224 7.1.1. 0-1 hátzsák probléma.................................. 225 7.1.2. A dnamkus programozás elve............................. 230 7.1.3. Leghosszabb közös részsorozat............................. 231 7.2. Mohó algortmusok........................................ 238 7.2.1. Pénzkfzetés....................................... 239 7.2.2. 0-1 hátzsák probléma.................................. 241 7.2.3. Mohó algortmus szemben a dnamkus programozással................ 244 7.2.4. Mohó stratéga...................................... 250 7.2.5. Ütemezés feladatok................................... 251 8. Kupacrendezés 258 8.1. Defnícók............................................. 259 8.2. Kupacolás............................................. 263 8.3. Kupac építése........................................... 267 8.4. Kupac rendezése......................................... 270 Magyar-angol szótár 275 Sergyán Szabolcs 2 Óbuda Egyetem
Angol-magyar szótár 277 Sergyán Szabolcs 3 Óbuda Egyetem
Bevezetés Ez a jegyzet az Óbuda Egyetem án Mérnök nformatkus alapszakon tanuló hallgatók számára készült. A jegyzet a Programozás I. első féléves tárgyhoz íródott. A tárgy célja a hallgatók algortmkus gondolkodásának fejlesztése, a leggyakrabban használt alapvető algortmusok megsmertetése, valamnt a C# programozás nyelv alapjanak megsmerése. Jelen jegyzet ebből a három célból csak az első kettő elérésében nyújt segítséget a hallgatóknak. Ezért konkrét programozás nyelvvel nem s foglalkozk, a közölt algortmusok programozás nyelv mplementácóját nem adja meg. A C# programnyelv részletes smertetése számos magyar vagy angol nyelvű szakkönyvben megtalálható, lletve egy konkrétan ezzel foglalkozó később jegyzet témája lehet. A jegyzet anyaga nagy mértékben lefed az előadásokon smertetésre kerülő algortmusokat. Az előadások látogatása vszont a jegyzet anyagának megértése és elsajátítása mellett s szükséges, hszen az előadó ott tud rámutatn a legfontosabb összefüggésekre. A jegyzetben mnden algortmus azonos módszerrel kerül leírásra. Az egyes algortmusok bemutatása a megoldandó probléma smertetésével kezdődk. Ezt követ a megoldásra javasolt módszer szöveges kfejtése, a tervezett algortmus lépésenek nagy vonalakban történő smertetése. Ezután pszeudokód formátumban bemutatásra kerül a konkrét algortmus, a bemenet és kmenet változók megadása mellett. A pszeudokód mnden egyes utasítását szövegesen s leírjuk, hogy jól érthető legyen, melyk lépésnek pontosan m a szerepe. Az algortmus alapos bemutatását követően egy konkrét példán keresztül s véggvezetjük az algortmus működését. A példák nyomon követését szolgálják az egyes lépések eredményet bemutató ábrasorozatok. Az algortmus leírását a futás dő elemzésével zárjuk. A tananyag elsajátítása érdekében az alább feldolgozás módszer követését ajánljuk. A szorgalm dőszakban az egyes előadások előtt szükséges egyszer átolvasn az előadáson smertetésre kerülő anyagot, hogy az előadás keretében a hallgató valóban az összefüggések megértésére tudja a fgyelmét összpontosítan. Az előadást követően az algortmusok újból átnézését javasoljuk akár számos példa megoldásán keresztül. A jegyzetben közölt mntapéldák mellett érdemes más feladatokon s véggkövetn az egyes algortmusok működését. Így a hallgató meggyőződhet arról, hogy más esetekben s helyes megoldást szolgáltat a megsmert módszer. A vzsgákra készülve ajánlott a jegyzet alapos véggolvasása, mnden algortmus működés elvének megértése, az algortmusok memorzálása. A vzsga előtt napokban célszerű az algortmusok pszeudokódjat még egyszer tüzetesen átnézn, azokat vakon reprodukáln. Amennyben az olvasó hbát talál a jegyzetben, kérjük, hogy azt a szerző felé jelezze. Ha valam nehezen érthető, valamely téma mélyebb kfejtést, vagy más megközelítést követő leírást kíván, akkor ezt s jelezze a szerző felé. Közös célunk, hogy olyan jegyzet kerüljön az olvasó kezébe, am a tananyag megértését és elsajátítását szolgálja. A jegyzet felépítése Az 1. fejezetben az algortmusok alapjat smertetjük. Elsőként defnáljuk, hogy mt s értünk algortmus alatt, majd bevezetjük az ezek leírásához szükséges változók, típusok és kfejezések fogalmát. Bemutatásra kerül az s, hogy mként írjuk le ezeket a fogalmakat a jegyzetben használt pszeudokódokban. Ezt követően defnálunk egy összetett adatszerkezetet, a tömböt. A tömbök feldolgozása képez lényegében a jegyzet teljes anyagát. Bevezetjük az algortmusokban használt vezérlés szerkezeteket, valamnt megadjuk ezek pszeudokóddal történő leírás módját. Ezt követően összegezzük a pszeudokódokkal kapcsolatos megállapításokat, majd megadjuk azt a leírás módot, amt a jegyzet tovább részeben követünk. A fejezet végén az algortmusok futás dejének elemzés módszerét mutatjuk be. A 2. fejezetben a leggyakrabban előforduló problémákra adunk hatékony megoldás módszereket, melyeket programozás tételeknek nevezünk. Ismertetésre kerül hat egyszerű, valamnt hat összetett 4
programozás tétel. A fejezet végén leírunk néhány olyan esetet, amkor két programozás tétel összeépítésével tudunk egy problémát megoldan. A programozás gyakorlatban gyakran előforduló probléma, hogy egy tömbben tárolt értékeket rendezn kell. Számos rendező algortmust dolgoztak k, melyek közül a legsmertebb elem módszereket mutatjuk be a 3. fejezetben. Az smertetésre kerülő hét algortmus közül általában csak négyet használnak, de ddaktka szempontból fontosnak érezzük mndegyk bemutatott algortmus megsmerését. A 4. fejezetben bevezetjük a rekurzó fogalmát. Bemutatunk néhány algortmust annak érdekében, hogy a hallgató megértse a rekurzív algortmusok működését, lássa azok előnyet és hátrányat. A fejezet végén leírjuk, hogy a korábban már megsmert egyszerű programozás tételek mként valósíthatók meg rekurzív módon. Az 5. fejezetben rendezett tömbök feldolgozásával foglalkozunk. Bemutatjuk, hogy lyen tömbök esetén mként lehetséges hatékony keresést megvalósítan. Néhány programozás tétel esetén smertetjük, hogy a tömb rendezettsége mellett hogyan tudjuk a probléma megoldásának futás dejét javítan. A fejezet végén pedg bemutatunk egy módszert halmazok ábrázolására és smertetjük a halmazokkal kapcsolatos műveletek megvalósításat. A 6. fejezetben a tömböknek egy olyan feldolgozás módját mutatjuk be, mely lényegesen különbözk a korább fejezetekben smertetett módszerektől. Az Oszd meg és uralkodj! néven smert megközelítés a tömbök rekurzív feldolgozásának egy specáls módját adja. A fejezetben egy konkrét programozás tétel megvalósítását mutatjuk be az új módszerrel, majd két hatékony és széles körben használt rendező algortmust smertetünk. A fejezet végén egy specáls kválasztás problémát s megoldunk. A jegyzet 7. fejezetében ún. optmalzálás problémákat oldunk meg. A fejezet célja, hogy a hallgatók megsmerjenek specáls probléma megoldás módszereket s. Két megközelítés kerül bemutatásra: a dnamkus programozás módszer és a mohó stratéga. Az utolsó fejezetben egy specáls adatszerkezetre, a kupacra épülő rendezés módszert mutatunk be. Ez a fejezet már előre mutat a Programozás II. tárgy rányába, hszen tovább adatszerkezetek ott kerülnek smertetésre. A jegyzetben mnden fogalmat a magyar elnevezésével írunk le. Annak érdekében, hogy az angol nyelvű szakrodalom megértésében segítsük a hallgatót a legfontosabb fogalmak angol megfelelőt az első előfordulásuknál lábjegyzetben közöljük. A jegyzet végén ks szótárba gyűjtöttük az smertetett fogalmakat. A korább évek előadás anyaganak kdolgozása, valamnt a jegyzet írása során számos magyar és angol nyelvű szakrodalmat smertünk meg és dolgoztunk fel. Ezeket a jegyzet végén található rodalomjegyzékben gyűjtöttük össze. Ha valak mélyebben kívánja megsmern a bemutatott algortmusokat, akkor javasolt az ajánlott szakrodalmak tovább tanulmányozása. Köszönetnylvánítás A Programozás I., lletve korábban Algortmusok, adatszerkezetek, objektumok előadásokat három éven keresztül tartottam Dr. Vámossy Zoltánnal közösen. A tárgyat Dr. Csnk Lászlótól vettem át, ak kdolgozta a tárgy alapjat. Ezek ks módosításával érlelődött k az a tananyag, am a jegyzetben leírásra került. Köszönöm Csnk tanár úr tantárgy kalakítás munkáját, a tőle megörökölt tananyagot, módszereket. Dr. Vámossy Zoltán az elmúlt három évben végg követte előadásamat, melyekre adott értékes észrevétele beépültek az anyagba. Ezen kívül a dnamkus programozás módszer előadását ő tartja, így a jegyzetben közölt anyagot s ő dolgozta k. A jegyzetet lektorálta, számos javítás javaslatot fogalmazott meg, amelyek segítettek abban, hogy lyen formában álljon elő a jegyzet. Köszönetet mondok mndezért a munkáért. A Programozás I. tárgyat követ a másodk félévben a Programozás II. A két tárgy tematkáját, egymásra épülését Dr. Szénás Sándorral dolgoztuk k. Ezen mű születésével együtt ő s megírta az Algortmusok, adatszerkezetek II. jegyzetet. Az egységes tárgyalásmód érdekében számos témában egyeztettünk, öröm volt vele együtt dolgozn. Köszönet a sok segítségért, amt tőle kaptam. Szeretnék még köszönetet mondan az Alkalmazott Informatka Intézet munkatársa közül Bedők Dávdnak, Cser Orsolya Eszternek, Dr. Erdély Krsztnának, Kertész Gábornak, Kss Dánelnek, Légrád Gábornak, Smon-Nagy Gabrellának, Nagy Tbor Istvánnak, Szabó Zsoltnak, Szántó Balázsnak és Urbán Andrásnak, akk a Programozás I. tárgy laborjat tartották. Számos értékes észrevételt fogalmaztak meg az előadások tananyagával kapcsolatban, amelyek beépültek a jegyzetbe s. Sergyán Szabolcs 5 Óbuda Egyetem
1. fejezet Algortmusok alapja 1.1. Algortmus fogalma Algortmusokkal 1 az élet számos területén találkozhatunk. Például, amkor elmegyünk autót mosatn, akkor egy adott algortmus fut le. Kfzetjük a mosás árát, amért kapunk egy mágneskártyát. Beállunk az autómosóba, majd a mágneskártyát behelyezzük egy termnálba és megnyomjuk a start gombot. Ekkor elndul az alább folyamat. 1. Előmosás. Az autót mosószeres lével besprccelk. 2. Kefés mosás. A forgó kefék letsztítják az autót. 3. Öblítés. Az autót tszta vízzel leöblítk. 4. Szárítás. Az autót levegő áramoltatással megszárítják. Természetesen ez a folyamat lehet ennél sokkal bonyolultabb s, hszen különböző programokra fzethetünk elő. Ilyenkor az egyes végrehajtandó tevékenységek megvalósulása attól függ, hogy mlyen programot választottunk. Nézzünk erre s egy példát: 1. Ha aktívhabos mosásra fzettünk elő, akkor az autót besprccelk aktív habbal. Különben csak mosószeres lével sprccelk be az autót. 2. Ha alváz mosásra s előfzettünk, akkor az alvázat s véggsprccelk aktív habbal. 3. Ha kerékmosásra előfzettünk, akkor forgó kefék letsztítják az autót, a kerekeknél pedg specáls keréktsztító kefék mossák a kerekeket. Különben csak a forgó kefék letsztítják az autót. 4. Az autót tszta vízzel leöblítk. 5. Ha előfzettünk vaszvédelemre, akkor az autót forró vasz réteggel bevonják. 6. Az autót levegőáramoltatással megszárítják. Látható, hogy ez az algortmus már döntéseket s tartalmaz, hszen annak függvényében, hogy mlyen programot választottunk más-más történk az autómosás során. Az előbb példához hasonlóan számos továbbt tudunk mondan arra, hogy a mndennapokban hol és mlyen algortmusokkal találkozhatunk. Érdemes megsmernünk, hogy m volt az első olyan algortmus, amelyre azt mondták, hogy az valóban algortmusnak teknthető. Az első lyen algortmust az ókor görögöknél találhatjuk meg. Eukldész alkotta meg azt a módszert, amely két poztív egész számról meghatározza a legnagyobb közös osztójukat. Ezt az eljárást ma Eukldesz algortmusnak nevezzük, és a következőt mondja k. 1. Adott két poztív egész szám, jelöljük ezeket m-mel és n-nel. A kettő közül legyen m a nagyobbk. 2. Osszuk el m-et n-nel, az osztás maradékát jelöljük r-rel. 1 Angolul: algorthm 6
3. Ha r értéke 0, azaz m osztható n-nel, akkor az algortmus végére értünk. Ilyenkor a két szám legnagyobb közös osztója az n értékével egyezk meg, az algortmus pedg befejeződk. 4. Ha r értéke nem 0, akkor m-be tároljuk el az n jelenleg értékét, n-be pedg az r értékét. Majd ugorjunk vssza a 2. pontra. 1.1. Példa. Az előbb bemutatott Eukldesz algortmus használatával nézzük meg, hogy m lesz az m = 150 és az n = 36 számok legnagyobb közös osztója. Az algortmus 2. pontja alapján el kell osztanunk m-et n-nel. 150-ben 4-szer van meg a 36, a maradék pedg 6. Ezért az r-be eltároljuk a 6-ot. Az algortmus 3. pontjára lépünk, megvzsgáljuk, hogy r értéke 0-e. Mvel nem nulla, ezért továbblépünk a 4. pontra. Az m-et felülírjuk, mostantól 36 lesz benne eltárolva. Az n értékét s módosítjuk, ez 6 lesz. Ezután vsszaugrunk az algortmus 2. pontjára. Elosztjuk a 36-ot 6-tal. Az eredmény 6 lesz, a maradék pedg 0. Így r-be a 0 értékét tároljuk el. A 3. sorba lépve megvzsgáljuk r értékét. Mvel r = 0, ezért leáll az algortmus futása és eredményül megkapjuk az n-ben eltárolt aktuáls értéket tehát a 6-ot. Ez az érték a 150 és a 36 legnagyobb közös osztója. Az eddg példák fgyelembe vételével jó lenne megfogalmazn, hogy mt s tekntünk algortmusnak, egy algortmusnak mlyen elvárásokat kell teljesítene. Az algortmus teknthető egy olyan gép -nek, amely valamlyen bemenetekből meghatározott lépéseken keresztül előállít valamlyen kmenetet. A bemenetek 2 természetesen az algortmus elején már smertek. Az Eukldesz algortmus bemenete például a két poztív egész szám, melyek legnagyobb közös osztóját akarjuk megsmern. A kmenetek 3 a bemenetek által egyértelműen meghatározottak. Olyan nem állhat elő, hogy egy algortmus ugyanazon bemenetek esetén más-más kmenetet produkál. Ez úgy s kfejezhető, hogy az algortmus működése jól meghatározott, azaz az algortmus determnsztkus. Fontos még, hogy az algortmus egyértelmű, jól defnált lépésekből áll, melyek száma mnden esetben véges. Ha végtelen lépést s megengednénk, akkor az algortmus leállása nem lenne bztosítva. 2 Angolul: nput 3 Angolul: output Sergyán Szabolcs 7 Óbuda Egyetem
1.2. Változók, típusok és kfejezések Ahogy azt az Eukldesz algortmus példáján láttuk, szükséges lehet, hogy az algortmus bemenetet, lletve a futása közben előálló értékeket, ezek módosulásat valamlyen módon eltároljuk. Ezt a célt szolgálják az ún. változók 4. Mnden algortmusban használt változónak van valamlyen neve, amellyel egyértelműen azonosítan tudjuk. Azok a változók, amelyek már az algortmus kezdetén valamlyen értéket tárolnak, az algortmus bemenet változó, vagy rövden bemenete. A bemenet változók értéke s módosíthatók az algortmus futása során. Léteznek olyan változók, amelyek csak az algortmuson belül műveletek elvégzése matt szükségesek, ezek az ún. lokáls változók 5. Vannak olyan változók, amelyekben az algortmus eredményeként előálló értékeket tároljuk, lletve ezeket adja vssza az algortmus a külvlág felé. Ezek a változók a kmenet változók, vagy rövden kmenetek. A változóknak típusa 6 s van. Ez főként az egyes programozás nyelvekben fontos, mert ez alapján tudja a programozás nyelv értelmezője, lletve fordítója, hogy az adott változó számára mlyen méretű memórát kell lefoglaln a bztonságos működés érdekében. Az algortmusok leírásánál a típusokat lazább módon kezeljük, mnt konkrét programozás nyelv mplementácók esetén. Megjegyzés Az fordító készít el az algortmust leíró, általában magasabb szntű programozás nyelven megírt forrás kódból azt a gép kódú programot, amt a számítógép utasításként megért és végrehajt. Jelen jegyzet kerete között csak néhány típust használunk. Az egész típusú változókban egész számok tárolhatók. A logka típusú változókban logka érték tárolható, azaz értékük csak gaz vagy hams lehet. Ezen kívül használn fogjuk még a T-vel jelölt típust, am egy ún. általános típus. Akkor mondjuk, hogy egy változó T típusú, ha benne lényegében bármlyen érték eltárolható. Néhány esetben a T típusú változók esetén megszorítást teszünk arra, hogy a változóknak összehasonlíthatóknak kell lennük, azaz értelmezett közöttük a < relácó. Ilyenkor ezt fel s tüntetjük khangsúlyozva, hogy T összehasonlítható. Mnden egyes változónak lehet értéket adn. Ezt például a következő módon jelöljük: a 5, am azt jelent, hogy az a értékül kapja az 5-öt. Fontos, hogy csak a bal oldalon lévő változó kaphat értéket, azaz az értékadás nem szmmetrkus művelet. Ezen kívül egy változó értéke átadható egy másk változónak s, lyenkor az érték mndkét változóban tárolva van, az eredet helyről nem törlődk. Például a b változó értéke 3, majd kadjuk a a b utasítást. Ilyenkor az a értéke s 3 lesz, a b pedg 3 marad. Egy változóban tárolt érték k s olvasható, kfejezésekben valamnt kíratásnál felhasználható. Gyakran előforduló feladat, hogy két azonos típusú változóban eltárolt értéket meg kell cserélünk. Ezt értékadások egymás után elvégzésével tehetjük meg. A csere megvalósításához vszont a két megcserélendő értéket tartalmazó változó mellett szükséges egy harmadk változó s, amben átmenetleg eltároljuk valamelyk értéket. Az a és b változókban tárolt értékek cseréjét az alább módon valósíthatjuk meg: segéd a a b b segéd Látható, hogy két változó cseréjét három értékadással tudjuk csak megoldan és egy átmenet változó szükséges még hozzá. Mvel gyakran kell cseréket végrehajtan, ezért külön jelölést vezetünk be erre a műveletre. Az a b jelöl az a és b változóban tárolt értékek cseréjét, amt a fent látott módon valósítunk meg. A változókból kfejezések építhetők. Egy számokat tartalmazó kfejezésben számokat tartalmazó változók, konkrét számértékek és ezeket összekapcsoló matematka műveletek szerepelhetnek. Kfejezés például a következő: bal jobb + 3. (1.1) 2 4 Angolul: varable 5 Angolul: local varable 6 Angolul: type Sergyán Szabolcs 8 Óbuda Egyetem
Ebben a kfejezésben két szám értékű változó a bal és a jobb szerepel, melyek különbségének feléhez adunk hozzá hármat. Ahogy már említettük a logka típusú változók csak gaz vagy hams értéket vehetnek fel. Így egy logka változónak csak olyan kfejezés adható értékül, amely kfejezés vagy egyértelműen gaz vagy hams. Például mondhatjuk azt, hogy az l logka változónak értékül adjuk a 2/2 = 1 kfejezést. Mvel 2-ben a 2 pontosan 1-szer van meg, ezért ez a kfejezés gaz. Logka értékek, lletve logka kfejezések között logka műveleteket s értelmezhetünk, melyek közül hármat használunk ebben a jegyzetben. Logka értékek tagadására a szmbólummal jelölt negálás műveletet használjuk. Az gaz érték negáltja a hams, míg a hams negáltja a gaz, ahogy az az 1.1 táblázatban s látható. l logka értéke hams gaz l logka értéke gaz hams 1.1. táblázat. A negálás logka művelet értelmezése. Két logka érték vagy kfejezés és kapcsolatát s értelmezzük, ezt a műveletet a szmbólummal jelöljük. Két logka érték és kapcsolata pontosan akkor gaz, ha mndkét érték gaz, ahogy az az 1.2 táblázatban s látható. l 1 logka értéke l 2 logka értéke l 1 l 2 logka értéke l 1 l 2 logka értéke hams hams hams hams hams gaz hams gaz gaz hams hams gaz gaz gaz gaz gaz 1.2. táblázat. Az és ( ) valamnt a vagy ( ) kapcsolat értelmezése, az l 1 és l 2 logka típusú változók értékenek mnden lehetséges varácója esetén. Két logka érték vagy kfejezés vagy kapcsolatát s értelmezzük, ezt a műveletet a szmbólummal jelöljük. Két logka érték vagy kapcsolata pontosan akkor hams, ha mndkét érték hams, mnden más esetben gaz, ahogy az az 1.2 táblázatban s látható. A logka kfejezések, mnt mnden más kfejezés balról jobbra kerül kértékelésre. Így például az (a = 5) (b > 3) logka kfejezésben először az a = 5, majd a b > 3 kfejezés értékelődk k. Abban az esetben, ha az első kfejezés hams, akkor az és kapcsolat matt a teljes kfejezés s bztosan hams lesz, tehát a másodk kfejezés kértékelése felesleges. Ezt fgyelembe vesz az ún. rövdzár kértékelés. Ezek szernt két és kapcsolattal összekötött kfejezésben, ha az első kfejezés értéke hams, akkor a másodk kfejezés kértékelése nem történk meg és a teljes kfejezés értéke hams lesz. Hasonlóan két kfejezés vagy kapcsolata esetén, ha az első kfejezés gaz, akkor a másodk kfejezés nem kerül kértékelésre, és a teljes kfejezés logka értéke gaz lesz. Sergyán Szabolcs 9 Óbuda Egyetem
1.3. Tömbök Gyakran fordul elő, hogy sok azonos típusú adatot akarunk tároln, lletve ezeken az adatokon valamlyen műveletet elvégezn. Például egy meteorológa állomáson mnden órában eltárolják az aktuáls hőmérséklet értéket. Ilyenkor egy nap adatanak tárolására nem célszerű 24 különböző változót létrehozn, het adatok esetén pedg 168-at. Sokkal célravezetőbb egyetlen változóban összegyűjten az összes mérés adatot. Ezt valósíthatjuk meg tömbök használatával. A tömbök használata esetén tehát egyetlen változóban több adatot s el tudunk tároln. A tömbben tárolt adatoknak azonos típusúaknak kell lennük. Az 1.1. ábrán láthatunk egy x nevű tömböt, melyben a 20-nál ksebb prím számokat tároltuk el. Ebben az esetben a tömb egész típusú. Mnden tömbnek van elemszáma s, példánkban ez 8. x: 2 3 5 7 11 13 17 19 1 2 3 4 5 6 7 8 1.1. ábra. A 20-nál ksebb prím számokat tartalmazó tömb és az elemek ndexe. A tömbben tárolt értékek elérése érdekében valamlyen módon hvatkoznunk kell a tömb elemere. Ezt ndexeléssel valósítjuk meg úgy, hogy mnden egyes tömbelemhez egyértelműen hozzátartozk egy ndex. Az ndexek logkus rendet követnek: az első tömbelem ndexe 1, a másodké 2,..., az utolsóé pedg a tömb elemszámával azonos. Az 1.1. ábrán látható, hogy melyk tömbelemnek m az ndexe. A tömbök ndexelése a [ ] ndexképző operátor használatával történk. Ha például az x tömb harmadk elemére akarunk hvatkozn, akkor azt a x[3] módon tehetjük meg. Konkrét példánkban x[3] értéke 5. Gyakran fogunk tömbelemekre olyan módon hvatkozn, hogy ndexként egy változót használunk. Például x[] az x tömb -edk elemét azonosítja. Ilyenkor mndg fgyeln kell arra, hogy az alkalmazott ndexnek olyan értéke legyen, am valóban használható ndexként. azaz mndenképp poztív egész számnak kell lenne, és értéke nem haladhatja meg a tömb méretét. Ezek szernt az 1.1. ábrán látható példa esetén csak az 1 és 8 között egész számok használhatók ndexként. Algortmusankban külön jelezn fogjuk, ha új tömböt hozunk létre. Ilyenkor meg kell adnunk, hogy m lesz az új tömb neve, mlyen típusú adatokat tárolunk benne, lletve hogy mekkora a tömb mérete. Például egy x nevű egészeket tartalmazó nyolc elemű tömböt az x Létrehoz(egész)[8] utasítással hozhatunk létre. Lehetőségünk van többdmenzós tömbök használatára s. Ezek közül most csak a kétdmenzós tömböket smertetjük. A kétdmenzós tömbök adott számú sorral, lletve oszloppal rendelkeznek. Az elemek ndexelése két ndexszel, a sor- és az oszlopndexszel történk. Az 1.2. ábrán megadunk egy 4 sorból és 6 oszlopból álló kétdmenzós tömböt. A kékkel kemelt elem sorndexe 2, oszlopndexe pedg 5, ezért x[2, 5] módon hvatkozhatunk rá. 1 2 3 4 5 6 1 2 3 4 3 5 8 4 7 1 2 9 3 0 6 4 6 8 2 1 1 5 4 1 0 2 7 8 1.2. ábra. Kétdmenzós tömb és ndexelése. Kétdmenzós tömb létrehozása s a Létrehoz létrehoz utasítással lehetséges, de méretként meg kell adn a sorok valamnt az oszlopok számát s. Így az ábrán látható tömböt az x Létrehoz(egész)[4, 6] utasítással hozhatjuk létre. Sergyán Szabolcs 10 Óbuda Egyetem
1.4. Vezérlés szerkezetek Az eddgekben három műveletet smertünk meg. Ezek az értékadás, amkor egy változóhoz valamlyen konkrét értéket rendeltünk, lletve a csere, amkor két változóban tárolt értékeket megcserélünk. Harmadk már smert műveletünk pedg a tömb létrehozása, amnek eredményeként létrejön egy adott típusú és elemszámú új összetett változó. Mlyen tovább műveletekre van szükségünk ahhoz, hogy összetett algortmusokat építsünk fel? Az gazat megvallva már nem sokra, vszont fontos lenne, hogy az eddg megsmert műveleteket valamlyen módon össze tudjuk építen. Az összeépítések fajtát vezérlés szerkezeteknek nevezzük, mert ezek adják meg, hogy az algortmus végrehajtása, annak vezérlése mként történjen. Első vezérlés szerkezetünk a szekvenca. Ez utasítások egymás után végrehajtását jelent. Nézzük példaként az alább szekvencát: x Létrehoz(egész)[3] x[1] 5 x[2] 8 x[3] 11 Négy utasításból áll ez a szekvenca, melyek egymás után kerülnek végrehajtásra. Elsőként létrehozunk egy egész típusú három elemű tömböt, melynek az x nevet adjuk. Ezt követően a tömb első elemébe eltároljuk az 5 értéket. A tömb másodk helyére a 8 érték kerül, míg a harmadk eleme 11-gyel lesz egyenlő. Az algortmusok leírásánál a szekvencában lévő utasításokat általában egymás alá írjuk. Az utasításokat fentről lefelé haladva sorban hajtjuk végre. Az utasítások sorrendje nagyon fontos, nézzük meg például, hogy mt eredményezne az alább szekvenca. x[1] 5 x[2] 8 x[3] 11 x Létrehoz(egész)[3] Ha lyen sorrendben írnánk a szekvenca elemet, akkor hbát követnénk el. Akkor akarnánk a tömb egyes elemenek értéket adn, amkor a tömb még nem s létezk, hszen a tömb létrehozása csak a negyedk utasításban történk meg. Lehetőségünk van arra s, hogy helytakarékosság okokból néhány egymást követő utasítást egy sorba írjunk. Ilyenkor az egy sorba kerülő utasításokat pontosvesszővel választjuk el egymástól, ahogy ez az alább példában s látható. x Létrehoz(egész)[3] x[1] 5; x[2] 8; x[3] 11 Másodk vezérlés szerkezetünk az elágazás vagy más néven szelekcó. Ez a vezérlés szerkezet azt tesz lehetővé, hogy egy utasítást, vagy több utasításból felépülő szekvencát egy logka érték gazságának függvényében hajtsunk végre. Az elágazás leírásához szükségünk van meghatározott kulcsszavakra s. Ennek általános formája az alább. ha feltétel akkor utasítás elágazás vége A ha kulcsszót követően kell leírnunk a logka feltételt am lehet egy logka típusú változó, vagy egy logka értéket eredményező kfejezés, majd következk az akkor kulcsszó. Új sorban behúzással adjuk meg azt az utasítást, amt végrehajt az algortmus abban az esetben, ha a feltétel gaz értékű. Az elágazást egy új lezáró sorban behúzás nélkül az elágazás vége kulcsszó zárja le. A lezárásra azért van szükség, mert az utasítás helyén akár több utasítás, például egy szekvenca s állhat: Sergyán Szabolcs 11 Óbuda Egyetem
ha feltétel akkor utasítás1 utasítás2. utasításn elágazás vége Az elágazásnál az algortmus futása úgy történk, hogy először kértékelődk a feltétel. Ha a feltétel gaz, akkor a vezérlés az elágazásban megadott utasítások végrehajtásával folytatódk, majd ezt követően továbbhalad az elágazás vége kulcsszót követő részre. Amennyben vszont a feltétel hams, akkor a feltétel kértékelése után a vezérlés rögtön az elágazás vége kulcsszót követő részre ugrk. Nézzük egy konkrét példát: ha a < 0 akkor a a elágazás vége b a A példában a kértékelendő feltétel az a < 0. Ha az a változó aktuáls értéke negatív, akkor a vezérlés az a a utasításra ugrk, majd nnen halad tovább a b a sorra. Amennyben a már a feltétel kértékelésénél se volt negatív, akkor vszont a vezérlés rögtön a b a sorra ugrk. Az elágazásból megengedünk ún. kétrányú elágazást s. Ilyenkor más utasítás vagy utasításokból felépített szekvenca hajtódk végre, ha az elágazás feltétele gaz, és más ha hams. A kétrányú elágazást az alább módon adhatjuk meg: ha feltétel akkor utasításgazesetben különben utasításhamsesetben elágazás vége Ha a feltétel gaz, akkor a ha ágban található utasításgazesetben utasítás hajtódk végre, majd a végrehajtást követően a vezérlés az elágazás vége kulcsszót követő sorra ugrk. A feltétel hams logka értéke esetén vszont a feltétel kértékelését követően a vezérlés a különben ágban található utasításhamsesetben sorra ugrk. Az ott található utasítás végrehajtását követően az algortmus futása az elágazás vége kulcsszót követő sorban folytatódk. Nézzünk egy példát a kétrányú elágazásra s: ha a < 0 akkor b a különben b a elágazás vége Ha az a változó aktuáls értéke negatív, akkor az ellentettjének gyöke kerül b-be, egyéb esetben vszont az a gyöke lesz b értéke. Az elágazások egymásba s ágyazhatók, amből egy specáls esetet szeretnénk kemeln. Az alább példában megjelenk egy különben ha ág: ha a > 0 akkor b a különben ha a < 0 akkor b a különben b 0 elágazás vége Sergyán Szabolcs 12 Óbuda Egyetem
Ez teljesen egyenértékű az alább egymásba ágyazott elágazásokkal: ha a > 0 akkor b a különben ha a < 0 akkor b a különben b 0 elágazás vége elágazás vége A harmadk vezérlés szerkezet a cklus, vagy más néven terácó. Ez arra ad lehetőséget, hogy egy utasítás, vagy utasítások sorozata többször s végrehajtásra kerüljön. Természetesen a végrehajtások száma nem lehet végtelen, mert mnden algortmustól elvárjuk, hogy véges sok lépést követően véget érjen. A cklusok leállását kétféle módon lehet bztosítan. Vagy csak addg hajtódnak végre a ckluson belül utasítások, amíg egy meghatározott feltétel gaz értékű (tesztelős cklus), vagy előre megadjuk az terácók számát (számlálós cklus). Cklusokból három félét különböztetünk meg. Első az ún. elöltesztelős cklus. Ennél a cklusba való belépés előtt kértékelésre kerül egy feltétel. Ha a feltétel logka értéke gaz, akkor a ckluson belül első utasításra ugrk a vezérlés. Végrehajtódk az összes ckluson belül utasítás, majd smét kértékelésre kerül a cklus feltétele. Ha a feltétel gaz, akkor újra végrehajtódnak a ckluson belül utasítások. Amnt hamssá válk a cklus feltétele, akkor a cklust követő utasításnál folytatódk az algortmus futása. Az elöltesztelős cklusnál használt feltételt a fentek értelmében belépés és bennmaradás feltételnek nevezzük. Az elöltesztelős cklust az alább formában adjuk meg: cklus amíg feltétel utasítások cklus vége Az Eukldesz algortmusnál már láttunk s lyen cklust, csak még nem neveztük elöltesztelős cklusnak. Az Eukldesz algortmus terácója az alább módon írható le, ahol a mod kulcsszó a maradékos osztás operátorát jelöl: cklus amíg r 0 m n n r r m mod n cklus vége Másk cklusunk az ún. hátultesztelős cklus. Ennél a cklusbennmaradás feltétele a cklus végén van. Ez azt jelent, hogy a ckluson belül utasítások egyszer bztosan végrehajtásra kerülnek, majd ezt követően kerül kértékelésre a cklus feltétele. Ha a feltétel gaz, akkor az utasítások újra végrehajtódnak, majd megnt kértékelésre kerül a feltétel. Ha vszont a feltétel hams, akkor a cklust követő utasításra ugrk a vezérlés. Ebben az esetben a feltétel csak bennmaradás feltétel. A hátultesztelős cklusok leírás módja: cklus utasítások amíg feltétel A harmadk cklus az ún. számlálós cklus. Ebben az esetben a cklusnak van egy cklusváltozója, amely egy megadott értéktől egy másk adott értékg változk úgy, hogy mnden felvett értéke mellett egyszer lefutnak a ckluson belül utasítások. Leírása a következő módon történk: cklus cklusváltozó kezdetérték-től végérték-g utasítások cklus vége Sergyán Szabolcs 13 Óbuda Egyetem
Számlálós cklusokat tpkuson tömbök bejárására használhatunk. A következő példában egy tömbbe elhelyezzük az első öt darab négyzetszámot: x Létrehoz(egész)[5] cklus 1-től 5-g x[] 2 cklus vége Az eddg említett vezérlés szerkezetekkel, tehát a szekvencával, szelekcóval és terácóval mnden algortmus leírható. Ezt az állítást külön nem bzonyítjuk. Sergyán Szabolcs 14 Óbuda Egyetem
1.5. Algortmusok leírása, pszeudokód Az előző fejezetekben már láttuk, hogy m s az az algortmus, lletve mlyen részekből épül fel. Az eddgeket összefoglalva most bemutatjuk, hogy mként írhatunk le egy konkrét algortmust. A leírásra az ún. pszeudokódot használjuk. Mutatunk egy példát s, a már megsmert Eukldesz algortmus részletes leírásával, amt az 1.1. algortmusban adunk meg. A jegyzetben mnden algortmusnak saját sorszáma és neve van, amkkel hvatkozhatunk rájuk. Mvel mnden algortmusnak van bemenete és kmenete, ezért a leírás ezek pontos megadásával történk. A bemenet és kmenet változók nevét és típusát s meghatározzuk. Ezt követ az adott algortmust megvalósító függvény vagy eljárás megadása. Azért van szükség függvényekre, lletve eljárásokra, mert ezeken keresztül egy konkrét algortmust egy másk algortmusból akár meg s hívhatunk (ld. később). Az algortmus bemenete egyben a függvény vagy eljárás bemenete s lesznek. A függvény abban különbözk az eljárástól, hogy a függvénynek van legalább egy kmenete, míg az eljárásnak nncs lyen. A függvény kmenetét a vssza kulcsszó használatával adhatjuk meg (ld. 1.1. algortmus 8. sora). Ha a vezérlés a vssza kulcsszóhoz kerül, akkor a függvény futása véget s ér. 1.1. Algortmus Eukldesz algortmus Bemenet: m egész, n egész Kmenet: n egész 1: függvény LNKO(m : egész, n : egész) 2: r m mod n 3: cklus amíg r 0 4: m n 5: n r 6: r m mod n 7: cklus vége 8: vssza n 9: függvény vége Felhasznált változók és függvények m: Poztív egész szám. n: Poztív egész szám, amely kezdetben nem nagyobb m-nél. Az algortmus végén ennek a változónak az értéke a két bemenet változó legnagyobb közös osztójával egyenlő. r: Az aktuáls m és n maradékos osztásának eredménye. A függvényen vagy eljáráson belül a már korábban megsmert algortmus leíró eszközöket használjuk. Ezek az értékadás, tömblétrehozás, lletve a megsmert vezérlés szerkezetek. A függvényt vagy eljárást követően smertetjük az algortmusban használt változókat s. Az Eukldesz algortmust leírhatjuk függvény helyett eljárás használatával s, ahogy az 1.2. algortmusban látható. Ilyenkor természetesen nncs a vssza kulcsszóval megadott vsszatérés értéke az eljárásnak. A kmenetet az eljárás egyk paraméterén keresztül kapjuk meg, amhez a címszernt kulcsszót írjuk az adott változó elé. Az algortmusokban lehetőségünk van arra s, hogy egy másk algortmusban defnált függvényt vagy eljárást meghívjunk. Erre láthatunk egy példát az 1.3. algortmusban. Az algortmus azt vzsgálja, hogy egy tömb mely eleme relatív prímek egy megadott értékkel. Ennek eldöntéséhez meg kell nézn, hogy a vzsgált x tömb aktuáls elemének (x[]) és az érték változónak m a legnagyobb közös osztója. Ehhez meghívjuk az 1.1. Eukldesz algortmusban defnált LNKO függvényt, ahogy ez az 1.3. algortmus 4. sorában látható. Sergyán Szabolcs 15 Óbuda Egyetem
1.2. Algortmus Eukldesz algortmus (2) Bemenet: m egész, n egész Kmenet: n egész 1: eljárás LNKO(m : egész, címszernt n : egész) 2: r m mod n 3: cklus amíg r 0 4: m n 5: n r 6: r m mod n 7: cklus vége 8: eljárás vége Felhasznált változók és függvények m: Poztív egész szám. n: Poztív egész szám, amely kezdetben nem nagyobb m-nél. Az algortmus végén ennek a változónak az értéke a két bemenet változó legnagyobb közös osztójával egyenlő. r: Az aktuáls m és n maradékos osztásának eredménye. 1.3. Algortmus Relatív prím vzsgálat Bemenet: x egész tömb, n egész (tömb mérete), érték egész Kmenet: y logka tömb 1: függvény RelatívPrímVzsgálat(x : egész tömb, n : egész, érték : egész) 2: y Létrehoz(logka)[n] 3: cklus 1-től n-g 4: ha LNKO(x[], érték) = 1 akkor 5: y[] gaz 6: különben 7: y[] hams 8: elágazás vége 9: cklus vége 10: függvény vége Felhasznált változók és függvények x: Poztív egész értékeket tartalmazó tömb. n: Az x tömb elemszáma. érték: Poztív egész szám. Az algortmusban azt vzsgáljuk, hogy az x tömb relatív prímek-e az érték számmal. y: Kmenet logka típusú tömb. Az y tömb -edk eleme pontosan akkor gaz, ha az x tömb -edk eleme relatív prím az érték-kel. Létrehoz(logka)[n]: Utasítás, mely létrehoz egy n elemű logka típusú tömböt. LNKO(x[], érték): Az 1.1. algortmusban kfejtett LNKO függvényt hívja meg, mely meghatározza, hogy a x[]-nek és az érték-nek m a legnagyobb közös osztója. Sergyán Szabolcs 16 Óbuda Egyetem
1.6. Hatékonyság, futás dő elemzése Láttuk már, hogy mként tudunk leírn egy algortmust. Felmerül vszont, hogy mlyen elvárásank vannak egy algortmussal szemben. Rövden tekntsük ezért át az algortmusokkal szemben támasztott követelményeket. Fontos az algortmus megbízhatósága és kszámíthatósága. Ez alatt azt értjük, hogy mnden lehetséges bemenet esetén valóban azt a kmenetet állítsa elő, amt elvárunk az algortmustól. A kszámíthatóságba beleértjük azt s, hogy egy adott bemenet esetén mndg ugyanazt a kmenetet állítsa elő. Ezt más néven az algortmus determnsztkus (előre meghatározott) vselkedésének s nevezzük. A jó algortmusok egyszerű ek s. Ez alatt azt értjük, hogy nem túl körülményesek, könnyen megérthetőek. Az egyszerűség érdekében érdemes az algortmusokat olyan változó nevekkel ellátn, amk alapján egyértelmű, hogy az adott változóban mlyen adatot s tárolunk el. Az egyszerűség érdekében érdemes az algortmusokat részekre, ún. modulokra osztan. Erre mutat jó példát az 1.3. algortmus, ahol a legnagyobb közös osztó meghatározását nem írjuk le újra az algortmuson belül, hanem egy már máshol megvalósított függvényt hívunk meg. Az 1.3. algortmus olvasáskor nem az köt le a fgyelmünket, hogy a legnagyobb közös osztó kszámítása mként történk, csak azt látjuk, hogy az adott helyen annak számítása megtörténk. Az algortmusokkal kapcsolatban elvárás még, hogy hatékonyak legyenek. Ez alatt általában két különböző dolgot s értünk. Egyrészt elvárás, hogy az algortmus számítógépes mplementácója során mnél kevesebb memóra, vagy más háttértár génye legyen. Ezért, ha egy algortmus ugyanazt a feladatot meg tudja oldan egy darab n elemű tömb használatával, míg egy másk algortmusnak ugyanehhez két darab n elemű tömb s szükséges, akkor memóra felhasználás tekntetében az elsőt tekntjük hatékonyabbnak. A hatékonyság fogalmában értjük azt s, hogy az algortmus gyorsan fusson le. Persze ennek meghatározása elég nehéz, sokszor nagyon szubjektív feladat. A fejezet tovább részében épp ezért azzal foglalkozunk, hogy egy algortmus futás dejét mként lehet meghatározn vagy megbecsüln. Hogyan s lehet egy algortmus futás dejét meghatározn? Első ötletünk talán az, hogy az adott algortmust egy adott számítógépen, valamlyen programozás nyelven lekódoljuk, majd futtatjuk az elkészült programot. A futó program végrehajtás dejét mérve már meg s tudjuk határozn az adott algortmus futás dejét. Ez az egyszerűnek tűnő eljárás vszont számos problémát vet fel. Ha az algortmusunkat más gépen vagy más programozás nyelven kódoltuk volna, akkor különböző futás dőt kapunk. Azt se felejtsük el, hogy egy számítógépen egyszerre nem csak egy program fut, tehát mközben a saját programunk futás dejét mérjük, nem tudhatjuk, hogy mlyen más programok zavarnak még be futás közben. Ezek matt ezt az emprkus módszert elvetjük, az algortmusok futás dejét nem így határozzuk meg. Másk lehetőségünk annak vzsgálata, hogy az adott algortmus hány darab elem lépésből áll. Megnézzük tehát, hogy hány értékadás, összehasonlítás, logka kfejezés kértékelés, függvény hívás, stb. történk egy algortmus futása alatt. Ha nézzük például az Eukldesz algortmust, ott adott bemenetek mellett össze tudjuk számoln ezen műveletek számát. Vszont azt s látnunk kell, hogy mnden elem művelet végrehajtása más-más dőgénnyel rendelkezk. Például az m n értékadás esetén anny történk, hogy az m változóba átmásolódk az n változó értéke. Az r m mod n értékadásnál vszont először k kell értékeln az m mod n kfejezést, majd ezt követően kell az előálló értéket az r változóba másoln. Sőt az m mod n kfejezés kértékelése sokkal bonyolultabb művelet mnt egy másolás, ezért pontosan meg se tudjuk mondan, hogy hányszor több dőt gényel. Mndebből az látható, hogy elég nehéz egzakt dolgot mondan egy algortmus futás dejéről. Mégs, mként tudjuk akkor egy algortmus futás dejét megbecsüln? A leggyakrabban használt megközelítés annak vzsgálata, hogy a feldolgozandó adatok mennységének növekedésével mként növekszk egy algortmus futás deje. Azt vzsgáljuk tehát, hogy ha például kétszeresére növeljük a feldolgozandó adatok számát, akkor hányszorosára növekszk ettől az algortmus futás deje. Ematt azt fogjuk vzsgáln, hogy n darab bemenet adat esetén a futás dő hogyan függ az n értéktől. Nézzük egy konkrét példát! Feladatunk, hogy egy n elemű egész számokat tartalmazó tömbben határozzuk meg, hány esetben eredményez a tömb két elemének összege 0 értéket. Ezt a feladatot valósítja meg az 1.4. algortmus. Az algortmus működésének lényege, hogy mnden lehetséges elempárt előállítunk, amt két darab egymásba ágyazott cklussal érünk el. Mnden egyes elempár esetén megnézzük, hogy az összegük 0-e (ld. 5. sor). Ha gen, akkor a db változó értékét amely kezdetben 0 volt növeljük eggyel (ld. 6. sor). Az algortmus végén a db változó aktuáls értékét adjuk vssza (ld. 10. sor). Sergyán Szabolcs 17 Óbuda Egyetem
1.4. Algortmus Nullát eredményező elempárok száma Bemenet: x egész tömb, n egész Kmenet: db egész 1: függvény NullátAdóElempárokSzáma(x : egész tömb, n : egész) 2: db 0 3: cklus 1-től (n 1)-g 4: cklus j ( + 1)-től n-g 5: ha x[] + x[j] = 0 akkor 6: db db + 1 7: elágazás vége 8: cklus vége 9: cklus vége 10: vssza db 11: függvény vége Felhasznált változók és függvények x: A feldolgozandó tömb. n: Az x mérete. db: Azon x-bel elempárok száma, melyek összege 0. Mt mondhatunk az 1.4. algortmus futás dejéről? Ehhez vzsgáljuk meg először, hogy hányszor kerül a x[] + x[j] = 0 feltétel kértékelésre. Ha = 1, akkor j (n 1) darab különböző értéket vesz fel, hszen 2, 3,..., n lehet. Amennyben = 2, akkor j már csak (n 2)-féle lehet. Amkor vszont már n 1 értékű, akkor j csak egy értéket az n-t vesz fel. Így a vzsgált feltétel kértékelésenek száma: (n 1) + (n 2) +... + 2 + 1 = (n 1) + 1 2 (n 1) = n (n 1). (1.2) 2 Hányszor fogjuk elvégezn a db db + 1 értékadást? Ez attól függ, hogy hányszor volt gaz a x[] + x[j] = 0 feltétel. Lehetséges, hogy a feltétel mndg gaz volt, lehet vszont, hogy soha. Futás dő szempontjából a legrosszabb eset, ha mndg gaz a feltétel, lyenkor a db db+1 értékadás s n(n 1) 2 -szer kerül végrehajtásra. Így, ha mnden elem utasítást egy lépésnek tekntünk, akkor legrosszabb esetben a futás dő már n (n 1) 2 = n (n 1). (1.3) 2 Futás dő szernt legjobb esetben vszont a db db + 1 értékadás egyszer sem történk meg, így lyenkor a futás dő n (n 1). (1.4) 2 Azt még nem vettük fgyelembe, hogy az algortmus elején van egy db 0, lletve a végén egy vssza db utasítás, am mnden esetben kettővel növel a szükséges lépések számát. Emellett még a cklusok megvalósításának s van valamenny futás deje. M az am ezek alapján bztosan kjelenthető az algortmus futás dejéről? Am egyértelműen látszk az anny, hogy a futás dő bztosan arányos a feldolgozandó tömb méretének négyzetével, hszen az 1.3. és az 1.4. képletből s ez olvasható k. Tehát, ha a feldolgozandó tömb méretét kétszeresére növeljük, akkor a futás dő már négyszeres lesz, háromszoros méret esetén pedg klencszeres. Hogyan lehet eldönten, hogy egy algortmus futás deje jobb-e egy másk algortmus futás dejénél? Ha a futás dő elemzésénél azt kapjuk például eredményül, hogy egy algortmus futás deje egy másk algortmusé pedg T 1 (n) = 9 100 n2, (1.5) T 2 (n) = n log 2 n, (1.6) akkor melyk teknthető hatékonyabbnak? Az 1.3. ábrán megadjuk a két függvény grafkonját. Látható, hogy ksebb n értékek esetén az első, míg nagyobb n értékeknél a másodk algortmus eredményez Sergyán Szabolcs 18 Óbuda Egyetem
gyorsabb futást. Mvel számunkra az a fontos, hogy n növekedésével mként változk a futás dő, ezért a nagy n értékekre koncentrálunk. Ematt a másodk algortmus futás dejét tekntjük jobbnak, hszen mnél több adatot kell feldolgozn, annál gyorsabban szolgáltat eredményt az első algortmushoz képest. 800 T (n) 600 400 200 9 100 n2 n log 2 n 0 0 20 40 60 80 100 n 1.3. ábra. A T 1 (n) = 9 100 n2 és a T 2 (n) = n log 2 n függvények grafkonja. Könnyen belátható, hogy ha az első algortmus futás dejénél a konstans szorzó nem 9 100, hanem annál még ksebb lenne, akkor s elég nagy n esetén a T 1 (n) már nagyobb lenne T 2 (n)-nél. Tehát a futás dő nagy n esetén lényegében független a konstans szorzó értéktől. Ezt fejez k a nagy ordó jelölés, amt gyakran használunk algortmusok futás dejének jellemzésére. Hogyan defnáljuk az O-val jelölt nagy ordót? Azt mondjuk, hogy a T (n) futás dő O (f(n))-es, ha létezk olyan c konstans, hogy elég nagy n értékek esetén a T (n) c f(n). (1.7) Ezek alapján mondhatjuk például, hogy az 1.4. algortmus futás deje O(n 2 )-es. Az 1.3. táblázatban összefoglaltuk a leggyakrabban előforduló futás dőket. A táblázat tetejétől lefelé haladva egyre nagyobb futás dőkkel találkozunk. Futás dő nagyságrendje Futás dő nagyságrendjének elnevezése O(1) Konstans O(log n) Logartmkus O(n) Lneárs O(n log n) Logartmetkus O(n 2 ) Négyzetes O(n 3 ) Köbös O(2 n ) Exponencáls 1.3. táblázat. Futás dők nagyságrendje és azok elnevezése Sergyán Szabolcs 19 Óbuda Egyetem
2. fejezet Programozás tételek A programozás tételek az algortmus alkotás során gyakran előforduló problémákra adnak megoldásokat. Azért nevezzük ezeket a módszereket tételeknek, mert matematkalag s bzonyítható az smertetett módszerek helyessége és hatékony futás dejük. A programozás tételek néhány esetben már első olvasásra s nagyon egyszerűnek tűnnek, esetleg megkérdőjelezhető pontos smeretük szükségessége s. Fontos szerepük van vszont abban, hogy ezeket a tételeket általában mnden programozó smer, így a nap rutnban egy adott feladat megoldására ezeket használja. Így kjelenthető, hogy a programozás tételek által adott megoldások használatával az előálló algortmusok, lletve programok olvashatósága és megértése s sokkal egyszerűbbé válk. A programozás tételeket jegyzetünkben tömbök használatával mutatjuk be, mert jelenleg csak ezt az adatszerkezetet smerjük. Tanulmányank előrehaladtával könnyen meg tudjuk majd oldan, hogy más adatszerkezetek (például lsták) esetén s megadjuk a megfelelő tétel megvalósítását, de ez nem képez ezen jegyzet tárgyát. A programozás tételek elnevezésének jelentős szerepe van a később algortmus alkotás gyakorlatban. Az tt bevezetett fogalmak általában mndg ugyanazzal a jelentéssel bírnak. Ezen fogalmak közül szeretnénk kemeln párat az alábbakban. Eldöntés Eldönt, hogy a bemenet tömbben van-e adott tulajdonságú elem. Kválasztás Megadja, hogy hol van a bemenet tömbben egy adott tulajdonságú elem, feltételezve, hogy van lyen a tömbben. Keresés Az előző kettő kombnácója, tehát eldönt, hogy a bemenet tömbben van-e adott tulajdonságú elem, és ha van, akkor megadja, hogy hol találjuk meg azt. Megszámlálás Megadja, hogy hány darab adott tulajdonságú elem van a bemenet tömbben. Másolás Egy tömb elemenek egyk tömbből másk tömbbe másolása, melynek során a tömbbel elemek értéke változhatnak. Kválogatás A bement tömb adott tulajdonságú elemenek átmásolása egy másk tömbbe. Szétválogatás A bemenet tömb különböző tulajdonságú elemenek átmásolása különböző tömbökbe. A programozás tételeket jegyzetünkben két nagy csoportra bontjuk. Az első csoportba tartoznak azok a tételek, melyek egy bemenet tömbből állítanak elő egyetlen (vagy esetleg több) értéket. Ezeket egyszerű programozás tételeknek nevezzük és a 2.1. alfejezetben tárgyaljuk. A másodk csoportba tartoznak azok a tételek, amelyek bemenete egy vagy több tömb, és a kmenete s egy vagy több tömb. Ezek alkotják az összetett programozás tételeket, melyek tárgyalására a 2.2. alfejezetben kerül sor. A fejezet végén mutatunk pár példát a programozás tételek összeépítésére s (ld. 2.3. alfejezet). 20