1

Bevezetés a programozásba Tartalomjegyzék

Bevezetés a programozásba .............................................................................................................1 Tartalomjegyzék...............................................................................................................................1 A hardver és a szoftver jelentőségének változása............................................................................2

A hardver és a szoftver kapcsolata: a számítógépek működése...................................................2 Számítógépek ...........................................................................................................................2 A program végrehajtásának menete.........................................................................................2

A programozás alapjai .....................................................................................................................3 A gépi kód....................................................................................................................................3 Programozási nyelvek, fordító/értelmező ....................................................................................3 Programozási hibák, hibakeresés .................................................................................................3 A programozási nyelvek és módszerek változása........................................................................4 Programozási nyelvek ..................................................................................................................4

Csoportosításuk, jellemzésük...................................................................................................4 A fontosabb programnyelvek...................................................................................................5 A programozási módszerek......................................................................................................6

Adatok..............................................................................................................................................7 Elemi (egyszerű) adattípusok.......................................................................................................7 Összetett adatok ...........................................................................................................................9 Változók .......................................................................................................................................9

Algoritmikus programozás.............................................................................................................10 Algoritmus .................................................................................................................................10 Algoritmus leíró módszerek:......................................................................................................10

Mondatszerű leírás (pszeudokód) ..........................................................................................11 Folyamatábra (blokkdiagram)................................................................................................12

Az alapvető vezérlési szerkezetek összehasonlítása ..................................................................15 Elágazások .............................................................................................................................15 Ciklusok .................................................................................................................................15

Példa algoritmus készítésre........................................................................................................16 Elemi algoritmusok ........................................................................................................................18

Algoritmusok, amelyek egy sorozatból egy adatot állítanak elő: ..............................................18 Elemek összegzése.................................................................................................................18 Lineáris keresés......................................................................................................................18 Maximum kiválasztása...........................................................................................................18 Megszámlálás.........................................................................................................................19

Algoritmusok, amelyek egy sorozatból egy másik sorozatot állítanak elő:...............................19 Kiválogatás.............................................................................................................................19 Rendezések.............................................................................................................................19 Minimum-elven alapuló rendezés ..........................................................................................20 Buborék rendezés...................................................................................................................20 Javított buborékos rendezés ...................................................................................................21 Tovább javított buborékos rendezés ......................................................................................21

2

A hardver és a szoftver jelentőségének változása A számítástechnika hajnalában (1950-es évek) a hardvernek sokkal nagyobb volt a jelentősége, hiszen akkoriban magának a számítógépnek, mint szerkezetnek az összeállítása és működtetése jelentette a legnagyobb problémát. Akkoriban csak a hozzáértő szakemberek jutottak számítógép közelébe, így nem is volt cél, hogy kimondottan felhasználóbarát programokat írjanak. Ahogy a technológia fejlődött, úgy a számítógép (a hardver) egyre megbízhatóbbá és olcsóbbá vált, így fokozatosan eljutott a kisebb cégekhez, s mára a hétköznapi emberig. Tehát a felhasználók köre megváltozott: profi szakemberek helyett most gyermekek, tanárok, orvosok, titkárnők, pékek, és takarítónők ülnek a gépek előtt, és minden joggal elvárják, hogy a számítógépet a saját különbözőcéljaikra a lehető legkényelmesebben lehessen felhasználni, a legkevesebb tanulással. De mivel a számítógép hardvere csupán egy halom vas és műanyag, ami önmagától semmi értelmes dologra nem képes, a fent említett hatalmas felhasználói igényeket a programoknak (szoftvereknek) kell biztosítani. A számítástechnika története során tehát a hangsúly áthelyeződött a hardverről aszoftverre. Mára a szoftvergyártás (vagyis a programozás) jelentős iparággá nőtt.

A hardver és a szoftver kapcsolata: a számítógépek működése Számítógépek A számítástechnika fejlődése során számtalan különböző próbálkozás született arra, hogy miként lehetne a számításokat valamilyen géppel elvégeztetni. Mindközül a Neumann-elvű gépek bizonyultak a legsikeresebbnek, a modern elektronika pedig megteremtette a digitális technológia alkalmazásának műszaki feltételeit. A Neumann-elvű számítógépek lényege, hogy mind az adatok, mind az elvégzendő feladat (kódolt utasítások formájában) a memóriában van eltárolva. A digitális szó azt jelenti, hogy mindent számokként ábrázolunk, és azokat dolgozzuk fel. A ma körülöttünk lévő számítógépek mind ilyen elven működnek, ezért ettől a ponttól számítógépen Neumann-elvű digitális számítógépet értünk. A program végrehajtásának menete A memória

minden bájtja sorszámmal (címmel) rendelkezik, így a memória bármely rekesze (1 vagy több bájtja) megcímezhető, és így a processzor által közvetlenül elérhető.

A CPU (központi feldolgozó és vezérlő egység, a ,,processzor'') feladata, hogy végighaladjon a program utasításain, és az előírt sorrendben végrehajtsa azokat. Az utasítások műveleteket végeznek az adatokon.

