ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (1. előadás)
|
|
- János Orsós
- 7 évvel ezelőtt
- Látták:
Átírás
1 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (1. előadás) Programozási feladatok megoldásának lépései 1, a feladatok meghatározása -egyértelmű, rövid, tömör, pontos 2, a feladat algoritmusának elkészítése jól definiált (automatizálható, programozható) számítási eljárás egy meghatározott számítási feladat megoldására, amely bementként bizonyos értékeket kap és kimenetként bizonyos értékeket állít elő. Egy algoritmust helyesnek mondunk, ha minden bemenetre megáll és helyes eredményt ad. A helyes algoritmus megoldja az adott számítási feladatot. Általános feladatok fő részei: - a bemenő adatok bevitele - azokon a szükséges műveletek elvégzése - az eredmények megjelenítése, rögzítése, kiíratása Érdekes az algoritmusok hatékonysága két szempontból is: - felhasznált időben (ezt használjuk rendszerint az algoritmus bonyolultsága mértékeként) - felhasznált memóriában Ugyanannak a feladatnak a megoldására fejlesztett algoritmusok nagy mértékben eltérő hatékonyságot mutathatnak. 3, kódolás - a kész algoritmus valamilyen konkrét programnyelvre való lefordítása Program: a gép számára érthető formájú meghatározott sorrendű, véges, gépi utasítássorozat. 4, tesztelés 5, dokumentálás: felhasználói dokumentáció és fejlesztői dokumentáció Algoritmusleíró eszközök Céljuk: a megoldás menetének géptől független, szemléletes, a logikai gondolatmenetet, a szerkezeti egységeket világosan tükröző leírása. Legismertebb algoritmusleíró eszközök: a, folyamatábra b, mondatszerű leírások 1
2 Folyamatábrák A folyamatábra a feladat megoldási lépéseinek sorrendjét - művelettípusonként különböző geometriai alakzatok felhasználásával - szemléltető ábra. A felhasznált szimbólumok és jelentésük a következő: START STOP - ún. határszimbólumok, az algoritmus elejét és végét jelzik - beolvasó és kiíró művelet - értékadás, művelet végrehajtás, aritmetikai kifejezés kiértékelése n i - elágazás. A feladat végrehajtása, egy a rombuszba írt feltétel alapján, egyik vagy másik irányba folytatódik. A rombusznak két kimenete van, amelynek (i, n) jelzéssel vannak ellátva. Az i kimenetet kell folytatni, ha a feltétel teljesül (igaz), különben (hamis esetén) az n kimenetet kell követni. - gyakran találkozhatunk a számlálós ciklus jelölésére a következő szimbólummal is 2
3 A folyamatábrán az algoritmus haladási irányát nyilakkal jelöljük. Abban az esetben, ha a nyilakat elhagyjuk a folyamatábrát fentről lefelé, illetve balról jobbra kell követni. A folyamatábrák hátránya, hogy elemei nem felelnek meg az algoritmuskészítés során felhasználható, a strukturált programozásra jellemző struktúráknak (szekvencia, elágazás, ciklus). Használatukkal igen könnyen előállíthatók olyan bonyolult szerkezetek is, melyek megértése azután nagyon nagy problémát jelent. Nézzük egy nagyon egyszerű feladat algoritmusát folyamatábrán szemléltetve: FELADAT: Kérjünk be a billentyűzetről N (>0, egész) számot és számoljuk ki az összegüket! 3
4 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (2. előadás) Mondatszerű leírások A mondatszerű leírások szemléletesebb módja az, amikor az algoritmus leírására mondatok helyett csak ún. mondatszerű szerkezeteket használjuk. Mondatszerű szerkezetek egymásutánjával írjuk le a feladat megoldását. Ennél a leírási módnál az algoritmus szerkezeti egységeit bekezdéses struktúra segítségével szemléltetjük. Az egyértelműség kedvéért meg kell határozni, milyen műveleteket (utasításokat) tartalmaz az így készített algoritmus leíró nyelv és utasítás fajtánként, hogyan definiáljuk ezeket a mondatszerű szerkezeteket! Beolvasó és kiíró utasítás Formája : Be: <változók felsorolása> Ki: <kifejezések felsorolása> // az adatokkal szemben támasztott // követelmények // a kiírás formájára vonatkozó // követelmények Értékadó utasítás Formája: <változó> := <kifejezés> // Az utasítás hatására a baloldalon álló változó felveszi a jobboldalon álló kifejezés értékét. Elágazások ( feltételes utasítások) Formája : A, Ha (<feltétel>) akkor // Ha az adott feltétel teljesül akkor az <utasítás(ok)> // utasítás(ok) kerül(nek) végrehajtásra és a // feladat megoldása a után folytatódik. // Ha a feltétel nem teljesül, akkor a feladat a Ha // vége után folytatódik. B, Ha (<feltétel>) akkor // Ha az adott feltétel teljesül akkor az <utasítás(ok)1> // utasítás(ok)1 kerül(nek) végrehajtásra. Ha a különben // feltétel nem teljesül, akkor az utasítás(ok)2 <utasítás(ok)2> // kerül(nek) végrehajtásra. Mindkét esetben a // feladat megoldása a után folytatódik. C, Elágazás // Sorban vizsgálja a feltételeket. Amikor <feltétel1> esetén <utasítás(ok)1> // megtalálja az első teljesülő feltételt, <feltétel2> esetén <utasítás(ok)1> // a hozzátartozó utasítás(ok) kerül(nek) // végrehajtásra.ha nem talált egyetlen egy <feltételn> esetén <utasítás(ok)n> // feltételt sem, amely teljesül, akkor az egyéb esetben <utasítás(ok)n+1> // egyéb esetben - hez tartozó utasítás(ok) Elágazás vége // kerül(nek) végrehajtásra. Minden // esetben a feladat megoldása az // Elágazás vége után folytatódik. 4
5 Ciklusszervező utasítások Formája: A, Ciklus <ciklus-változó> := <kezdőérték> -től <végérték> -ig <lépésköz> -esével <ciklusmag utasításai> // Végrehajtja a ciklusmag utasításait a ciklus-változó kezdőértékével. Ezután növeli a ciklus- // változó kezdőértékét a lépésközzel, és az új értékkel hajtja végre a ciklusmag utasításait. Ez // a folyamat addig ismétlődik, amíg a ciklus-változó kisebb vagy egyenlő, mint a végérték. // Ha a ciklus-változó értéke nagyobb, mint a végérték, akkor a feladat megoldása a Ciklus // vége után folytatódik. Ha a kezdőérték nagyobb, mint a végérték, akkor a ciklusmag // utasításai egyszer sem kerülnek végrehajtásra. A lépésköz, 1 esetén, elhagyható. Szokásos // ezt a szerkezetet számlálós ciklusnak nevezni. B, Ciklus amíg <feltétel> <ciklusmag utasításai> // A ciklusmag utasításai addig hajtódnak végre amíg a feltétel igaz, s ha a feltétel hamis // akkor a program végrehajtása a után folytatódik. Szokásos elnevezés: // elöl tesztelős ciklus. C, Ciklus <ciklusmag utasításai> amíg <feltétel> // A ciklusmag utasításai addig hajtódnak végre amíg a feltétel igaz, s ha a feltétel hamis // akkor a program végrehajtása a után folytatódik. A ciklusmag utasításai // egyszer mindenképpen végre hajtódnak. Elnevezés: hátul tesztelős ciklus Egyéb jelölések: // kiegészítések, megjegyzések (már használtuk!) : ha egy soron belül több utasítást használunk <tomb-név>[ ] - tömbök jelölése ha teljes algoritmust írunk: <algoritmus utasításai> ha eljárást( függvényt írunk): <eljárásnév>(<paraméterek>) <eljárás utasításai> <eljárásnév> vége Eljárás esetén a paraméterek az eljárás bemeneteinek a felsorolása. Az eljárás kimeneteit a Return <kifejezések felsorolása> 5
6 segítségével adjuk meg, amely a visszatérési értékeket adja vissza és az eljárás végrehajtását fejezi be. A megadott szabály kivétele a tömbök. Ha egy tömb szerepel paraméterként, akkor bemenő és kimenő paraméter is, azaz, ha az eljárásban módosítjuk a tömb paramétert, akkor a módosítások érvényesülnek az eljárás végrehajtása után az eljárást hívó algoritmusban is. Nézzük a szokásos feladat ( N>0 billentyűzetről olvasott egész szám összegének a kiszámítása) mondatszerű leírásának algoritmusát: Bemenet: N (az összeadandó számok száma) Kimenet: Szum (a képzett összeg) Be: N // N>0 egész Szum:=0 Ciklus i:=1-től N -ig Be: A Szum:= Szum+A Ki: Szum 6
7 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (3. előadás) Egyszerű algoritmusok Aki már több programot készített különböző témákban, bizonyára tapasztalta, hogy az egyes problémák, feladatok, részfeladatok tipizálhatóak, megoldásukhoz gyakorlatilag ugyanaz az algoritmus szükséges legfeljebb a körítés azaz a feladat szövege, a változók, konstansok mások és mások. Ebben a részben most néhány egyszerű, ilyen típus algoritmus következik. Összegzés Adva van egy N elemű számsorozat, és ki kell számolni az elemeinek az összegét! A sorozat elemeit ennél a tételnél és a következőkben is az N elemű A[1..N] vektorban tároljuk. Bemenet: A[1..N] Kimenet: Szum Szum:=0 Ciklus i := 1-től N-ig Szum:=Szum+A[i] Példa az összegzés alkalmazására: A hét minden egyes napján megmértük egyszer a hőmérsékletet s az értékeket a HOM[7] vektorban tároljuk. Számítsuk ki a heti átlaghőmérsékletet! Atl:=0 Ciklus i := 1-től 7-ig Atl:=Atl+Hom[i] Atl:=Atl/7 Eldöntés Adva van egy N elemű sorozat, és egy a sorozat tagjain értelmezett T tulajdonság. Olyan algoritmust kell írni, amely eldönti: van-e a sorozat tagjai közt legalább egy T tulajdonságú. Bemenet: A[1..N], T tulajdonság Kimenet: Eredmény ( VAN T tulajdonságú vagy NINCS T tulajdonságú ) i:=1 Ciklus amíg i<=n és A[i] nem T tulajdonságú 7
8 i:=i+1 Ha( i<=n) akkor Eredmény := VAN T tulajdonságú különben Eredmény := NINCS T tulajdonságú Példa az eldöntésre: Egy N=20 fős osztály tanulóinak magasságát a Mag[20] elemű vektorban tároljuk. A feladat annak eldöntése, hogy van-e 180 cm-nél magasabb tanuló. i:=1 Ciklus amíg i<=20 és Mag[i]< =180 i:=i+1 Ha (i<=20) akkor Eredmény := VAN 180-nál magasabb különben Eredmény := NINCS 180-nál magasabb Kiválasztás Adva van egy N elemű sorozat, és egy a sorozat tagjain értelmezett T tulajdonság. Tudjuk, hogy a sorozat tagjai között van T tulajdonságú. Olyan algoritmust kell írni, amely megadja a sorozat első T tulajdonságú tagjának a sorszámát. Bemenet: A[1..N], T tulajdonság Kimenet: Sorszam i:=1 Ciklus amíg A[i] nem T tulajdonságú i:=i+1 Sorszam:=i Példa kiválasztásra : Tudjuk, hogy az N=20 tagú osztály tagja Tóth Mihály. Hányadik a rendezett névsorban? Algoritmus 8
9 i:=1 Ciklus amíg NEV[i] <> 'Tóth Mihály' i:=i+1 Sorszám:=i Lineáris keresés Adva van egy N elemű sorozat, és egy a sorozat tagjain értelmezett T tulajdonság. Olyan algoritmust kell írni amely eldönti, hogy van- e T tulajdonságú elem a sorozatban és ha van hányadik az első T tulajdonságú elem.( előbbi két algoritmus összegzése) Bemenet: A[1..N], T tulajdonság Kimenet: Index (a sorozat első T tulajdonságú elemének sorszáma, ha nincs, akkor 0) i:=1 Ciklus amíg i<=n és A[i] nem T tulajdonságú i:=i+1 Ha (i<=n) akkor Index:=i különben Index:=0 Megszámlálás Adva van egy N elemű sorozat, és egy a sorozat tagjain értelmezett T tulajdonság. Olyan algoritmust kell írni amely megszámlálja a T tulajdonságú elemeket. Bemenet: A[1..N], T tulajdonság Kimenet: DB DB:=0 Ciklus i:=1-től N-ig Ha (A[i] T tulajdonságú) akkor DB:=DB+1 Példa megszámlálásra: Adott egy N=20 fős osztály matematika eredménye a JEGY[20] vektorban tárolva. Számoljuk össze a bukottakat! 9
10 DB:=0 Ciklus i:=1-től 20-ig Ha (JEGY[i] =1 ) akkor DB:=DB+1 Kiválogatás Adva van egy N elemű sorozat, és egy a sorozat tagjain értelmezett T tulajdonság. Olyan algoritmust kell írni, amely a T tulajdonságú elemek sorszámát egy külön B[] vektorba gyűjti. Bemenet: A[1..N], T tulajdonság Kimenet: B[1..M], ahol M az A sorozat T tulajdonságú elemeinek a száma M:=0 Ciklus i:= 1-től N-ig Ha (A[i] T tulajdonságú) akkor M:=M+1 : B[M]:=i Példa kiválogatásra: Két hétig naponta megmértük a hőmérsékletet. Válogassuk ki a fagypont alatti napok sorszámát. j:=0 Ciklus i:=1- től 14-ig Ha (Hom[i] < 0) akkor j:=j+1 : Fagy[j]:=i Maximum kiválasztása Adva van egy N elemű sorozat. Meg kell keresni a sorozat legnagyobb elemének a sorszámát. Bemenet: A[1..N], T tulajdonság Kimenet: Maxindex INDEX:=1 Ciklus i:=2-től N ig Ha ( A[INDEX] < A[i] ) akkor INDEX:=i 10
11 Maxindex:= INDEX Minimum kiválasztásnál csak a feltételes utasítás feltétele fordul meg. Abban az esetben, ha a kérdést úgy tesszük fel, hogy menyi a legnagyobb érték, akkor egy másik megoldást is kaphatunk : Bemenet: A[1..N], T tulajdonság Kimenet: Maxertek Ertek:= A[1] Ciklus i:=2-től N-ig Ha ( Ertek < A[i]) akkor Ertek:= A[i] Maxertek:=Ertek Megtehetjük azt is, hogy a két eljárást egybeépítjük. Példa maximum kiválasztásra: Készítsünk olyan eljárást, amely N ember magasságának ismeretében megadja a legmagasabb személy magasságát, valamint megjelöl egy ilyen embert! Legmagasabb(N, A[]) Index:= 1 : Ertek:=A[1] Ciklus i:= 2-től N-ig Ha (Ertek < A[i]) akkor Ertek:=A[i] : Index:=i Maxindex:=Index Maxertek:= Ertek Return Maxindex, Maxertek Legmagasabb vége 11
12 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (4. előadás) Rendezés Rendezés közvetlen kiválasztással A rendezendő számok legyenek az A tömb elemei. Az első menetben kiválasztjuk a tömb legkisebb elemét úgy, hogy az A[1]-et összehasonlítjuk az A[2].A[N] mindegyikével és akárhányszor A[1]-nél kisebbet találunk megcseréljük a két elemet, így az első kör után biztosan A[1] lesz a vektor legkisebb eleme. Ezt az eljárást A[2] A[N-1]-gyel folytatjuk. Az A vektor N-1 lépésben rendezett lesz. Bemenet: A[1..N] Kimenet: A[1..N] rendezett Ciklus i:=1-től N-1-ig Ciklus j:= i+1-től N-ig Ha (A[j] < A[i ]) akkor A:= A[j] A[j]:=A[i] A[i]:=A A módszer működését véletlenszerűen választott 16 szám esetén a következő táblázat mutatja: Eredeti kör u kör u kör u kör u Az eljárásban megfigyelhető, hogy minden menetben igen sok felesleges csere történik, mely a felesleges cserék kiküszöbölésével javítható. Rendezés minimum kiválasztással A felesleges cserék érdekében bevezetünk két segéd változót. Az 'Ertek' változóban tároljuk a az eddig megtalált legkisebb elemet, az 'Index'-ben pedig a sorozatbeli helyét. A menet végére az 'Ertek'- ben lesz a legkisebb elem, az 'Index'-ben pedig a helye. Csak a menet utolsó lépésében van szükség cserére, amikor is az értékben lévő legkisebb elemet a helyére tesszük. Bemenet: A[1..N] Kimenet: A[1..N] rendezett 12
13 Ciklus i:=1-től N-1-ig Index:=i : Ertek:= A[i] Ciklus j:= i+1-től N-ig Ha (Ertek > A[j]) akkor Ertek:= A[j] : Index:= j A[Index] := A[i] A[i]:= Ertek A módszer működését véletlenszerűen választott 16 szám esetén a következő táblázat mutatja: Eredeti kör u kör u kör u kör u Buborékos rendezés A rendezés alapgondolata a szomszédos elemek cseréje. Az első körben a rendezendő tömb végéről indulva az elemeket összehasonlítjuk az előttük levővel s amennyiben rossz sorrendben vannak felcseréljük őket. Az első kör végére a legkisebb elem biztosan a helyére kerül. Minden további körben újra a tömb végéről indulunk,de egyre rövidülnek a körök mert a tömb eleje fokozatosan rendezetté válik. Bemenet: A[1..N] Kimenet: A[1..N] rendezett Ciklus i:= 2-től N-ig Ciklus j:= N-től i- ig -1-esével Ha ( A[j-1] > A[j]) akkor A:= A[j-1] A[j-1]:= A[j] A[j]:= A A módszer működését véletlenszerűen választott 16 szám esetén a következő táblázat mutatja: Eredeti kör u kör u
14 kör u Egyszerű beillesztéses rendezés (beszúrásos rendezés) Úgy végezzük a rendezést, mintha kártyáznánk és kezünkbe egyesével vennénk fel az asztalról a kiosztott lapokat. Az éppen felvett lapnak megkeressük a kezünkben lévő, már rendezett sorozatban a helyét úgy, hogy a nála nagyobbakat egy hellyel elcsúsztatjuk, végül a felvett lapot a neki megfelelő helyre illesztjük. Bemenet: A[1..N] Kimenet: A[1..N] rendezett Ciklus j:= 2-től N-ig i:= j-1 : A:=A[j] Ciklus amíg i >0 és A<A[i] A[i+1] :=A[i] : i:= i-1 A[i+1]:= A A módszer működését véletlenszerűen választott 16 szám esetén a következő táblázat mutatja: Eredeti kör u kör u kör u ,kör u A most bemutatott rendezés hátránya, hogy elég sok mozgatásra van benne szükség. 14
15 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (5. előadás) Shell-módszer beszúrással Rendezés (folytatás) A módszer nem foglalkozik egyszerre minden rendezendő elemmel, csak az egymástól adott távolságra lévőkkel. Minden menet elején meghatározunk egy lépésközt (D), amely azt jelenti, hogy az adott menetben a tömb egymástól (D) távolságra lévő elemeit rendezzük. Adott meneten belül a rendezés több módszer szerint történhet, most beszúrással. Az induló lépésköz meghatározása úgy történik, hogy a rendezéshez szükséges menetek száma kb. log 2 N legyen. A további lépésközöket felezéssel kapjuk. Megjegyzés: A továbbiakban a log kifejezés alatt mindig 2-es alapú logaritmust értjük, azaz, számunkra, log N = log 2 N, ha külön nem említünk mást. A módszer működését véletlenszerűen választott 16 szám esetén a következő táblázat mutatja: Eredeti D=15 u D=7 u D=3 u D=1 u Bemenet: A[1..N] Kimenet: A[1..N] rendezett D:=2 [log(n)] 1 Ciklus i:=1 Ciklus amíg i<=d és i+d<=n Ciklus j:=i+d-től N-ig D-esével A:=A[j] : B:=j-D Ciklus amíg B>0 és A<A[B] A[B+D]:=A[B] : B:=B-D A[B+D]:=A i:=i+1 D:=[D/2] amíg D>0 15
16 Keresés (folytatás) Logaritmikus keresés Adva van egy N elemű RENDEZETT sorozat és egy keresett elem X. Olyan algoritmust kell írni amely eldönti, hogy van-e X elem a sorozatban és ha van hányadik. Szokás az eljárást intervallum felezéses módszernek is nevezni. Bemenet: A[1..N], X elem Kimenet: Sorszam (az X elem sorszáma az A sorozatban, ill. 0, ha X nincs A-ban) p:=1 : q:=n Ciklus k:= [(p+q)/2] Ha (A[k] < X) akkor p:=k+1 Ha (A[k] > X) akkor q :=k-1 amíg p<=q és A[k] <>X Ha (p <= q) akkor Sorszam:=k különben Sorszam:=0 A logaritmikus elnevezés onnan származik, hogy evvel a módszerrel az elem megkereséséhez szükséges lépések száma max. log N (log 2 N). 16
17 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (6. előadás) Rekurzió Rendezés (folytatás) Tervezési módszerek: - Rekurzió: A problémát megoldó algoritmus eljárásaiban alkalmazzuk a leírt eljárásokat, azaz a leírt eljárások közvetlenül vagy közvetve hívják (alkalmazzák) saját magukat. - Oszd meg és uralkodj: A probléma hasonló problémákra való bontása, a részproblémák megoldása, majd a kapott részmegoldásokból a probléma megoldásának az összeállítása. Összefésülő rendezés: Az összefésülő rendezés alkalmazza a fent említett két tervezési módszert. Egy tömb rendezéséhez felbontja azt két résztömbre (első és második fele), majd rendezi a két felet és a kapott részmegoldásokból összeállítja összefésüléssel az eredeti tömb rendezését ( Oszd meg és uralkodj alkalmazása). A felek rendezését az összefésülő rendezés alkalmazásával oldja meg ( rekurzió alkalmazása). Bemenet: A[p..r] Kimenet: A[p..r] rendezettek Összefésülő-rendezés(A, p, r): Ha (p < r ) akkor q := [(p + r) / 2] Összefésülő-rendezés vége Összefésülő-rendezés(A, p, q) Összefésülő-rendezés(A, q+1, r) Összefésül(A, p, q, r) Az alkalmazott Összefésülés eljárás leírása: Bemenet: A[p..q] és A[q+1..r] rendezettek Kimenet: A[p..r] rendezett //Az A bemenő, p-től r-ig rendezendő tömb és // kimenő, p pozíciótól r pozícióig rendezett tömb // Első fele rendezése // Második fele rendezése // A rendezett felek összefésülése Összefésülés(A, p, q, r): // Az eljárás hívó algoritmus // visszakapja az összefésült A tömböt n1 := q p + 1 // Az első fél (p-től q-ig) elemeinek száma n2 := r q // A második fél (q+1-től r-ig) elemeinek száma Ciklus i := 1-től n1-ig // A B tömb feltöltése az első fél elemeivel B[i] := A[p + i 1] Ciklus j := 1-től n2-ig // A J tömb feltöltése a második fél elemeivel J[j] := A[q + j] 17
18 B[n1 + 1] := : J[n2 + 1] := // A két fél végére egy minden lehetséges // elemnél nagyobb elemet teszünk, amely // már nem kerül a rendezett tömbre i := 1 : j := 1 // Mindkét félnél az első elemtől indulunk a visszahelyezésnél Ciklus k := p-től r-ig // Egyenként visszatesszük az elemeket A-ba Ha ( B[i] <= J[j] ) akkor // A soron következő kisebb elem A[k] := B[i] : i := i + 1 // visszahelyezése. A megfelelő különben // pozíció növelése abban a A[k] := J[i] : j := j + 1 // tömbben, ahonnan az elemet Összefésül vége Példa az Összefésül eljárás működésére: Bemenet: A: , p = 1, q = 3, r = 6 Összefésül: n1 = 3 n2 = 3 Kezdőértékek beállítása: B: J: A: i = 1, j = 1, k = 1 Első lépés: B: J: B[1] = 2 > J[1] = 1 A: i = 1, j = 2, k = 2 Második lépés: B: J: B[1] = 2 < J[2] = 3 A: i = 2, j = 2, k = 3 Harmadik lépés: //visszahelyeztünk 18
19 B: J: B[2] = 4 > J[2] = 3 A: i = 2, j = 3, k = 4 Negyedik lépés: B: J: B[2] = 4 < J[3] = 6 A: i = 3, j = 3, k = 5 Ötödik lépés: B: J: B[3] = 5 < J[3] = 6 A: i = 4, j = 3, k = 6 Hatodik lépés: B: J: B[4] = < J[3] = 6 A: i = 4, j = 4, k = 7 Vége Példa az Összefésülő-rendezés eljárás működésére: Bemenet: A: , p = 1, r = 6 Összefésülő-rendezés: q = 3 Összefésülő-rendezés(A[ ], 1, 3) Végrehajtás után: A: Összefésülő rendezés(a[ ], 4, 6) Végrehajtás után: A: Összefésül(A[ ], 1, 3, 6) // Előző példán láttuk! Végrehajtás után: A: Vége 19
20 Gyors rendezés: A gyors rendezés egy tömb rendezéséhez először egy választott elemet a helyére teszi úgy, hogy a tömbben minden a választott elemet megelőző elem nála kisebb vagy egyenlő, minden a választott elemet követő elem nála nagyobb vagy egyenlő. Ezután az így keletkezett két résztömböt, a választott elemet megelőző elemek ill. követő elemek tömbjeit kell rendezi, és megvan az eredeti tömb rendezése. Az eredeti tömb felbontásával az oszd meg és uralkodj tervezési módszert alkalmazzuk, azzal pedig, hogy a résztömböket gyors rendezéssel rendezzük, a rekurzió tervezési módszert is alkalmazzuk. Bemenet: A[p..r] Kimenet: A[p..r] rendezett Gyors-rendezés(A, p, r): //Az A bemenő, p-től r-ig rendezendő tömb és // kimenő, p pozíciótól r pozícióig rendezett tömb Ha (p < r ) akkor q := Feloszt(A, p, r) // q a választott, helyre került elem helye Gyors-rendezés(A, p, q-1) // A választott elemnél kisebb vagy // egyenlő elemek rendezése Gyors-rendezés(A, q+1, r) // A választott elemnél nagyobb vagy // egyenlő elemek rendezése Gyors-rendezés vége Az alkalmazott Feloszt eljárás leírása (a választott elem a bemenő tömb utolsó eleme) : Bemenet: A[p..r] Kimenet: q, A[p..q-1], A[q+1..r] // q a választott (utolsó) elem végleges helye // A[p..q-1] a választott elemnél kisebb elemek // A[q+1..r] a választott elemnél nagyobb elemek Feloszt(A, p, r): // Az A bemenő, p és r pozíciók közötti felosztandó i := p -1 // i az utolsó megtalált A[r]-nél kisebb elem pozíciója Ciklus j := p-től r-1-ig Ha ( A[j] < A[r] ) akkor // Ha megtalálunk egy A[r]-nél kisebbet, i := i + 1 // akkor helycserével áthelyezzük a tömb S := A[i] : A[i] := A[j] : A[j] := S // elejére, a már megtalált // A[r]-nél kisebbek mögé S := A[i+1] : A[i+1] := A[r] : A[r] := S // A választott (utolsó) elem // áthelyezése a helyére (a nála // kisebbek mögé) Return i+1 // visszaadja a választott elem végleges pozícióját Feloszt vége 20
21 ALGORITMUSOK ÉS PROBLÉMAOSZTÁLYOK (7. előadás) Algoritmusok hatékonysága Az algoritmusok hatékonyságát főleg két szempont alapján szokták vizsgálni: - felhasznált idő - felhasznált memória A legfontosabb szempont az időigény és ezt használjuk mi rendszerint. Egy algoritmus időigényének a megadásához szükség van a bemenet mértékének a meghatározásához. Ez az általunk eddig látott algoritmusok esetén a tömb elemeinek a száma. Így, ha az A tömb elemeinek a száma n, akkor az időigénye n függvényeként adható meg. Az algoritmusok időhatékonyságának az összehasonlításához szükségünk van a függvények összehasonlítására. Függvények összehasonlítása: 1) f(n) = Θ(g(n)) : g(n) aszimptotikusan éles korlátja f(n)-nek, ha létezik c 1 > 0, c 2 > 0, n 0 > 0, hogy 0 c 1 g(n) f(n) c 2 g(n) minden n n 0 -ra 2) f(n) = O(g(n)) : g(n) aszimptotikusan éles felső korlátja f(n)-nek, ha létezik c 2 > 0, n 0 > 0, hogy 0 f(n) c 2 g(n) minden n n 0 -ra 3) f(n) = Ω(g(n)) : g(n) aszimptotikusan éles alsó korlátja f(n)-nek, ha létezik c 1 > 0, n 0 > 0, hogy 0 c 1 g(n) f(n) minden n n 0 -ra Tétel: f(n) = Θ(g(n)) akkor és csak akkor, ha f(n) = O(g(n)) és f(n) = Ω(g(n)) 4) f(n) = o(g(n)) : g(n) aszimptotikusan nem éles felső korlátja f(n)-nek, f(n) ha lim = 0 ( f(n) 0, g(n) 0 ) n g(n) 5) f(n) = ω(g(n)) : g(n) aszimptotikusan nem éles alsó korlátja f(n)-nek, f(n) ha lim = ( f(n) 0, g(n) 0 ) n g(n) Párhuzam a függvények és a valós számok összehasonlítása kzött: f(n) = O(g(n)) f(n) = Ω(g(n)) f(n) = Θ(g(n)) f(n) = o(g(n)) f(n) = ω(g(n)) a b a b a = b a < b a > b 21
22 Néhány korábban látott algoritmus időigénye: Összegzés: Eldöntés: Általános: Θ(n) Általános: O(n) Kiválasztás: Általános: O(n) Lineáris keresés (első megkeresése): Általános: O(n) Megszámlálás: Általános: Θ(n) Kiválogatás (minden előfordulás megkeresése): Általános: Θ(n) Szélsőértékek: Általános: Θ(n) Logaritmikus keresés: Általános: O(log n) Egyszerű beillesztéses rendezés (beszúrásos rendezés): - legjobb eset: Θ(n) - legrosszabb eset: Θ(n 2 ) Általános: O(n 2 ) Összefésülő rendezés: Általános: Θ(n log n) Gyors rendezés: - legjobb eset: Θ(n log n) - legrosszabb eset: Θ(n 2 ) - az átlagos eset közelít a legjobbhoz Általános: O(n 2 ) A következő példán keresztül szeretnénk rámutatni az időigény vizsgalátának a fontosságára: A számítógép sebessége: 10 9 művelet/sec B számítógép sebessége: 10 7 művelet/sec Beszúró rendezés: c 1 n 2 (2 n 2 ) Összefésülő rendezés: c 2 n log n (50 n log n) Rendezendő tömb mérete: 10 6 elem A tömb rendezésének időigénye: 2.(10 6 ) 2 művelet log 10 6 művelet = 2000 sec 100 sec 10 9 művelet/sec 10 7 művelet/sec Az A számítógép100-szor gyorsabb, mint a B, mégis B 20-szor gyorsabban végez, mint A. Nézzük meg most példaként az Összefésülő rendezés időigényének a kiszámítását: 22
23 Tegyük fel, hogy a rendezendő A tömb mérete n = 2 k és a rendezéséhez szükséges idő T(n). Akkor az A tömb rendezéséhez szükséges idő: Akkor: T(n/2) az első fele rendezéséhez összefésüléssel T(n/2) a második fele rendezéséhez összefésüléssel c n a rendezett felek összefésüléséhez T(n) = 2 T(n/2) + c n = 2 (2 T(n/4) + c n/2) + c n = 4 T(n/4) + 2 c n = 4 (2 T(n/8) + c n/4) + 2 c n = 8 T(n/8) + 3 c n = 2 K T(1) + k c n = n + (log n) c n = n c log n + n = n (c log n + 1) T(n) = Θ(n log n) 23
PROGRAMOZÁSI TÉTELEK
PROGRAMOZÁSI TÉTELEK Összegzés tétele Adott egy N elemű számsorozat: A(N). Számoljuk ki az elemek összegét! S:=0 Ciklus I=1-től N-ig S:=S+A(I) Megszámlálás tétele Adott egy N elemű sorozat és egy - a sorozat
RészletesebbenProgramozási tételek. Dr. Iványi Péter
Programozási tételek Dr. Iványi Péter 1 Programozási tételek A programozási tételek olyan általános algoritmusok, melyekkel programozás során gyakran találkozunk. Az algoritmusok általában számsorozatokkal,
RészletesebbenSpecifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.
Algoritmus Az algoritmus olyan elemi műveletekből kompozíciós szabályok szerint felépített összetett művelet, amelyet megadott feltételt teljesítő bemeneti adatra végrehajtva, a megkívánt kimeneti adatot
RészletesebbenAdatszerkezetek. Nevezetes algoritmusok (Keresések, rendezések)
Adatszerkezetek Nevezetes algoritmusok (Keresések, rendezések) Keresések A probléma általános megfogalmazása: Adott egy N elemű sorozat, keressük meg azt az elemet (határozzuk meg a helyét a sorozatban),
RészletesebbenAdatbázis és szoftverfejlesztés elmélet. Programozási tételek
Adatbázis és szoftverfejlesztés elmélet Témakör 8. 1. Egy sorozathoz egy érték hozzárendelése Az összegzés tétele Összefoglalás Programozási tételek Adott egy számsorozat. Számoljuk és írassuk ki az elemek
RészletesebbenSpecifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.
Algoritmus Az algoritmus olyan elemi műveletekből kompozíciós szabályok szerint felépített összetett művelet, amelyet megadott feltételt teljesítő bemeneti adatra végrehajtva, a megkívánt kimeneti adatot
Részletesebben1. Alapfogalmak Algoritmus Számítási probléma Specifikáció Algoritmusok futási ideje
1. Alapfogalmak 1.1. Algoritmus Az algoritmus olyan elemi műveletekből kompozíciós szabályok szerint felépített összetett művelet, amelyet megadott feltételt teljesítő bemeneti adatra végrehajtva, a megkívánt
RészletesebbenRendezések. A rendezési probléma: Bemenet: Kimenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat
9. Előadás Rendezések A rendezési probléma: Bemenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat Kimenet: a bemenő sorozat olyan (a 1, a 2,,a n ) permutációja, hogy a 1 a 2 a n 2 Rendezések Általánosabban:
RészletesebbenELEMI PROGRAMOZÁSI TÉTELEK
ELEMI PROGRAMOZÁSI TÉTELEK 1. FELADATMEGOLDÁS PROGRAMOZÁSI TÉTELEKKEL 1.1 A programozási tétel fogalma A programozási tételek típusalgoritmusok, amelyek alkalmazásával garantáltan helyes megoldást adhatunk
RészletesebbenEdényrendezés. Futási idő: Tegyük fel, hogy m = n, ekkor: legjobb eset Θ(n), legrosszabb eset Θ(n 2 ), átlagos eset Θ(n).
Edényrendezés Tegyük fel, hogy a rendezendő H = {a 1,...,a n } halmaz elemei a [0,1) intervallumba eső valós számok. Vegyünk m db vödröt, V [0],...,V [m 1] és osszuk szét a rendezendő halmaz elemeit a
RészletesebbenAlgoritmusok Tervezése. 6. Előadás Algoritmusok 101 Dr. Bécsi Tamás
Algoritmusok Tervezése 6. Előadás Algoritmusok 101 Dr. Bécsi Tamás Mi az algoritmus? Lépések sorozata egy feladat elvégzéséhez (legáltalánosabban) Informálisan algoritmusnak nevezünk bármilyen jól definiált
RészletesebbenKészítette: Nagy Tibor István Felhasznált irodalom: Kotsis Domokos: OOP diasor Zsakó L., Szlávi P.: Mikrológia 19.
Készítette: Nagy Tibor István Felhasznált irodalom: Kotsis Domokos: OOP diasor Zsakó L., Szlávi P.: Mikrológia 19. Programkészítés Megrendelői igények begyűjtése Megoldás megtervezése (algoritmuskészítés)
RészletesebbenBánsághi Anna 2014 Bánsághi Anna 1 of 68
IMPERATÍV PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 3. ELŐADÁS - PROGRAMOZÁSI TÉTELEK 2014 Bánsághi Anna 1 of 68 TEMATIKA I. ALAPFOGALMAK, TUDOMÁNYTÖRTÉNET II. IMPERATÍV PROGRAMOZÁS Imperatív
RészletesebbenTartalom Keresés és rendezés. Vektoralgoritmusok. 1. fejezet. Keresés adatvektorban. A programozás alapjai I.
Keresés Rendezés Feladat Keresés Rendezés Feladat Tartalom Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
RészletesebbenProgramozás alapjai (ANSI C)
Programozás alapjai (ANSI C) 1. Előadás vázlat A számítógép és programozása Dr. Baksáné dr. Varga Erika adjunktus Miskolci Egyetem, Informatikai Intézet Általános Informatikai Intézeti Tanszék www.iit.uni-miskolc.hu
RészletesebbenA félév során előkerülő témakörök
A félév során előkerülő témakörök rekurzív algoritmusok rendező algoritmusok alapvető adattípusok, adatszerkezetek, és kapcsolódó algoritmusok dinamikus programozás mohó algoritmusok gráf algoritmusok
RészletesebbenÖsszetett programozási tételek Rendezések Keresések PT egymásra építése. 10. előadás. Programozás-elmélet. Programozás-elmélet 10.
Összetett programozási tételek Sorozathoz sorozatot relő feladatokkal foglalkozunk. A bemenő sorozatot le kell másolni, s közben az elemekre vonatkozó átalakításokat lehet végezni rajta: Input : n N 0,
RészletesebbenProgramozási segédlet
Programozási segédlet Programozási tételek Az alábbiakban leírtam néhány alap algoritmust, amit ismernie kell annak, aki programozásra adja a fejét. A lista korántsem teljes, ám ennyi elég kell legyen
RészletesebbenKeresés és rendezés. A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
Keresés Rendezés Feladat Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán 2016. november 7. Farkas B., Fiala
RészletesebbenVáltozók. Mennyiség, érték (v. objektum) szimbolikus jelölése, jelentése Tulajdonságai (attribútumai):
Javascript Változók Mennyiség, érték (v. objektum) szimbolikus jelölése, jelentése Tulajdonságai (attribútumai): Név Érték Típus Memóriacím A változó értéke (esetleg más attribútuma is) a program futása
RészletesebbenProgramozás I. 1. előadás: Algoritmusok alapjai. Sergyán Szabolcs
Programozás I. 1. előadás: Algoritmusok alapjai Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar Alkalmazott Informatikai Intézet 2015. szeptember 7. Sergyán
RészletesebbenSzámjegyes vagy radix rendezés
Számláló rendezés Amennyiben a rendezendő elemek által felvehető értékek halmazának számossága kicsi, akkor megadható lineáris időigényű algoritmus. A bemenet a rendezendő elemek egy n méretű A tömbben
RészletesebbenAdatbázis rendszerek Gy: Algoritmusok C-ben
Adatbázis rendszerek 1. 1. Gy: Algoritmusok C-ben 53/1 B ITv: MAN 2015.09.08 Alapalgoritmusok Összegzés Megszámlálás Kiválasztás Kiválasztásos rendezés Összefésülés Szétválogatás Gyorsrendezés 53/2 Összegzés
Részletesebben6. gyakorlat Egydimenziós numerikus tömbök kezelése, tömbi algoritmusok
6. gyakorlat Egydimenziós numerikus tömbök kezelése, tömbi algoritmusok 1. feladat: Az EURO árfolyamát egy negyedéven keresztül hetente nyilvántartjuk (HUF / EUR). Írjon C programokat az alábbi kérdések
RészletesebbenSzámláló rendezés. Példa
Alsó korlát rendezési algoritmusokra Minden olyan rendezési algoritmusnak a futását, amely elempárok egymással való összehasonlítása alapján működik leírja egy bináris döntési fa. Az algoritmus által a
RészletesebbenProgramozás I. Sergyán Szabolcs Óbudai Egyetem Neumann János Informatikai Kar szeptember 10.
Programozás I. 1. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2012. szeptember 10. Sergyán (OE NIK) Programozás I. 2012. szeptember 10. 1 /
Részletesebben9. előadás. Programozás-elmélet. Programozási tételek Elemi prog. Sorozatszámítás Eldöntés Kiválasztás Lin. keresés Megszámolás Maximum.
Programozási tételek Programozási feladatok megoldásakor a top-down (strukturált) programtervezés esetén három vezérlési szerkezetet használunk: - szekvencia - elágazás - ciklus Eddig megismertük az alábbi
RészletesebbenProgramozás I. Sergyán Szabolcs Óbudai Egyetem Neumann János Informatikai Kar szeptember 10.
Programozás I. 1. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2012. szeptember 10. Sergyán (OE NIK) Programozás I. 2012. szeptember 10. 1 /
RészletesebbenRendezések. Sergyán Szabolcs Óbudai Egyetem Neumann János Informatikai Kar október 24.
Rendezések 8. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2011. október 24. Sergyán (OE NIK) AAO 08 2011. október 24. 1 / 1 Felhasznált irodalom
RészletesebbenAlgoritmizálás, adatmodellezés tanítása 1. előadás
Algoritmizálás, adatmodellezés 1. előadás Az algoritmus fogalma végrehajtható (van hozzá végre-hajtó) lépésenként hajtható végre a lépések maguk is algoritmusok pontosan definiált, adott végre-hajtási
RészletesebbenEgyszerű programozási tételek
Egyszerű programozási tételek 2. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2011. szeptember 15. Sergyán (OE NIK) AAO 02 2011. szeptember 15.
RészletesebbenVáltozók. Mennyiség, érték (v. objektum) szimbolikus jelölése, jelentése Tulajdonságai (attribútumai):
Python Változók Mennyiség, érték (v. objektum) szimbolikus jelölése, jelentése Tulajdonságai (attribútumai): Név Érték Típus Memóriacím A változó értéke (esetleg más attribútuma is) a program futása alatt
RészletesebbenKiegészítő részelőadás 1. Az algoritmusok hatékonyságának mérése
Kiegészítő részelőadás 1. Az algoritmusok hatékonyságának mérése Dr. Kallós Gábor 2014 2015 1 Az Ordó jelölés Azt mondjuk, hogy az f(n) függvény eleme az Ordó(g(n)) halmaznak, ha van olyan c konstans (c
RészletesebbenFüggvények növekedési korlátainak jellemzése
17 Függvények növekedési korlátainak jellemzése A jellemzés jól bevált eszközei az Ω, O, Θ, o és ω jelölések. Mivel az igények általában nemnegatívak, ezért az alábbi meghatározásokban mindenütt feltesszük,
RészletesebbenAlgoritmuselmélet 2. előadás
Algoritmuselmélet 2. előadás Katona Gyula Y. Budapesti Műszaki és Gazdaságtudományi Egyetem Számítástudományi Tsz. I. B. 137/b kiskat@cs.bme.hu 2002 Február 12. ALGORITMUSELMÉLET 2. ELŐADÁS 1 Buborék-rendezés
RészletesebbenProgramozás I. Egyszerű programozási tételek. Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu
Programozás I. 3. előadás Egyszerű programozási tételek Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar Alkalmazott Informatikai Intézet 2015. szeptember
RészletesebbenBevezetés a programozásba I 3. gyakorlat. PLanG: Programozási tételek. Programozási tételek Algoritmusok
Pázmány Péter Katolikus Egyetem Információs Technológiai Kar Bevezetés a programozásba I 3. gyakorlat PLanG: 2011.09.27. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Algoritmusok
RészletesebbenNagyságrendek. Kiegészítő anyag az Algoritmuselmélet tárgyhoz. Friedl Katalin BME SZIT február 1.
Nagyságrendek Kiegészítő anyag az Algoritmuselmélet tárgyhoz (a Rónyai Ivanyos Szabó: Algoritmusok könyv mellé) Friedl Katalin BME SZIT friedl@cs.bme.hu 018. február 1. Az O, Ω, Θ jelölések Az algoritmusok
RészletesebbenAlgoritmizálás, adatmodellezés tanítása 7. előadás
Algoritmizálás, adatmodellezés tanítása 7. előadás Oszd meg és uralkodj! Több részfeladatra bontás, amelyek hasonlóan oldhatók meg, lépései: a triviális eset (amikor nincs rekurzív hívás) felosztás (megadjuk
RészletesebbenProgramozási módszertan. Függvények rekurzív megadása "Oszd meg és uralkodj" elv, helyettesítő módszer, rekurziós fa módszer, mester módszer
PM-03 p. 1/13 Programozási módszertan Függvények rekurzív megadása "Oszd meg és uralkodj" elv, helyettesítő módszer, rekurziós fa módszer, mester módszer Werner Ágnes Villamosmérnöki és Információs Rendszerek
RészletesebbenALGORITMIKUS SZERKEZETEK ELÁGAZÁSOK, CIKLUSOK, FÜGGVÉNYEK
ALGORITMIKUS SZERKEZETEK ELÁGAZÁSOK, CIKLUSOK, FÜGGVÉNYEK 1. ELÁGAZÁSOK ÉS CIKLUSOK SZERVEZÉSE Az adatszerkezetek mellett a programok másik alapvető fontosságú építőkövei az ún. algoritmikus szerkezetek.
Részletesebben1. ábra. Számláló rendezés
1:2 2:3 1:3 1,2,3 1:3 1,3,2 3,1,2 2,1,3 2:3 2,3,1 3,2,1 1. ábra. Alsó korlát rendezési algoritmusokra Minden olyan rendezési algoritmusnak a futását, amely elempárok egymással
RészletesebbenHaladó rendezések. PPT 2007/2008 tavasz.
Haladó rendezések szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Témakörök Alapvető összehasonlító rendezések Shell rendezés Kupacrendezés Leszámláló rendezés Radix rendezés Edényrendezés
RészletesebbenAlgoritmizálás. Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar
Algoritmizálás Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar horvath@inf.u-szeged.hu 0.1. Az algoritmikus tudás szintjei Ismeri (a megoldó algoritmust) Érti Le tudja pontosan
RészletesebbenHatékonyság 1. előadás
Hatékonyság 1. előadás Mi a hatékonyság Bevezetés A hatékonyság helye a programkészítés folyamatában: csak HELYES programra Erőforrásigény: a felhasználó és a fejlesztő szempontjából A hatékonyság mérése
RészletesebbenProgramozás I. Egyszerű programozási tételek. Sergyán Szabolcs
Programozás I. 3. előadás Egyszerű programozási tételek Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar Alkalmazott Informatikai Intézet 2015. szeptember
RészletesebbenDr. Schuster György február / 32
Algoritmusok és magvalósítások Dr. Schuster György OE-KVK-MAI schuster.gyorgy@kvk.uni-obuda.hu 2015. február 10. 2015. február 10. 1 / 32 Algoritmus Alapfogalmak Algoritmus Definíció Algoritmuson olyan
RészletesebbenProgramozási alapismeretek 1. előadás
Programozási alapismeretek 1. előadás Tartalom A problémamegoldás lépései programkészítés folyamata A specifikáció Az algoritmus Algoritmikus nyelvek struktogram A kódolás a fejlesztői környezet 2/33 A
RészletesebbenAlkalmazott modul: Programozás. Programozási tételek, rendezések. Programozási tételek Algoritmusok és programozási tételek
Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás, rendezések 2015 Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Algoritmusok és programozási tételek
RészletesebbenBevezetés a programozásba I.
Bevezetés a programozásba I. 3. gyakorlat Tömbök, programozási tételek Surányi Márton PPKE-ITK 2010.09.21. ZH! PlanG-ból papír alapú zárthelyit írunk el reláthatólag október 5-én! Tömbök Tömbök Eddig egy-egy
RészletesebbenAlgoritmus fogalma. Mi az algoritmus? HF: Al Khwarizmi. Egy adott probléma megoldásának leírása elemi lépések sorozatával
Algoritmusok Algoritmus fogalma Mi az algoritmus? Egy adott probléma megoldásának leírása elemi lépések sorozatával HF: Al Khwarizmi Követelmények Véges: nem állhat végtelen sok lépésből Teljes: teljes
RészletesebbenAlgoritmizálás, adatmodellezés 1. előadás
Algoritmizálás, adatmodellezés 1. előadás Algoritmus-leíró eszközök Folyamatábra Irányított gráf, amely csomópontokból és őket összekötő élekből áll, egyetlen induló és befejező éle van, az induló élből
RészletesebbenFelvételi tematika INFORMATIKA
Felvételi tematika INFORMATIKA 2016 FEJEZETEK 1. Természetes számok feldolgozása számjegyenként. 2. Számsorozatok feldolgozása elemenként. Egydimenziós tömbök. 3. Mátrixok feldolgozása elemenként/soronként/oszloponként.
RészletesebbenÖsszetett programozási tételek
Összetett programozási tételek 3. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2011. szeptember 19. Sergyán (OE NIK) AAO 03 2011. szeptember
RészletesebbenInformatikai tehetséggondozás:
Ég és Föld vonzásában a természet titkai Informatikai tehetséggondozás: Rendezések TÁMOP-4.2.3.-12/1/KONV-2012-0018 Az alapfeladat egy N elemű sorozat nagyság szerinti sorba rendezése. A sorozat elemei
RészletesebbenProgramozás alapjai 9. előadás. Wagner György Általános Informatikai Tanszék
9. előadás Wagner György Általános Informatikai Tanszék Leszámoló rendezés Elve: a rendezett listában a j-ik kulcs pontosan j-1 kulcsnál lesz nagyobb. (Ezért ha egy kulcsról tudjuk, hogy 27 másiknál nagyobb,
RészletesebbenKözismereti informatika I. 4. előadás
Közismereti informatika I. 4. előadás Rendezések Bemenet: N: Egész, X: Tömb(1..N: Egész) Kimenet: X: Tömb(1..N: Egész) Előfeltétel: Utófeltétel: Rendezett(X) és X=permutáció(X ) Az eredmény a bemenet egy
RészletesebbenRekurzió. (Horváth Gyula és Szlávi Péter előadásai felhasználásával)
Rekurzió (Horváth Gyula és Szlávi Péter előadásai felhasználásával) Rekurzió és iteráció Balrekurzió Ha az eljárás első utasításaként szerepel a rekurzív hívás, akkor a rekurzió lényegében az első nem
RészletesebbenKupacrendezés. Az s sorban lévő elemeket rendezzük a k kupac segítségével! k.empty. not s.isempty. e:=s.out k.insert(e) not k.
10. Előadás Beszúró rendezés Használjuk a kupacokat rendezésre! Szúrd be az elemeket egy kupacba! Amíg a sor ki nem ürül, vedd ki a kupacból a maximális elemet, és tedd az eredmény (rendezett) sorba! 2
RészletesebbenAlkalmazott modul: Programozás. Programozási tételek, rendezések Giachetta Roberto
Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás Programozási tételek, rendezések 2015 Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Algoritmusok
RészletesebbenA 2011/2012 tanévi Országos Középiskolai Tanulmányi Verseny első forduló feladatainak megoldása. INFORMATIKÁBÓL II. (programozás) kategóriában
Oktatási Hivatal A 2011/2012 tanévi Országos Középiskolai Tanulmányi Verseny első forduló feladatainak megoldása INFORMATIKÁBÓL II. (programozás) kategóriában Kérjük a tisztelt tanár kollégákat, hogy a
RészletesebbenAlgoritmusokfelülnézetből. 1. ELŐADÁS Sapientia-EMTE
Algoritmusokfelülnézetből 1. ELŐADÁS Sapientia-EMTE 2015-16 Algoritmus Az algoritmus kifejezés a bagdadi arab tudós, al-hvárizmi(780-845) nevének eltorzított, rosszul latinra fordított változatából ered.
Részletesebben15. tétel. Adatszerkezetek és algoritmusok vizsga Frissült: 2013. január 30.
15. tétel Adatszerkezetek és algoritmusok vizsga Frissült: 2013. január 30. Edényrendezés Tegyük fel, hogy tudjuk, hogy a bemenő elemek (A[1..n] elemei) egy m elemű U halmazból kerülnek ki, pl. " A[i]-re
RészletesebbenWebprogramozás szakkör
Webprogramozás szakkör Előadás 5 (2012.04.09) Programozás alapok Eddig amit láttunk: Programozás lépései o Feladat leírása (specifikáció) o Algoritmizálás, tervezés (folyamatábra, pszeudokód) o Programozás
RészletesebbenEgyszerű programozási tételek
Egyszerű programozási tételek Sorozatszámítás tétele Például az X tömbben kövek súlyát tároljuk. Ha ki kellene számolni az összsúlyt, akkor az S = f(s, X(i)) helyére S = S + X(i) kell írni. Az f0 tartalmazza
RészletesebbenElőfeltétel: legalább elégséges jegy Diszkrét matematika II. (GEMAK122B) tárgyból
ÜTEMTERV Programozás-elmélet c. tárgyhoz (GEMAK233B, GEMAK233-B) BSc gazdaságinformatikus, programtervező informatikus alapszakok számára Óraszám: heti 2+0, (aláírás+kollokvium, 3 kredit) 2019/20-es tanév
RészletesebbenProgramozási alapismeretek 11. előadás
Programozási alapismeretek 11. előadás Tartalom Rendezési feladat specifikáció Egyszerű cserés rendezés Minimum-kiválasztásos rendezés Buborékos rendezés Javított buborékos rendezés Beillesztéses rendezés
RészletesebbenProgramozás I. Metódusok C#-ban Egyszerű programozási tételek. Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu
Programozás I. 3. előadás Tömbök a C#-ban Metódusok C#-ban Egyszerű programozási tételek Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar Szoftvertechnológia
RészletesebbenBevezetés az informatikába
Bevezetés az informatikába 6. előadás Dr. Istenes Zoltán Eötvös Loránd Tudományegyetem Informatikai Kar Programozáselmélet és Szoftvertechnológiai Tanszék Matematikus BSc - I. félév / 2008 / Budapest Dr.
RészletesebbenAlgoritmusok, adatszerkezetek, objektumok
Algoritmusok, adatszerkezetek, objektumok 1. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2011. szeptember 14. Sergyán (OE NIK) AAO 01 2011.
RészletesebbenRendezések. Összehasonlító rendezések
Rendezések Összehasonlító rendezések Remdezés - Alapfeladat: Egy A nevű N elemű sorozat elemeinek nagyság szerinti sorrendbe rendezése - Feltételezzük: o A sorozat elemei olyanok, amelyekre a >, relációk
Részletesebben15. A VERSENYRENDEZÉS
15. A VERSENYRENDEZÉS A versenyrendezés (tournament sort) a maximum-kiválasztó rendezések közé tartozik, ugyanis az elemek közül újra és újra kiválasztja (eltávolítja és kiírja) a legnagyobbat. Az eljárás
RészletesebbenTartalom. Programozási alapismeretek. 11. előadás
Tartalom Programozási alapismeretek 11. előadás Rendezési feladat specifikáció Egyszerű cserés Minimum-kiválasztásos Buborékos Javított buborékos Beillesztéses Javított beillesztéses Szétosztó Számlálva
RészletesebbenAZ ALGORITMUS. az eredményt szolgáltatja
ALGORITMUSOK AZ ALGORITMUS Az algoritmus problémamegoldásra szolgáló elemi lépések olyan sorozata, amely a következő jellemzőkkel bír: Véges: véges számú lépés után befejeződik, és eredményt szolgáltat
RészletesebbenAlgoritmusok és adatszerkezetek gyakorlat 03 Oszd meg és uralkodj. Nagy
Algoritmusok és adatszerkezetek gyakorlat 03 Oszd meg és uralkodj Divide & Conquer (,,Oszd meg és uralkodj ) paradigma Divide: Osszuk fel az adott problémát kisebb problémákra. Conquer: Oldjuk meg a kisebb
RészletesebbenPásztor Attila. Algoritmizálás és programozás tankönyv az emeltszintű érettségihez
Pásztor Attila Algoritmizálás és programozás tankönyv az emeltszintű érettségihez 9. ÖSSZETETT FELADATOK...111 9.1. ELEMI ALGORITMUSOK ÖSSZEÉPÍTÉSE...111 9.2. ÖSSZEFOGLALÁS...118 9.3. GYAKORLÓ FELADATOK...118
RészletesebbenA 2015/2016 tanévi Országos Középiskolai Tanulmányi Verseny első forduló javítási-értékelési útmutató. INFORMATIKA II. (programozás) kategória
Oktatási Hivatal 2015/2016 tanévi Országos Középiskolai Tanulmányi Verseny első forduló javítási-értékelési útmutató INFORMTIK II. (programozás) kategória Kérjük a tisztelt tanár kollégákat, hogy a dolgozatokat
RészletesebbenRekurzív algoritmusok
Rekurzív algoritmusok 11. előadás Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar 2011. november 14. Sergyán (OE NIK) AAO 11 2011. november 14. 1 / 32 Rekurzív
RészletesebbenProgramtervezés. Dr. Iványi Péter
Programtervezés Dr. Iványi Péter 1 A programozás lépései 2 Feladat meghatározás Feladat kiírás Mik az input adatok A megoldáshoz szükséges idő és költség Gyorsan, jót, olcsón 3 Feladat megfogalmazása Egyértelmű
Részletesebben1. előadás. számításokban. Adatszerkezetek és algoritmusok előadás február 12. Kósa Márk, Pánovics János, Szathmáry László és Halász Gábor
1. előadás mint Adatszerkezetek és algoritmusok előadás 2019. február 12. fogalma megadása építőelemei mint helyessége elemzés,, és Debreceni Egyetem Informatikai Kar 1.1 Általános tudnivalók Ajánlott
RészletesebbenAdatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája
Adatszerkezetek Összetett adattípus Meghatározói: A felvehető értékek halmaza Az értékhalmaz struktúrája Az ábrázolás módja Műveletei Adatszerkezet fogalma Direkt szorzat Minden eleme a T i halmazokból
RészletesebbenA 2017/2018 tanévi Országos Középiskolai Tanulmányi Verseny első fordulójának feladatai. INFORMATIKA II. (programozás) kategória
Oktatási Hivatal A 2017/2018 tanévi Országos Középiskolai Tanulmányi Verseny első fordulójának feladatai 1. feladat: Repülők (20 pont) INFORMATIKA II. (programozás) kategória Ismerünk városok közötti repülőjáratokat.
RészletesebbenProgramozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás V 1.0 OE-NIK,
Programozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás OE-NIK, 2013 1 Hallgatói Tájékoztató A jelen bemutatóban található adatok, tudnivalók és információk
RészletesebbenRENDEZÉSEK, TOVÁBBI PROGRAMOZÁSI TÉTELEK
RENDEZÉSEK, TOVÁBBI PROGRAMOZÁSI TÉTELEK 1. EGY SOROZATHOZ EGY SOROZATOT RENDELŐ TÉTELEK 1.1 Rendezések 1.1.1 Kitűzés Adott egy sorozat, és a sorozat elemein értelmezett egy < reláció. Rendezzük a sorozat
Részletesebben19. AZ ÖSSZEHASONLÍTÁSOS RENDEZÉSEK MŰVELETIGÉNYÉNEK ALSÓ KORLÁTJAI
19. AZ ÖSSZEHASONLÍTÁSOS RENDEZÉSEK MŰVELETIGÉNYÉNEK ALSÓ KORLÁTJAI Ebben a fejezetben aszimptotikus (nagyságrendi) alsó korlátot adunk az összehasonlításokat használó rendező eljárások lépésszámára. Pontosabban,
RészletesebbenAz informatika kulcsfogalmai
Az informatika kulcsfogalmai Kulcsfogalmak Melyek azok a fogalmak, amelyek nagyon sok más fogalommal kapcsolatba hozhatók? Melyek azok a fogalmak, amelyek más-más környezetben újra és újra megjelennek?
RészletesebbenAlgoritmusok és adatszerkezetek gyakorlat 07
Algoritmusok és adatszerkezetek gyakorlat 0 Keresőfák Fák Fa: összefüggő, körmentes gráf, melyre igaz, hogy: - (Általában) egy gyökér csúcsa van, melynek 0 vagy több részfája van - Pontosan egy út vezet
RészletesebbenBevezetés a programozásba I.
Elágazás Bevezetés a programozásba I. 2. gyakorlat, tömbök Surányi Márton PPKE-ITK 2010.09.14. Elágazás Elágazás Eddigi programjaink egyszer ek voltak, egy beolvasás (BE: a), esetleg valami m velet (a
RészletesebbenGyakorló feladatok ZH-ra
Algoritmuselmélet Schlotter Ildi 2011. április 6. ildi@cs.bme.hu Gyakorló feladatok ZH-ra Nagyságrendek 1. Egy algoritmusról tudjuk, hogy a lépésszáma O(n 2 ). Lehetséges-e, hogy (a) minden páros n-re
RészletesebbenInformációk. Ismétlés II. Ismétlés. Ismétlés III. A PROGRAMOZÁS ALAPJAI 2. Készítette: Vénné Meskó Katalin. Algoritmus. Algoritmus ábrázolása
1 Információk 2 A PROGRAMOZÁS ALAPJAI 2. Készítette: Vénné Meskó Katalin Elérhetőség mesko.katalin@tfk.kefo.hu Fogadóóra: szerda 9:50-10:35 Számonkérés időpontok Április 25. 9 00 Május 17. 9 00 Június
RészletesebbenAlgoritmusok vektorokkal keresések 1
Algoritmusok vektorokkal keresések 1 function TELJES_KERES1(A, érték) - - teljes keresés while ciklussal 1. i 1 2. while i méret(a) és A[i] érték do 3. i i + 1 4. end while 5. if i > méret(a) then 6. KIVÉTEL
Részletesebben7. előadás. Gyorsrendezés, rendezés lineáris lépésszámmal. Adatszerkezetek és algoritmusok előadás március 6.
7. előadás, rendezés lineáris lépésszámmal Adatszerkezetek és algoritmusok előadás 2018. március 6.,, és Debreceni Egyetem Informatikai Kar 7.1 Általános tudnivalók Ajánlott irodalom: Thomas H. Cormen,
RészletesebbenAlgoritmizálás, adatmodellezés tanítása 2. előadás
Algoritmizálás, adatmodellezés tanítása 2. előadás Programozási tételek Mi az, hogy programozási tétel? Típusfeladat általános megoldása. Sorozat érték Sorozat sorozat Sorozat sorozatok Sorozatok sorozat
RészletesebbenMaximum kiválasztás tömbben
ELEMI ALKALMAZÁSOK FEJLESZTÉSE I. Maximum kiválasztás tömbben Készítette: Szabóné Nacsa Rozália Gregorics Tibor tömb létrehozási módozatok maximum kiválasztás kódolása for ciklus adatellenőrzés do-while
RészletesebbenDinamikus programozás - Szerelőszalag ütemezése
Dinamikus programozás - Szerelőszalag ütemezése A dinamikus programozás minden egyes részfeladatot és annak minden részfeladatát pontosan egyszer oldja meg, az eredményt egy táblázatban tárolja, és ezáltal
RészletesebbenProgramozási alapismeretek. 1. előadás. A problémamegoldás lépései. A programkészítés folyamata. Az algoritmus fogalma. Nyelvi szintek.
Tartalom 1. előadás programozás során használt nyelvek A specifikáció Algoritmikus nyelvek A problémamegoldás lépései 3/41 (miből?, mit?) specifikáció (mivel?, hogyan?) adat- + algoritmus-leírás 3. (a
RészletesebbenA rész (30 pont) A.1. Vajon mit csinál? (5 pont) A generál(n) algoritmus egy n természetes számot dolgoz fel (0 < n < 100).
BABEŞ-BOLYAI TUDOMÁNYEGYETEM MATEMATIKA-INFORMATIKA KAR Felvételi verseny - szeptember Informatika írásbeli A versenyzők figyelmébe: 1. Minden tömböt 1-től kezdődően indexelünk. 2. A rácstesztekre (A rész)
RészletesebbenA programozás alapjai előadás. Amiről szólesz: A tárgy címe: A programozás alapjai
A programozás alapjai 1 1. előadás Híradástechnikai Tanszék Amiről szólesz: A tárgy címe: A programozás alapjai A számítógép részegységei, alacsony- és magasszintű programnyelvek, az imperatív programozási
RészletesebbenProgramozási tételek. Jegyzet. Összeállította: Faludi Anita 2012.
Programozási tételek Jegyzet Összeállította: Faludi Anita 2012. Tartalomjegyzék Bevezetés... 3 Programozási tételek... 4 I. Elemi programozási tételek... 4 1. Sorozatszámítás (összegzés)... 4 2. Eldöntés...
RészletesebbenTérinformatikai algoritmusok Elemi algoritmusok
Cserép Máté Analóg programozásnak nevezzük azt, amikor egy feladat megoldásához egy már ismert és megoldott feladat megoldását használjuk fel. Általában nem pontosan ugyanazt a feladatot oldottuk meg korábban,
Részletesebben