Algoritmusok s ksztsk Algoritmus fogalma Az algoritmus sz

Algoritmusok és készítésük

Algoritmus fogalma Az algoritmus szó Muhammad Ibn Músza Al-Hvázimi (IX. század) csillagász és matematikus nevéből származik A hindu számokról írt jelentős munkájának pontatlan latinra fordításakor változott a szerző neve Algoritmusra Az algoritmus egy probléma véges számú elemi lépésben történő egyértelmű és teljes megadása.

A problémamegoldás lépései 1. A feladat megfogalmazása – A feladat leírása legyen mindig pontos és egyértelmű. – Ezt elhanyagolva sok idő és pénz veszhet kárba. 2. Elemzés, tervezés, szervezés – Számos módszertant, szoftvert fejlesztettek ki erre a célra. – Ezek tartalmazzák a probléma megoldását támogató és leíró matematikai modelleket, valamint a be- és kimenő adatokkal szembeni igényeket

A problémamegoldás lépései (folyt. ) 3. Programtervezés, algoritmuskészítés – Ebben a szakaszban kell megtervezni és dokumentálni a különböző modelleket megvalósító algoritmusokat. – Az algoritmus nem egyenlő a programmal, ugyanis még általános, programnyelvfüggetlen – A programterv kidolgozása többlépcsős, egyre finomabb részletezettségű

A problémamegoldás lépései (folyt. ) 4. Programozás, kódolás – Az algoritmusok kódolása konkrét programozási nyelvre – Ebben az esetben a számítógép számára értelmezhető, futtatható programokról van szó 5. A program tesztelése, hangolása – A tesztelés bonyolult, aprólékos munka, megfelelő időt kell rá fordítani (hibák kiküszöbölése, finomhangolás)

A problémamegoldás lépései (folyt. ) 6. Dokumentálás – Az egész folyamatot végigkíséri, de ebben a fázisban kell a felhasználók és üzemeltetők számára leírni a rendszer használatát – Ez a leírás tartalmazza a rendszer működési feltételeit, paramétereit, valamint az adminisztrátori és felhasználói kézikönyveket 7. A rendszer bevezetése, üzemszerű használata – A megtervezett, elkészített, letesztelt és dokumentált rendszer használatának megkezdése, folyamatos ellenőrzés mellett – A bevezetés után megfogalmazódó igények alapján további verziók készíthetők

Algoritmus-leíró eszközök Ezekkel az eszközökkel jeleníthetőek meg az algoritmusok: – Folyamatábra (blokkdiagram) – Mondatszerű leírás (leírónyelv) – Struktogram – Jackson módszer Mindegyik leíró eszköznek megvannak a maga külön jelölési módszerei

Folyamatábra (blokkdiagram) A folyamatábra az algoritmus képi reprezentációja A mindennapi életben is találkozhatunk algoritmusokkal (bank- vagy italautomata) A szimbólumok különbözőek, de mindegyikre igaz, hogy elemi vagy összetett lépések végrehajtási sorrendjét adják meg

Folyamatábra jelölései START Kezdőpont jele: minden algoritmusban csak 1 van belőle, pontosan 1 él indul ki belőle és egy sem csatlakozik bele STOP Végpont jele: minden algoritmusban csak 1 van belőle, pontosan 1 él csatlakozik bele és egy sem indul ki belőle be: vált 1, vált 2 ki: kif 1, kif 2 Beolvasás és kiíratás szimbóluma: legalább 1 él csatlakozik bele és pontosan 1 él indul ki belőle változó: =kifejezés Értékadás szimbóluma: a kifejezés értéke a változóban lesz tárolva. Legalább 1 él csatlakozik bele és pontosan 1 indul ki belőle

Folyamatábra jelölései (folyt. ) feltétel Döntés (elágazás) szimbóluma: ha a feltétel igaz, akkor az igaz ágon, ellenkező esetben a hamis ágon folytatódik az algoritmus. Legalább 1 él csatlakozik bele, és legalább 1 indul ki belőle részalgoritmus Beágyazás szimbóluma: egy máshol leírt (rész)algoritmust helyettesít. Legalább 1 él csatlakozik bele és pontosan 1 indul ki belőle beállít, vizsgál, léptet Ciklikus végrehajtás szimbóluma: három műveletet tartalmaz (számláló beállítása, vizsgálata és léptetése). Pontosan 2 él indul ki belőle és pontosan 2 él érkezik bele