A processzor a következő lépésekben hajtja végre az utasításokat: 1. a soron következő utasítás gépi kódját lehívja a memóriából a CPU-ba, 2. dekódolás: megállapítja, hogy milyen adatokkal milyen műveletet kell elvégezni, 3. beolvassa a memóriából a szükséges adatokat, végrehajtja az előírt utasítást,

az eredményt pedig, ha szükséges, visszaírja a memóriába

3

A programozás alapjai A gépi kód A memóriában az utasítások kódolva tárolódnak, az adott processzor ,,nyelvén'' (a különbözőprocesszoroknak különböző utasításai vannak). Utasítás alatt itt egyszerű, elemi utasítást kell érteni, pl. 2 szám összeadása, szorzása, egy szám másolása egyik memóriarekeszből a másikba. Minden utasításnak van egy kódja (ez lényegében egy szám). Az adott utasításhoz meg kell adni, hogy milyen adatokkal számol, pl. az általa használt adatok memóriacímét (azt a sorszámot, amely memória rekeszben elhelyezkedik). Így lehet a programot számokkal kódolni. Az így kapott kód a gépi kód. A programozás tehát lényegében ennek a gépi kódnak a megalkotása. Programozási nyelvek, fordító/értelmezőGépi kódban programozni nagy odafigyelést igénylő, fáradtságos munka, amit nehéz megtanulni, könnyű elhibázni. Ezért már korán rájöttek, hogy a programozó munkáját minél jobban meg kell könnyíteni. Ennek érdekében programozási nyelveket dolgoztak ki, hogy ne számokkal kelljen programozni, hanem sokkal ember-közelibb módon, olyan nyelven, amelyben számok (kódok és címek) helyett angol szavak szerepelnek. Egy ilyen nyelvet azonban nem ,,ért meg'' a gép, ezért ezt le kell fordítani a gép nyelvére. Ehhez szükség van egy olyan segédprogramra, amely az általunk megírt programot gépi kóddá alakítja (ez a fordító, compiler), vagy lépésenként végrehajtja (ez az értelmező, interpreter).

fordító (compiler) értelmező (interpreter)

jellemzője a program forrásszövegéből egy gépi kódú programot (pl. OBJ) állít elő, vagyis a programot lefordítja a gép nyelvére.

a program forrásszövegét sorról sorra ellenőrzi, értelmezi, és végrehajtja.

szintaktikai (alaki) hibák

kiszűrése fordítási időben (+) futási időben (-)

az elkészült program

végrehajtási sebessége

gyorsabb (+) lassabb (-)

program hordozhatóság rosszabb (-) jobb (+)

a fejlesztés nehézsége nehézkesebb (-) egyszerűbb (+)

Programozási hibák, hibakeresés Természetesen egy magas szintű nyelven írt program írása közben is véthetünk hibákat. Ez lehet:

• szintaktikai hiba (alaki): a program nem felel meg az adott nyelv szabályainak. Pl. elírás, elfelejtettünk egy zárójelet... Az ilyen hibákat viszonylag könnyű megtalálni.

• szemantikai hiba (tartalmi): a program lefordul, elindul, de nem azt csinálja, amit kell, esetleg menet közben le is áll a hiba miatt. Az ilyen hibák sok gondot okoznak, s poloska módjára búvnak meg a programban, ezért ezeket a hibákat a poloska angol megfelelője után bug-nak nevezik. Az ilyen hibák megtalálása és kiírtása (debuggolás)sokkal nehezebb feladat, erre külön segédprogramok (debugger-ek) állnak rendelkezésünkre.

4

A programozási nyelvek és módszerek változása A számítástechnika története során a programok készítésének módszerei és eszközei is fejlődtek A főbb állomások:

• gépi kód az adott gép processzorának ,,nyelvén'' : számok (utasítás- és operandus kódok) sorozata

• assembly nyelv a gépi kód emberibb változata, ahol minden gépi kódú utasításnak egy kis angol neve van

• magas szintű nyelvek (pl. PASCAL, C, C++, Java) könnyű bennük ismétlési és döntési szerkezeteket, valamint alprogramokat készíteni

• integrált fejlesztő eszközök olyan programfejlesztő környezetek, amelyek megkönnyítik a programozásnál megszokott szerkesztés-fordítás-hibakeresés munkaciklust: a szövegszerkesztő (editor), fordító (compiler), és hibakereső (debugger) egy helyen találhatók és jól együttműködnek.

• vizuális fejlesztőeszközök olyan integrált programfejlesztő környezetek, melyekben sok programozói feladat szinte néhány egérkattintásra egyszerűsödök: pl. megrajzoljuk a leendő program dialógus ablakjainak elemeit, a fejlesztő eszköz pedig automatikusan

• legenerálja a megfelelő kódot: (vagyis megírja helyettünk a program egy részét) • dokumentációt készít...

Programozási nyelvek Csoportosításuk, jellemzésük A nyelv által megoldandó probléma alapján 2 nagy csoportra oszthatjuk: • leíró jellegű nyelvek

egy állandó állapotot (tényeket) fogalmazhatunk meg bennük, nem pedig cselekvést. Pl. HTML • (procedurális) programnyelvek