Folyamatábra jelölései (folyt. ) Folyamatvonal: a végrehajtás irányát, a lépések egymásutániságát mutatja. Csak a döntési és a ciklikus végrehajtás szimbólumában ágazhat el.

Adatok, adattípusok, változók

Változó A változó egy névvel ellátott tárolóhely a számítógép memóriájában – értéke mindig a tárolóhely aktuális tartalma A változókat jellemezhetjük a – nevével – típusával – memóriabeli kezdőcímével – értékével

Név A változó neve az azonosításra szolgál – ezzel tudunk a változóra hivatkozni, pl. : valamilyen képletben – célszerű a változónak beszédes nevet adni (a nevéből rá lehessen jönni, mi a tartalma) – mivel általában többször használjuk egy programban, így a hossza is fontos – programnyelvfüggőek a névre vonatkozó szabályok (hány karakter, milyen karakterek, kis- és nagybetű számít-e)

Típus Nagyon fontos tulajdonsága egy változónak a típus, hiszen meghatározza: – a változó értékkészletét – a változóval elvégezhető műveletek körét – a helyfoglalás nagyságát a memóriában A típusok konkrét megvalósítása az adott programnyelvtől függ, de általánosan elmondható, hogy 2 nagy csoportra oszthatóak: – elemi típusok – összetett típusok

Elemi típusok Az elemi típusoknak nincs szerkezetük, nem lehet egyes részeiket külön kezelni – Egész szám: egész számok tárolására, melyek lehetnek előjelesek vagy előjel nélküliek; többféle létezik belőle – Valós számok: véges tizedes törtek ábrázolására, a számokat normál alakban tárolják; többféle létezik belőle – Karakter: egyetlen karakter tárolására

Elemi típusok (folyt. ) – Logikai: kétféle értéket vehet fel (igaz, hamis) – Mutató: a változó értéke egy memóriacím, amivel gyakorlatilag „rámutatunk” az adott memóriabeli helyre (dinamikus memóriakezelés megvalósításához szükséges)

Összetett típusok Elemi vagy összetett típusokat tartalmaznak valamilyen szerkezeti összefüggés szerint (adatszerkezeteknek is nevezzük őket) – tömb: homogén adatszerkezet, azaz több azonos típusú elemet tartalmaz Jellemzői: név, típus, indexhatár A típus azt adja meg, hogy a tömbben szereplő elemek milyen típusúak Az indexhatár a tömb elemszámát határozza meg, azaz a tömb méretét (a memóriabeli mérete függ a típustól is) A tömb elemeire a tömb nevével, és mögötte szögletes zárójelben az indexszámmal hivatkozunk. Lehet egydimenziós (vektor) és többdimenziós is. A kétdimenziós tömböt mártixnak hívjuk.

Összetett típusok (folyt. ) – Karakterlánc (string, szöveg): egy karakter típusú egydimenziós tömbnek fogható fel kezelés szempontjából meghatározhatjuk a nevét és a méretét a string egyes elemeire a nevével és az adott karakter indexszámával (szögletes zárójelben) hivatkozhatunk – Rekord: heterogén adatszerkezet, melynek valamennyi komponensére és magára a rekordra is külön névvel hivatkozunk különböző típusú adatokat lehet benne tárolni a komponenseket mezőknek hívjuk állománykezelésnél, ill. adatbázis-kezelésnél használják

Összetett típusok (folyt. ) – Állomány (fájl): típusai: szöveges állomány típusos állomány nem típusos állomány

Érték A legtöbb programozási nyelvben a változót deklarálni kell – azaz, mielőtt használnánk, meg kell adni a nevét és a típusát (ezt általában a program vagy algoritmus elején található deklarációs részben lehet megtenni) A változó deklarálásakor a változó típusának megfelelő hely lefoglalódik a memóriában A deklarálás pillanatában a változó értékét definiálatlannak nevezzük Ekkor is lehet értéke, a memóriában lefoglalt hely korábbi tartalmától függően – mivel ezt a korábbi értéket biztosan nem akarjuk használni, a változónak érdemes kezdőértéket adni

Kifejezés lehet: – egy konkrét érték (pl. : 10, hamis, „A”) – egy változó (pl. : a, x, min, nev) – változók vagy konkrét értékek és műveleti jelek kombinációja (pl. : 2*x, 3+2, N<=5) A műveleti jeleket operátoroknak, a változókat és konkrét értékeket operandusoknak hívjuk A kifejezéseket kiértékelve konkrét értéket kapunk (aminek lesz valamilyen típusa) – a kifejezés típusa a kifejezésben szereplő operandusok és operátorok típusától függ