algoritmikus cselekvést (tennivalók sorozatát) fogalmazunk meg bennük. Ilyen elven működnek a Neumann elvű számítógépek. Innentől nyelven elsősorban ilyen programnyelvet értünk.

A nyelv absztrakciós szintje alapján is 2 nagy csoportra oszthatjuk: • alacsony szintű nyelvek

nehezebb a programírás, de a lefordítandó program közelebb áll a gép nyelvéhez (a gépi kódhoz), így nehezen hordozható (más típusú gépekre), viszont több beleszólásunk van a gépközeli dolgokba. Pl. assembly.

• magas szintű nyelvek könnyebb programot írni (pontosabban egy emberközeli probléma megfogalmazása könnyebb). A nyelv által nyújtott kényelem és a gép utasításkészlete közötti űrt a fordító vagy értelmező programnak kell áthidalnia. Pl. C, Java.

5

A fontosabb programnyelvek A ma is élő, legelterjedtebb általános nyelvek:

• assembly • gépi kódú programozást segítő nyelv • a megírt program nehezen hordozható • ma már főleg az operációs rendszerek készítői, ill. a hardvergyártók programoznak

ilyenben. • PASCAL

• eredetileg a struktúrált programozás tanulónyelvének szánták • továbbfejlesztett változata, a TURBO PASCAL a modulok, illetve ma már az OOP-t

is támogatja • a valós életben a C miatt nem tudott érvényesülni, illetve a DELPHI-ben él tovább

• DELPHI • alapja az objektum-orientált Turbo Pascal • fő erőssége a korszerű és hatékony vizuális fejlesztőfelület • fő korlátja, hogy egy céghez (Borland), és egy platformhoz (Windows) kötődik.

• C• közép szintű nyelvként szokták emlegetni, mert hatékony és könnyű programozni • minden (fontos) géptípusra van C fordító -> hordozható nyelv • régen minden általánosat C-ben írtak, ma a helyét egyre jobban átveszi a C++, ami

objektum orientált módszert (OOP) tesz lehetővé. • ahol megmarad, az a rendszerprogramozás.

• C++ • a C nyelv objektum-orientált továbbfejlesztése • ma már a legtöbb géptípusra van C++ fordító is -> jól hordozható nyelv • napjainkban minden (általános) programot ebben írnak

• Java • egy képzeletbeli (virtuális) Java-gép programnyelve • szintaktikája nagyon hasonlít a C++ -éhoz • a nyelv szabványos részét képezik a leggyakrabban kellő alapkönyvtárak,

mint pl. a grafika, felhasználói felület, hálózat programozás, adatbáziskezelés. • Java nyelven lehet appleteket írni, amelyek beszúrhatók HTML oldalakba is • tökéletesen hordozható nyelv • az Internet-programozás fő nyelve.

Érdekességképpen néhány régebbi programnyelv, amelyek elterjedtek voltak, de ma már csak elvétve találkozni velük:

• FORTRAN (FORmula TRANslator) • tudományos számítások • legmagasabb szintű adatstruktúra a tömb • ma főleg nagygépeken, vagy régi programok mélyén használják

• COBOL • emberközeli szintaktika • adatbáziskezelés • ma (szinte kizárólag) nagygépen használják

6

• PROLOG ( = PROgramming in LOGic) • matematikai logikán alapuló programozás • logikai problémák megoldásánál hatékony, de másra nehézkesen használható • mesterséges intelligencia kutatás

• LISP ( = LISt Processing) • listafeldolgozás • funkcionális programozás • mai programok mélyén: pl. Emacs, AutoCAD

• SMALLTALK • az első igazi objektum-orientált programozási nyelv • interpreteres megoldás

A programozási módszerek • Moduláris programozás • Strukturált programozás • Objektumorientált programozás Moduláris programozás Jellemzői: Top-down dekompozíció, majd Bottom-up kompozíció. Top-down dekompozíció: Top-down = felülről lefelé (lebontás), A megoldandó feladat komplexitását kell csökkenteni, ezért osszuk fel részfeladatokra a feladatot. Ha a részfeladatok is túl bonyolultak, osszuk azokat is részfeladatokra, és tegyük mindaddig, amíg a részek átláthatóak nem lesznek. Ha ezeket leprogramozzuk, ezek lesznek a modulok. Ettől moduláris a programozás. Bottom-up kompozíció: Bottom-up = lentről felfelé (összeépítés) Lentről fölfelé felépítjük a programot. Nincs módszer és nincs technika arra, hogy az önmagában tökéletesen jól működő modulokból hogyan lehet jó programot összeállítani. A program helyességére nem tud pozitív választ adni. Moduláris programozás moduljai:

• Adatmodul • vezérlőmodul • I/O modul

A modulok szabványosíthatók, modulkönyvtárakban elhelyezhetők. Strukturált programozás Böhm és Jacopini tétele: Egy tetszőleges algoritmus felépíthető a következő elemekből:

Szekvencia: egymás után végrehajtható utasítások sorozata. Szelekció: választás megadott tevékenységek közül. Iteráció: megadott tevékenységek ismételt végrehajtása.

Szekvencia: Szelekció: Iteráció:

7

Átveszi a Top-down-t. A csak szekvenciából, szelekcióból és iterációból felépülő programot strukturált programnak nevezzük. Minden strukturált (imperatív) program szerkezete egy szekvencia azzal a megkötéssel, hogy csak egy belépési és egy kilépési pontja van. A ciklusból való kiugrást (GOTO) nem használja. A szekvencián belül használható a szelekció és az iteráció is. Dijkstra dolgozta ki a strukturált programozás általános módszerét. Objektumorientált programozás Ez a módszer az objektum bevezetésével megszünteti a program kódjának és adatainak szétválását. Az objektumok felhasználásával egyszerű szerkezetű, jól kézben tartható programok készíthetők.

Adatok Mivel a programok utasításai adatokon dolgoznak, ismerkedjünk meg először ezekkel! Minden adattípusnál meg kell nézni, hogy milyen értékeket képes tárolni, hogyan ábrázolja a számítógép, és végül milyen műveleteket végezhetünk velük. Elemi (egyszerű) adattípusok Numerikus (szám) típusok: fixpontos típus, és lebegőpontos típus. Egész (fixpontos) típus: Ábrázolása kettes számrendszerben történik. Egy kettes számrendszerbeli számjegy - egy bit. Az ábrázolható számtartomány attól függ, hogy hány biten (n) történik a tárolás:

ábrázolható számtartomány előjel nélküli 0 … 2n-1

előjeles -2n-1 … 2n-1-1

Ha csak nem-negatív számokat kellene ábrázolni: 0 → 216-1 a 2 bájtos tartomány. 16 bites előjeles egész esetében ez -215...215-1, vagyis -32768…32767. A mai gépek általában 8, 16, 32, 64 biten tárolják az egész számokat. A negatív számokat olyan formában célszerű tárolni, hogy a gépi kivonás összeadással legyen helyettesíthető, mert akkor a számítógépnek csak az összeadást kell tudnia elvégezni. Az előjeles egész számok ábrázolására Neumann János dolgozta ki a kettes komplemens képzés (más néven nullára történő kiegészítés) módszerét. Komplemens képzés: a bináris szám minden jegyét átfordítjuk a másik jegyre. Például: 0101 0001 → 1010 1110 (Ezt egyes komplemensnek is szokás nevezni.) Ha a komplemenshez még 1-et hozzáadunk kettes komplemens alak jön létre. Pl.: 89 = 0101 1001

1010 0110 komplemens + 1

1010 0111 kettes komplemens Vegyük észre, hogy ha a számot és kettes komplemensét összeadjuk, akkor az adott méretben (példánkban 8 biten) az eredmény 0 lesz!

0101 1001 +1010 011110000 0000

8

Vessük össze ezt azzal a matematikában megismert ténnyel, hogy bármely számhoz a negatívját hozzáadva az eredmény 0 lesz! Tehát 89 kettes komplemense lesz a -89. A számítógépek többnyire a kettes komplementer képzésen alapuló eljárással végzik a kivonást. Negatív számok tárolása: láttuk az előbbiekben, hogy az x ≥0 esetben -x az x kettes komplemenseként állítható elő.Lássunk egy 16 bites példát (x=12 16 biten ábrázolva):

0000 0000 0000 10101111 1111 1111 0101 komplemens

1111 1111 1111 0110 kettes komplemens (-x=-12) Még van egy probléma: hogyan tudjuk eldönteni, hogy egy ilyen szám pozitív-e vagy pedig egy másik pozitív szám kettes komplemense? A felírásból sehogy! Ezért megegyeztünk abban, hogy a nem negatív számok csak az alsó 15 bitet foglalják el, ilyen módon ezek kettes komplemensének legfelső bitje 1 lesz, azaz ezek lesznek a negatív számok. A 0000 0000 kettes komplemense is 0. Az 1000 0000 negatív szám kettes komplemense : 1000 0000. Tehát a k 16 bites egész: - 32 768 ≤ k ≤ 32 767

Valós (lebegőpontos) típus ábrázolható számtartomány

egyszeres pontosságú 10-38…1038 dupla pontosságú 10-307…10307

A fixpontos számábrázolásnak 2 hátrányos tulajdonsága van: - kicsi az ábrázolható számtartomány - a pontosság erősen korlátozott: ha a szám végére képzeljük a tizedespontot, az egészek közötti értékek a gép számára nem léteznek. Azaz : 1/3=0 vagy 5/3=1 stb. A lebegőpontos számábrázolás a számok hatványkitevős felírásán alapszik. Pl. 1800000000=1.8∗109

1100011101.011=0.1100011101011∗27

azaz M∗pk

A képletben k a számrendszer alapszáma (példánkban 10 ill. 2). Hogy egyértelmű legyen a felírás M<1 és a tizedesponttól jobbra álló első jegy nem 0. A lebegőpontos szám a számítógépen a bináris számok hatványkitevős alakja. Ehhez a számot ún. kettes normál alakra kell hozni. Pl. /-12.25/ = 1100.012 =0.110001∗24