Konstans Lényege: egy konkrét értéket valamilyen beszédes névvel látunk el, hogy a későbbiekben a névvel tudjunk rá hivatkozni (pl. : pi) Előnye: az algoritmust átláthatóbbá teszi A konstansokat a program vagy algoritmus elején kell megadni, és csak itt kap értéket Ha az alapértékét meg szeretnénk változtatni, azt elég egyszer megtenni az algoritmus folyamán

Vezérlési szerkezetek A folyamatábrák segítségével csak egyszerűbb algoritmusok írhatóak le Komolyabb algoritmusok készítéséhez vezették be a vezérlési szerkezeteket Az 1960 -as években bebizonyították, hogy minden algoritmus leírható 3 vezérlési szerkezettel: – szekvenciával – szelekcióval – iterációval

Vezérlési szerkezetek (folyt. ) Szekvencia: – utasítások egymás utáni végrehajtása – külön nem jelöljük Szelekció (elágazás): – egy feltétel kiértékelésének eredményétől függ, hogy milyen utasítások kerülnek végrehajtásra Iteráció (ciklus, ismétlés): – egy utasítás egymás után többszöri végrehajtása esetén használjuk

Vezérlési szerkezetek (folyt. ) Ezek a vezérlési szerkezetek leírhatóak folyamatábrával, de mivel egymásba ágyazhatóak, egy bizonyos szint után a folyamatábra áttekinthetetlenné és túl bonyolulttá válik.

Mondatszerű leírás (leírónyelv) Ez az algoritmusleíró eszköz a magyar nyelvre épül, így könnyebben tanulható és átlátható. A sok különböző programozási nyelv eszköztáraiból csak a legfontosabbakat tartalmazza A mondatszerű leírással megírt algoritmus nem más, mint utasítások sorozata Létezik hozzá szabálygyűjtemény, ezt szintaxisnak nevezzük.

Leírónyelv - változódeklarálás Az algoritmus kezdésének jelölése után következik – az algoritmus kezdése leírónyelvben: algoritmus név – változódeklarálás: váltózó váltnév 1, váltnév 2, … : típus – akkor írhatjuk a változóneveket egy sorba, ha azok azonos típusúak – különböző típusú változóknál annyi sor lesz, ahány különböző típust akarunk használni

Leírónyelv – változódeklarálás (folyt. ) Példák változódeklarálásra: változó darab: egész változó átlag: valós változó l: logikai változó vezetéknév, keresztnév: szöveg Konkrét programozási nyelvek esetén figyelni kell a névadásra, mert léteznek olyan nyelvek, ahol a kis- és nagybetű különbözőnek számít (pl. : Java)

Leírónyelv - értékadás Értékadás: változónév: =kifejezés – A : = jel jobb oldalán lévő kifejezést kiszámítja, és az eredményt eltárolja a bal oldalon található változóban – Ez csak akkor lehetséges, ha a kifejezés eredményének és a változónak a típusa megegyezik – Pl. : átlag: =összeg/db l: =(darab<=10) vezetéknév: ="Horváth"

Leírónyelv – értékadás (folyt. ) Az első példánál látható, hogy az osztásra a / jel szolgál. Ha elosztjuk az összeget a darabszámmal, akkor megkapjuk az átlagot Fontos, hogy az átlag nevű változó valós típusú legyen, mivel egy osztás eredménye általában nem egész szám

Leírónyelv – értékadás (folyt. ) A második példát úgy kell értelmezni, hogy ha a darab nevű változó aktuális értéke kisebb, mint 10, akkor az l nevű logikai típusú változó értéke igaz lesz, ellenkező esetben hamis A harmadik sorban szöveges értéket adtunk egy változónak. – fontos, hogy ekkor a szöveget " " jelek közé kell tenni, különben a szöveget változónévként próbálja értelmezni a program, és ez hibához vezethet

Leírónyelv – Beolvasás, kiíratás Beolvasás be: vált 1, vált 2… Kiíratás ki: kif 1, kif 2… A be utasítás a felhasználótól kapott értékeket eltárolja az adott nevű változókba A ki utasítás pedig kiírja a képernyőre a megadott kifejezést, vagy a változók értékét

Leírónyelv – Beolvasás, kiíratás (folyt. ) Példa (név beolvasása, majd üdvözlés kiíratása): algoritmus üdv változó név: szöveg ki: "Írj be egy nevet!" be: név ki: "Üdvözöllek", név algoritmus vége