A szám kettes normál alakjának karakterisztikája 4 = 1002így a szám kettes normál alakban: -0.110001∗2100 Az ábrázolás a következő módon történik: - első bit a szám előjele, - 7 biten a karakterisztika torzítva, - végül 3 bájton a mantissza. Karakter (character) típus

ábrázolása kódolás 7/8 bit ASCII 2 byte UNICODE

9

A karakterek ábrázolása számítógépen a kódjukkal (bináris szám) történik! Szabványos kódrendszerek (ASCII, EBCDIC, UNICODE) a számítástechnika alappillérei. A kódrendszerek lényege, hogy minden karakterhez kölcsönösen egyértelmű megfeleltetéssel hozzá van rendelve egy 8 vagy 16 bites kódérték. A karaktereket a kódjukkal azonosítjuk.

Összetett adatok Tömb Adott számú (általában azonos típusú) adat együttese. Dimenzió szerint:

• 1 dimenziós: vektor • 2 dimenziós: mátrix • több dimenziós

Például számokból álló 5 elemű egydimenziós tömb: 12 -3 0 -3 1

Indexelés: A tömb minden elemének van egy sorszáma, ami azonosítja az elemet. Ezt indexnek nevezzük.

Rekord/ Struktúra Több, különböző típusú adat együttese. Az összegyűjtött adatok a rekord/struktúra mezőit képzik. Objektum A rekordok/struktúrák továbbfejlesztése: az adattagokon (adatmezőkön) kívül tagfüggvényeket (metódusokat) is tartalmaznak. Változók Programozás-technikai megközelítésben a változó egy névvel ellátott tároló hely a számítógép memóriájában. A változó értéke ennek a tároló helynek a pillanatnyi tartalma. A változó jellemzői: név típus tárbeli kezdőcím érték A változókban tároljuk az adatokat, így egy változó típusa a benne tárolt adat típusával azonos. Tehát lehetnek elemi változók (egész, valós, karakter, mutató) és összetett változók (tömb, struktúra). A változók kezelésének elve:

Adatterület a memóriában Név Típus Tárcím a egész 1526b valós -112,86 c karakter ’M’

„Ha valaki megértette már a változók használatát a programozásban, akkor megértette a programozás lényegét.” (E. W. Dijkstra)

10

Algoritmikus programozás Algoritmus Az algoritmus olyan pontos előírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát. Az algoritmussal szemben támasztott legfontosabb követelmények:

• legyen időben és lépésszámban véges;• legyen egyértelmű: ugyanazon bemenő adatokra minden esetben ugyanazt az eredményt

szolgáltassa; • legyen általános: ne csak egy konkrét feladatot oldjon meg, hanem lehetőleg minél

szélesebb problémaosztályt! (Pl. ne csak egy konkrét másodfokú egyenletet, hanem bármilyen másodfokú egyenletet oldjon meg!)

Az egyes lépésekben elvégezhető műveletek Neumann-elvű számítógépek esetében:

• egyszerű utasítások: • értékadás • függvényhívás

• összetett utasítások: • utasítás blokk (több utasítás egyben) • vezérlési szerkezetek (program menetének befolyásolásához használhatók)

• elágazások: döntési szerkezetek • ciklusok: ismétlési szerkezetek

Bármilyen programozási módszert alkalmazunk és bármilyen nyelven írjuk is meg a programot, először meg kell terveznünk a probléma megoldására szolgáló elemi lépések sorozatát, azaz az algoritmust!Algoritmusok tervezésére, leírására, szemléltetésére többféle eszköz létezik Algoritmus leíró módszerek: • folyamatábra (blokkdiagram) • mondatszerű leírás (pszeudokód) • struktogram • Jackson módszer A következőkben 2 algoritmus leíró módszer kerül ismertetésre: a mondatszerű leírás és a folyamatábra. Mindkét esetben a legfontosabb szerkezetek jelöléseit adjuk meg: 1. adat be- és kivitel; 2. értékadás; 3. utasítássorozat (szekvencia); 4. feltételes elágazás (szelekció); 5. ismétlési szerkezet (iteráció); 6. eljárás vagy függvény megadása (deklaráció);

11

Mondatszerű leírás (pszeudokód) Az anyanyelvi megfogalmazáshoz hasonló, de annál tömörebb leírási mód. Az élőnyelv pontatlanságait próbáljuk vele kizárni, de még egyszerűen értelmezhető marad. 1. BE: változók [az adatokkal szemben állított követelmények]

KI: kifejezések [a kiírás formájára vonatkozó követelmények]2. Értékadás:

változó=kifejezés Az utasítás hatására a változó felveszi a kifejezés aktuális értékét.

3. Utasítás sorozat: Egymás alá írással adjuk meg az egymás után végrehajtandó utasításokat.

4. Feltételes elágazások:

a) Egyágú HA feltétel AKKOR utasítás

ELÁGAZÁS VÉGE (Ha a feltétel teljesül, akkor az utasítás végrehajtásra kerül,

ha nem teljesül, akkor az ELÁGAZÁS VÉGE után folytatódik a program. Az utasítás helyén több utasítás is állhat.)

b) Kétágú Ha feltétel AKKOR utasítás1KÜLÖNBEN utasítás2ELÁGAZÁS VÉGE

(Ha a feltétel teljesül, akkor az utasítás1 kerül végrehajtásra, ha nem akkor az utasítás2. Mindkét esetben az ELÁGAZÁS VÉGE után folytatódik a program.)

c) Többágú

ELÁGAZÁS feltétel1 ESETÉN utasítás1

feltétel2 ESETÉN utasítás2....................

feltételn ESETÉN utasításnEGYÉB ESETBEN utasítás

ELÁGAZÁS VÉGE (Ha az i-edik, feltételi teljesül, akkor az utasítási kerül végrehajtásra, ha egyik feltétel sem teljesül, akkor az utasítás. Bármely esetben az ELÁGAZÁS VÉGE után folytatódik a program. A feltételeknek egymást kizárónak kell lennie, azaz legfeljebb egy teljesülhet közülük.)

5. Ismétlési szerkezetek (ciklusok):

a) ElöltesztelőCIKLUS AMÍG feltétel ciklusmag CIKLUS VÉGE

(Amíg a feltétel teljesül, addig a ciklusmag végrehajtásra kerül, ha már nem teljesül, akkor a CIKLUS VÉGE után folytatódik a program.)

12

b) HátultesztelőCIKLUS ciklusmag AMÍG feltétel CIKLUS VÉGE

(A ciklusmag mindaddig végrehajtásra kerül, amíg a feltétel teljesül. Ha már nem teljesül, akkor a CIKLUS VÉGE után folytatódik a program. Egyszer a ciklusmag mindenféleképpen végrehajtódik!)

6. Eljárás vagy függvény megadás: ELJÁRÁS eljárás_neve (paraméterek)

utasítások ELJÁRÁS VÉGE

Az eljárás vagy függvény hívása nevének és paramétereinek leírásával történik meg. A program egy kitüntetett szerepű eljárás (vagy függvény), neve meghatározott: PROGRAM utasítás sorozat PROGRAM VÉGE (A C programokban ennek a kitüntetett szerepű eljárásnak a main() függvény felel meg, amely a belépési pont.)

Folyamatábra (blokkdiagram) Az egyik legkorábban kialakult megadási mód. Alapjeleit maga Neumann János dolgozta ki. Az egyes szerkezeti elemek között nyilakkal jelöljük a végrehajtási sorrendet. Ennek köszönhetően igen vadul ugráló programok is születhetnek, minden átgondolt szerkezet nélkül. Az értékadó utasítás illetve valamilyen eljárás téglalapba, az egy vagy többágú kiválasztás rombuszba vagy lapos hatszögbe, az adatáramlás paralelogrammába, a vezérlő utasítások körbe kerülnek. Az ismétlési szerkezeteket elrejtve tartalmazza az ábra. Csak nagy odafigyeléssel és következetességgel érhetjük el a strukturáltságot. 1. Adat be- és kivitel:

2. Műveletvégzés:

BE: változó KI: kifejezés

változó= kifejezés

13

Lehet értékadó, de másfajta utasítás is. Példánkban utasításként az értékadás szerepel: a változó felveszi a kifejezés aktuális értékét.

3. Utasítás sorozat: A nyilak által meghatározott irányban haladva kell végrehajtanunk az utasításokat. 4. Feltételes elágazás:

Ha a feltétel teljesül, akkor az utasítás1 kerül végrehajtásra, ha nem, akkor az utasítás2.Mindkét esetben folytatódik a program. Megfelel a kétágú feltételnek. Egyágú esetén nincs utasítás a hamis ágban. A többágú elágazás is összeépíthető ebből. 5. Ismétlési szerkezet: A hátul tesztelő ciklus a következőképpen építhető fel:

feltétel

feltétel

utasítás1utasítás1 utasítás2

I H

ciklusmag

I

H

14

A ciklusmag mindaddig végrehajtásra kerül, amíg a feltétel teljesül. Ha nem teljesül, akkor folytatódik a program. (Egyszer a ciklusmag mindenféleképpen végrehajtódik!)

6. Eljárás megadás:

Külön blokkdiagramot készítünk számára. Az eljárás hívása az eljárásnév ovális dobozba írásával történik. A program egy kitüntetett szerepű eljárás, kezdőpontja a START, végpontja a VÉGE:

eljárásnév

utasítások

VÉGE

START

ELJÁRÁS VÉGE

utasítások

eljárásnév

15

Az alapvető vezérlési szerkezetek összehasonlítása Elágazások Egyágú elágazás:

blokkdiagram algoritmus leíró nyelv

Ha feltétel akkor

utasítások Elágazás vége

Kétágú elágazás: blokkdiagram algoritmus leíró nyelv

Ha feltétel akkor

utasítások különben

utasítások Elágazás vége

Ciklusok Elöl tesztelős ciklus: Először megvizsgálja a feltételt (belépési feltétel), és csak akkor hajtja végre a ciklusmagban lévőutasításokat, ha a feltétel igaz. Vegyük észre, hogy ha kiinduláskor már hamis a belépési feltétel, akkor egyszer sem fut le a ciklustörzs.

blokkdiagram algoritmus leíró nyelv

Ciklus amíg feltétel ciklusmag Ciklus vége