Leírónyelv – Beolvasás, kiíratás (folyt. ) Példa (név beolvasása, majd üdvözlés kiíratása) magyarázata: – Először változót deklarálunk: létrehozzuk a név nevű változót, ami szöveg típusú lesz – Majd kiíratjuk a képernyőre, hogy mit csináljon a felhasználó (írja be a nevet) – Bekérésnél a felhasználó által beírt nevet eltároljuk a név nevű változóban – Végül kiírjuk az üdvözlő szöveget, majd mellé a nevet, amit a felhasználó megadott, és a név nevű változóban található

Leírónyelv – Szelekciónál egy feltételtől függően hajtunk végre bizonyos utasításokat 3 fajtája van: – egyágú elágazás – kétágú elágazás – többágú elágazás

Leírónyelv – Szelekció (folyt) Egyágú elágazás: ha feltétel akkor utasítás(ok) hvége – Ha az adott feltétel igaz, akkor az utasítás(ok) végrehajtódnak

Egyágú szelekció folyamatábrával h i feltétel utasítás(ok)

Leírónyelv – Szelekció (folyt) Kétágú elágazás: ha feltétel akkor utasítás(ok) különben utasítás(ok) hvége – Ha az adott feltétel igaz, akkor az adott utasítás(ok) hajtódnak végre, ha hamis, akkor a különben részbe írt utasítás(ok) hajtódnak végre

Kétágú szelekció folyamatábrával h i feltétel utasítás(ok)

Leírónyelv – Szelekció (folyt) Többágú elágazás: elágazás amikor feltétel 1: utasítás(ok) amikor feltétel 2: utasítás(ok) … különben utasítás(ok) evége

Leírónyelv – Szelekció (folyt) Többágú elágazás: – A többágú elágazásnak legalább egy amikor ágat kell tartalmaznia, a különben ág elhagyható – Ha valamelyik feltétel teljesül, akkor a hozzá tartozó utasítások hajtódnak végre – Ha egyik feltétel sem teljesül, akkor a különben ágba írt utasítások hajtódnak végre (ha van különben ág)

Többágú szelekció folyamatábrával h i feltétel utasítás(ok)

Leírónyelv – Szelekció (folyt) Példa kétágú elágazásra (két szám összehasonlítása): algoritmus nagyobb változó a, b: egész be: a, b ha a>b akkor ki: "A nagyobb mint B" különben ki: "A nem nagyobb mint B" algoritmus vége

A példa folyamatábrával START be: a, b h i a>b ki: "A nagyobb mint B" ki: "A nem nagyobb mint B" STOP

Leírónyelv – Szelekció (folyt) Példa többágú elágazásra (két szám összehasonlítása): algoritmus nagyobb változó a, b: egész be: a, b elágazás amikor a>b: ki: "A nagyobb mint B" amikor a<b: ki: "B nagyobb mint A" különben ki: "A két szám egyenlő" evége algoritmus vége

A példa folyamatábrával START be: a, b h h ki: "A két szám egyenlő" a<b a>b i ki: "A nagyobb mint B" i ki: "A kisebb mint B" STOP

Leírónyelv – iteráció Az iteráció esetében olyan utasításokról van szó, amiket többször ismételünk meg egymás után Alapvetően 3 fajta iterációt (ciklust) különböztetünk meg: – növekményes (léptetős) ciklus – elöltesztelő ciklus – hátultesztelő ciklus

Leírónyelv – iteráció (folyt. ) Növekményes (léptetős) ciklus – Akkor használjuk, ha pontosan tudjuk, hogy hányszor kell ismételni az adott utasításokat – Szükség van a ciklusban egy ún. ciklusváltozóra, amivel számon tarthatjuk, hogy hányadik ismétlésnél tartunk ciklus cv: =ké. . vé lépésköz=lk ismétel ciklusmag utasítás(ok) cvége

Leírónyelv – iteráció (folyt. ) cv: ciklusváltozó ké: kezdőérték vé: végérték lk: lépésköz (a ciklusváltozót mekkora lépésekkel változtassuk – egyesével, kettesével, … stb. ) ciklusmag: az ciklus azon része, amely az ismétlendő utasításokat tartalmazza

Növekményes ciklus folyamatábrával cv: =ké cv<=vé cv: =cv+1 utasítás(ok)

Leírónyelv – iteráció (folyt. ) Példa (első 10 négyzetszám kiíratása): algoritmus négyzetszám változó i: egész ciklus i: =1. . 10 lépésköz=1 ismétel ki: i*i cvége algoritmus vége