Hátul tesztelős ciklus: Először végrehajtja a ciklusmagban lévő utasításokat, majd megvizsgálja a feltételt, és ha ez igaz, akkor újra végrehajtja a ciklustörzset. Vegyük észre, hogy a ciklusmag mindenképp lefut egyszer.

blokkdiagram algoritmus leíró nyelv

Ciklus ciklusmag

amíg feltétel Ciklus vége

I

H I

H

IH

16

Példa algoritmus készítésre Egy egyszerű feladat megoldásával szemléltetjük a két algoritmus leíró módszert. Feladat.: adjuk össze 1-től 100-ig a számokat! A feladat megoldása elöl tesztelő ciklussal:

PROGRAM A=1 S=0 CIKLUS AMÍG A<=100 S=S+A A=A+1 CIKLUS VÉGE Ki:S [Az összeg 1-100] PROGRAM VÉGE

START

A=1

S=0

A<100 Ki:S az összeg

S=S+A

A=A+1

STOP

START

A=1

S=0

A<101 Ki:S az összeg

S=S+A

A=A+1

STOP

n

i

17

A feladat megoldása hátul tesztelő ciklussal:

PROGRAM A=1 S=0 CIKLUS S=S+A A=A+1 AMÍG A<=100 CIKLUS VÉGE Ki:S [egész, Összeg 1-100] PROGRAM VÉGE

START

A=1

S=0

A<101

Ki:S az összeg

S=S+A

A=A+1

STOP

START

i

n

18

Elemi algoritmusok A számítógépes feladatmegoldás során az algoritmus megtervezésekor bizonyos elemi tevékenységek gyakran felmerülnek megoldandó feladatként. Az ezeket megoldó elemi algoritmusokat (programozási tételeket) mutatjuk meg a következőkben. Az algoritmusokat mondatszerű leírással adjuk meg. Algoritmusok, amelyek egy sorozatból egy adatot állítanak elő:Elemek összegzéseAdott egy N elemű A számsorozat. Határozzuk meg az elemek összegét! A végeredményt az S tartalmazza. ELJÁRÁS ÖSSZEGZÉS (A[],N,S)

S= 0I=0

CIKLUS AMÍG I< NS= S +A[I]

I=I+1 CIKLUS VÉGE

ELJÁRÁS VÉGE

Lineáris keresésAdott egy N elemű A sorozat, és egy, az elemein értelmezett, T tulajdonság. Döntsük el, hogy van-e olyan eleme a sorozatnak, amely rendelkezik a T tulajdonsággal, és ha van, akkor hányadik! (Ha nincs ilyen tulajdonságú elem, akkor a sorszám értéke legyen -1!) ELJÁRÁS Lineáris_ keresés (A[],N,T,SORSZAM)

SORSZAM=-1 I=0 CIKLUS AMÍG I < N ÉS A[I] NEM T tulajdonságú

I= I+1 CIKLUS VÉGE

Ha I < N akkor SORSZAM=I ELÁGAZÁS VÉGE

ELJÁRÁS VÉGE

Maximum kiválasztásaAz előbbi feladat egy speciális eseteként, egy adott sorozat legnagyobb (vagy esetleg legkisebb) elemének megkeresése is gyakran előfordul. Adott N elemű A számsorozatból keressük ki a legnagyobb elemet!

ELJÁRÁS MAXIMUM (A[],N,MAX) MAX= A[0] I=1 CIKLUS AMÍG I < N

HA MAX< A[I] AKKOR MAX=A[I] ELÁGAZÁS VÉGE

I=I+1 CIKLUS VÉGE

ELJÁRÁS VÉGE

19

MegszámlálásA tulajdonság előfordulása mellett az is kérdés lehet, hogy hány elem rendelkezik ezzel az adott tulajdonsággal. Legyen adott egy N elemű A sorozat és egy, az elemein értelmezett, T tulajdonság. Határozzuk meg a T tulajdonsággal rendelkező elemek számát!

ELJÁRÁS MEGSZÁMLÁLÁS(A[],N,DB) DB= 0I=0 CIKLUS AMÍG I < N

Ha A[I] T tulajdonságú AKKOR DB= DB+1 ELÁGAZÁS VÉGE

I=I+1 CIKLUS VÉGE

ELJÁRÁS VÉGE

PÉLDA: Ha a sorozat: 1, 3, 5, 7 a tulajdonság a párosság, akkor DB=0. Ha a sorozat: 1, 2, 4, 8 a tulajdonság a párosság, akkor DB=3. Algoritmusok, amelyek egy sorozatból egy másik sorozatot állítanak elő:

KiválogatásEgy sorozat elemei közül azokat válogatjuk ki egy új sorozatba, amelyek megfelelnek egy adott tulajdonságnak. Legyen adott egy N elemű A sorozat és egy, az elemein értelmezett, T tulajdonság. Gyűjtsük ki a Bsorozatba az A sorozat T tulajdonságú elemeit! A készülő sorozat elemszáma DB lesz. (Ha az Asorozatban nincs T tulajdonságú elem, akkor DB 0 lesz!)

ELJÁRÁS KIVÁLOGATÁS (A[],N,T,B[],DB) DB=0 I= 0 CIKLUS AMÍG I < N