A példa folyamatábrával START i: =1 i<=10 i: =i+1 ki: i*i STOP

Leírónyelv – iteráció (folyt. ) Példa (első 10 négyzetszám kiíratása) magyarázata: – A ciklus 10 -szer fog lefutni (a ciklusváltozó 1 -től megy 10 -ig) – Először a ciklusváltozó 1, ekkor a ciklusba lépve kiíródik az 1*1, azaz az 1 – Második lépésben a ciklusváltozó 2 -re változik (ha a lépésköz 1), ekkor a 2*2, azaz a 4 kerül kiírásra – Ez egészen addig megy így, amíg el nem értük az utolsó ismétlést (10. ), amikor is a 10*10, azaz a 100 kiíratása után kilépünk a ciklusból

Leírónyelv – iteráció (folyt. ) Elöltesztelő ciklus – A ciklus végrehajtása egy feltételhez van kötve – Ha a feltétel igaz, akkor BELÉPÜNK a ciklusba, és végrehajtódnak a ciklusmagban található utasítások – Előfordulhat, hogy a ciklusmag egyszer sem hajtódik végre, amennyiben a feltétel már kezdéskor hamis

Leírónyelv – iteráció (folyt. ) – Gondoskodni kell arról, hogy olyan feltételünk legyen, ami egyszer mindenképpen hamissá válik, ellenkező esetben soha nem ér véget a ciklus (végtelen ciklus) amíg feltétel ismétel utasítás(ok) ciklusmag avége

Elöltesztelő ciklus folyamatábrával feltétel h i utasítás(ok)

Leírónyelv – iteráció (folyt. ) Példa (bekért számok négyzetgyökének kiíratása, amíg nem negatív szám kerül beírásra): algoritmus négyzetszám változó a: egész be: a amíg a>=0 ismétel ki: gyök(a) be: a avége algoritmus vége

A példa folyamatábrával START be: a a>=0 ki: gyök(a) be: a STOP

Leírónyelv – iteráció (folyt. ) Példa magyarázata: – Először bekérünk egy számot a felhasználótól, amit az a nevű változóban eltárolunk – Ha ez a szám negatív, akkor belépünk a ciklusba, és kiíratjuk a négyzetgyökét – Bekérünk egy újabb számot, és az a nevű változó értékét felülírjuk vele – Ha ez az új szám negatív, akkor újra végrehajtjuk a ciklusmagot (gyök kiíratása, újabb bekérés), ha negatív, akkor kilépünk a ciklusból

Leírónyelv – iteráció (folyt. ) Hátultesztelő ciklus – A ciklus egyszer mindenképpen végrehajtódik, a ciklusból történő KILÉPÉS van feltételhez kötve – Miután végrehajtódnak a ciklusmag utasításai, a ciklus végén ellenőrizzük, teljesül-e a feltétel. Ha igen, kilépünk a ciklusból, ha nem, visszaugrunk az elejére

Leírónyelv – iteráció (folyt. ) – Gondoskodni kell arról, hogy olyan feltételünk legyen, ami egyszer mindenképpen igazzá válik, ellenkező esetben soha nem ér véget a ciklus (végtelen ciklus) ismétel ciklusmag utasítás(ok) ivége feltétel esetén

Hátultesztelő ciklus folyamatábrával utasítás(ok) feltétel h i

Leírónyelv – iteráció (folyt. ) Példa (bekért számok négyzetgyökének kiíratása, amíg nem negatív szám kerül beírásra): algoritmus négyzetszám változó a: egész be: a ismétel ki: gyök(a) be: a ivége a<0 esetén algoritmus vége

A példa folyamatábrával START be: a ki: gyök(a) be: a a<0 STOP

Leírónyelv – iteráció (folyt. ) Példa magyarázata: – Először bekérünk egy számot a felhasználótól, amit az a nevű változóban eltárolunk – Kiíratjuk a szám négyzetgyökét, majd bekérünk egy újabb számot, és az a nevű változó értékét felülírjuk vele – Ha ez az újonnan bekért szám negatív, akkor kilépünk a ciklusból, ha nem negatív, akkor visszaugrunk a ciklus elejére (kiíratjuk a négyzetgyököt, bekérünk egy új számot) – VIGYÁZAT! Ebben az esetben, ha először negatív számot írunk be, akkor hibát kapunk (gyökvonásnál), mert egyszer mindenképpen lefut a ciklus!