HA A[I] T tulajdonságú AKKOR B[DB]=A[I] DB=DB+1

ELÁGAZÁS VÉGE I=I+1

CIKLUS VÉGE ELJÁRÁS VÉGE

Rendezések Gyakran a rendezett elemekkel való műveletvégzés sokkal hatékonyabb, mint rendezetlen elemek esetében. Ezért nagyon fontosak a sorozat elemeit más sorrendbe előállító algoritmusok. A kívánt rendezési irány lehet növekvő vagy csökkenő Valamennyi ismertetésre kerülő rendezési algoritmusban a növekvő sorrend elérése a cél. A többféle rendezési módszer közül a legismertebbek algoritmusát adjuk meg. A rendezéseket mindig helyben, új sorozat létrehozása nélkül kell megoldani. Ha két sorozattag között a reláció nem a kívánt rendezettség szerinti, akkor a tagok felcserélésére van szükség.

20

Két elem cseréjét a következőkben az alábbi módon jelöljük: EGYIK ↔ MÁSIK.A csere megvalósításához egy segéd változót használunk:

EGYIK ↔ MÁSIK jelentése tehát: segéd= egyik

egyik= másik másik= segéd

Minimum-elven alapuló rendezésA minimumkereséses rendezés lényege az, hogy egy adott intervallumban - amely kezdetben a teljes sorozat - megkeressük a legkisebb elemet, s azt tesszük az első helyre. A következő lépésben eggyel szűkítjük az intervallumot (megnöveljük a sorozat alsó határát jelölő indexet), és ismét a legkisebb elemet visszük előre. Végül a rendezendő adatok elfogynak, a sorozat végére érünk. A mindenkori legkisebb elem keresése lineáris módszerrel történik. (Ha a kívánt sorrend a csökkenő rendezettség, akkor a maximum-elvű rendezési algoritmust használjuk, ami csak a relációban különbözik.)

ELJÁRÁS Minimum_elv (A[], N) I=0

CIKLUS AMÍG I < N-1 J=I+1

CIKLUS AMÍG J < NHA A[I] > A[J] AKKOR

A[I] ↔ A[J] ELÁGAZÁS VÉGE J=J+1

CIKLUS VÉGE I=I+1

CIKLUS VÉGE ELJÁRÁS VÉGE

Buborék rendezés A buborék rendezés mindig két szomszédos elemet vizsgál, s ha azok a kívánt rendezettségnek nem megfelelő relációban vannak, felcseréli őket, majd tovább lépve újabb elempárt vizsgál. Az elejétőla végéig ismételten végigpásztázva az egész sorozatot, eljutunk a rendezett állapotig, amikor már nincs szükség cserére. A belső ciklus egy lefutása után a legnagyobb elem az utolsó helyre kerül.

ELJÁRÁS BUBORÉK_ELV(A[],N) I=1

CIKLUS AMÍG I < NJ=0

CIKLUS AMÍG J < N-I HA A[J] > A[J+1] AKKOR A[J] ↔ A[J+1] ELÁGAZÁS VÉGE

J=J+1 CIKLUS VÉGE

I=I+1 CIKLUS VÉGE

ELJÁRÁS VÉGE

21

Javított buborékos rendezés Ha a buborékos rendezésnél egy teljes belső ciklus lefutása alatt egyetlen csere sem volt, akkor a sorozat már rendezett. Ilyenkor feleslegesek a további összehasonlítások. A CSERE változó jelzi azt, hogy a belső ciklusban kellett-e cserélni. A belső ciklus indulása előtt, előkészítésként, a változót nullázzuk, és csak akkor lesz újra 1 az értéke, ha cserére volt szükség. Tehát, ha az összes szomszédos elem-pár a kívánt rendezettségnek megfelelő relációban van, akkor a CSERE változó értéke 0 marad.

ELJÁRÁS JOBB_BUBORÉK(A[],N) CSERE = 1CIKLUS AMÍG CSERE ==1 CSERE = 0J=0 CIKLUS AMÍG J<N-1

HA A[J]>A[J+1] AKKOR A[J]↔A[J+1] CSERE =1

ELÁGAZÁS VÉGE J=J+1

CIKLUS VÉGE CIKLUS VÉGE

ELJÁRÁS VÉGE

Tovább javított buborékos rendezés Mivel a belső ciklus egyszeri lefutása után a legnagyobb elem az utolsó helyen áll, ezt az elemet már felesleges vizsgálni. Ebben az algoritmusban a belső ciklus minden alkalommal eggyel kevesebb elemre fut le, mert a DB változót a belső ciklus befejeződése után csökkentjük.

ELJÁRÁS LEGJOBB_BUBORÉK(A[],N)

CSERE = 1DB = NCIKLUS AMÍG CSERE == 1CSERE = 0J=0 CIKLUS AMÍG J< DB -1

HA A[J]>A[J+1] AKKOR A[J]↔A[J+1] CSERE =1

ELÁGAZÁS VÉGE J=J+1

CIKLUS VÉGE DB = DB-1

CIKLUS VÉGE ELJÁRÁS VÉGE