Programozási paradigmák és technikák - arek.uni-obuda.huhajnale/Cikkek_PDF/ppt.pdf · UML Rendszertervezés Programozási paradigmák és technikák Hogyan kell dokumentálni

Programozási paradigmák és

technikák

Előadás: Hajnal Éva

Gyakorlat: Burián Ágnes

Programozási paradigmák és technikák Dr. Hajnal Éva 2

Paradigma

• Egy tudományterület általánosan elfogadott nézetei (fogalmai, szakkifejezései) egy adott korszakban, időpontban.

• Egy szó összes ragozott alakjának rendszerezett leírása. (például igeragozási tábla)(lásd: Magyar Értelmező Kéziszótár)

• Egy mondat szakasz helyettesítésére alkalmas kifejezések osztálya, gyűjteménye (nem azonos értelmű, jelentésű (szinonímák), hanem azonos módon használható szavak).

• A paradigma a gondolkodásoknak, vélekedéseknek, értékeknek és módszereknek egy adott társadalom vagy szűkebben egy tudományos közösség minden tagja által elfogadott összegzését jelenti.


Adatbázisok

Informatikus tudása

Alapismeretek

Hardver ismeretek

Szoftver ismeretek

Gazdasági ismeretek

Hogyan kell programot írni

Hogyan kell tervezni

Programnyelvek

C#, Java, Assembly…

Adatszerkezetek Algoritmusok

UML

Rendszertervezés

Programozási paradigmák

és technikák

Hogyan kell dokumentálni


Tematika 1

2012.02.13- Rekurzió: Fibonacci (rekurzív és nem rekurzív), QuickSort (rekurzív és nem

rekurzív) 2

2012.02.20 OO programozás C# nyelven

Osztályok, objektumok. Konstruktor, destruktor, this.

Beágyazott osztályok. Egyszerű típuskonverziók

Mezők, metódusok. Átdefiniálás (overloading)

Névterek. Láthatóság. Felbontott típusok (partial types) 3

2012.02.27 Öröklés

Többszörös öröklés lehetőségei a különböző nyelvekben. Konstruktorok az

öröklésben. Hívási, végrehajtási sorrend. Paraméterezett őskonstruktor hívása.

Különböző konstansok és inicializálásuk

Metódusok elrejtése. Az ősosztály azonos nevű metódusának hívása. Öröklés és

értékadás. Explicit típuskonverzió. Az Object.GetType(). Az is, as operátorok.. 4

2012.03.05 Polimorfizmus

Nem virtuális metódusok, elrejtés. Virtuális metódusok, felüldefiniálás. Futásidejű

kötés, polimorfizmus. Virtuális Metódus Tábla. Konstruktorok, destruktorok

feladata. Virtual, override, new, new virtual. Virtuális metódus elrejtése. A

virtualitás újrakezdése. Statikus és virtuális metódusok. Lezárt metódus, lezárt

osztály

Delegált függvények 5

2012.03.12 Absztrakt osztály és interfész. Absztrakt metódus. Absztrakt osztály

Generikus osztályok Interfész. Metódusok implementációja. Láthatóság interfész

esetén. Explicit implementált interfész. Absztrakt osztály vagy interfész . 6

2012.03.19 Iterátorok. Kivételkezelés. Kivétel dobása, elkapása. Kezeletlen kivétel. Kivételek

egymásba ágyazása. Az osztálykönyvtár és a kivételkezelés. Operátor

overloading. Operátor. Átdefiniálható operátorok. Precedencia. Implicit, explicit

konverzió.


7

2012.03.26 Dinamikus memóriakezelés. Verem/sor. Statikus megvalósítás, dinamikus

megvalósítás.

8

2012.04.02 ZH Gráfok, Gráfalgoritmusok

9 Szünet

10

2012.04.16 Láncolt listák létrehozása Láncolt listák bejárása. Keresés, beszúrás,

törlés, hulladékgyűjtés. Fejelt listák. Kétirányú listák

11

2012.04.23 Fa adatszerkezetek. Fát reprezentáló adatstruktúrák. Adatmodell,

eljárásmodell. Adatszerkezetek rendszerezése. Absztrakt társzerkezetek.

Vektor, lista. Bináris fák. Megvalósításuk a memóriában. Bináris fák

bejárása, keresés. Beszúrás, törlés. BST fák, AVL fák. Általánosított fák,

piros-fekete fa, B-fa

12

2012.04.30 Rendezések.

A rendező algoritmusok bonyolultsága. Radix rendezés.

Kupacrendezés (HeapSort). Kupacrendezés bonyolultsága. Útvonalak

hosszúsága, a Huffman algoritmus.

13

2012.05.07 A tábla, mint adatszerkezet. Hasítás.

Hasító függvények. Az összeütközések feloldása.

Hasítás és keresőfák. Hasítás alkalmazásai


Követelmények • Az aláírás megszerzésének feltétele: A két gépes ZH, és az elméleti

ZH megírása, a házi feladat beadása. A ZH-k és házifeladatból megszerezhető pontok 50%-nak teljesítése, vagyis a

megszerezhető 120 pontból minimum 60 pontot kell elérni.

• A vizsga jegy: A gyakorlatokon a 2., 3., 4., 5., 8., 10., 11., 12. héten egy-egy 5 pontos, a 6., 13. héten egy-egy 20 pontos gépes ZH megírása, a 13. héten 20 pontos önálló feladat beadása és ebből beszámoló. Az előadás anyagából a 8. héten egy 20 pontos elméleti ZH lesz.

Összesen elérhető 120 pont. A vizsgán további 120 pont érhető el. A hozott pontszám a vizsga pontszámához hozzáadódik.

Osztályozás:

193-240 jeles

169-192 jó

145-168 közepes

121-144 elégséges


Teszt (igaz-hamis) 1. Szintaktika a szabályok összesége, amely megszabja a forráskód

felépítését.

2. A C# programnyelv nem különbözteti meg a kis- és a nagy betűket:

Consol.WriteLine ugyanaz mint consol.writeline

3. Az if egy kulcsszó, azaz a forráskódban a saját meghatározott

jelentésén kívül nem lehet másra használni.

4. //Ezt a programsort a C# fordítója nem fordítja le.

5. A C# erősen típusos nyelv, ami azt jelenti, hogy minden egyes

változó típusának már fordítási időben ismertnek kell lennie.

6. Az int és a System.Int16 ugyanazt jelenti, egymással

helyettesíthetők.

7. Egy változó abban a blokkban használható, amelyben definiálva

lett.

8. if(a<n && a%2==0) és if(a<n & a%2==0) teljesen ugyanúgy

hajtódik végre.


Teszt (igaz-hamis) 9. Az alábbi értékadás helyes: 10=++a;

10. Teljesen mindegy, hogy a programban mit írok: a++

vagy ++a, ugyanaz történik

11. int x=10; int y=3; int z=x/y; esetén z értéke 3,333…

12. for (int i=0;i<10;i++){k } k utasítás 10-szer lesz

végrehajtva

Programozási paradigmák

• Oszd meg és uralkodj paradigma

– A nagyobb feladat kisebb egymástól független

részfeladatokra bontása

• Dinamikus programozás paradigma

– Ha a feladat nem bontható fel egymástól

független részfeladatokra

– Az egymástól függő részfeladatok

behatárolása, és a részeredmények tárolása



Függvények A függvény utasítások logikailag összefüggő

csoportja, mely önálló névvel és

visszatérési értékkel rendelkezik.

• Hívása printf(„Hello”); Console.Clear();

Consol.WriteLine(„Hello”);

a=sin(x); Consol.WriteLine(sin(x));

• Szerkezete

Visszatérésiértéktípusa FüggvényNeve(paraméterlista)

{

Utasítások;

Return visszatérési érték;

}


Függvény végrehajtása,

és definíciója

static void terulet()

{

Console.WriteLine("Kérem a négyzet oldalát:");

int t = Int32.Parse(Console.ReadLine());

Console.WriteLine( t * t);

}

static void Main(string[] args)

{

terulet();

Console.ReadLine();

}

1. Program

belépési pontja

(Entry point)


Eljárás végrehajtása I.


Eljárás végrehajtása II.


Változók hatásköre

• A változók hatásköre az őket tartalmazó

blokkra terjed ki.

• Ha több eljárás közt „osztunk meg „ egy

változót: Static módosítóval rendelkező

eljáráshoz static módosítójú változót kell

definiálni.


Függvény visszaadott értéke

• void

• int

• double

• Összetett adat

– pl. tömb

függvény

Eljárás


Paraméter átadás

static void Kiiras(int a,int b)

{

Console.WriteLine("A {0}+{1}={2}",a,b,a+b);

}


Függvény paraméterei

• Bemenő-Kimenő paraméterek

• Érték szerinti – cím szerinti paraméter átadás

• Paraméterek, helyi változók tárolása


Átadott paraméter egyeztetése


Érték szerinti paraméter átadás


Cím szerinti paraméter átadás

• Átmenő, kimenő paraméter

• Ref, out


Paraméterátadás

• Szignatúra: függvény neve, és

paraméterlistája az abban levő típusokkal

• Írhatunk azonos nevű függvényeket, ha a

szignatúrájuk különböző. Polimorfizmus.

• Kérdés: Lehet-e egy programon belül

definiálni az alábbi függvényeket?

void mozgat(int x, int y);

void mozgat (int x);

void mozgat (int y);

File kezelés

• C#-an többszintű file kezelés létezik

egymás mellett.

– Form alapú filekezelés (OpenFileDialog,

SaveFileDialog)

–File-ok streamek, adatfolyamok – Bináris file kezelés byte-ról byte-ra olvasható,

írható a file

– XML fileok használata, szerializáció

– Konfigurációs file-ok használata


File kezelés

• Magas szintű file kezelés: a fileokat

adatfolyamnak stream-nek tekintjük

akárcsak a Console I/O-t. A stream a

definíciója és a megnyitása után írható,

olvasható. Használat végén be kell

zárni!!!!

• System.IO névtér használata


File stream példa //névtér megadása

Using System.IO;

//FileStream megadása

FileStream fs=new FileStream(„c:\\eva\\text.txt”,

FileMode.Open);

//Stream megadása olvasáshoz, íráshoz StreamWriter

StreamReader rs=new StreamReader(fs);

String s=rs.ReadLine();

While(s!=null)

{ Console.WriteLine(s);

s=rs.ReadLine();

}

rs.Close();

fs.Close();


FileMode értékei

Create LÉTREHOZ (ha van törli)

CreateNew LÉTREHOZ (ha van akkor hiba)

Open Megnyit (ha nincs akkor hiba)

OpenOrCreate Megnyit, ha nincs létrehozza

Append Megnyit hozzáfűzésre

Truncate Megnyit és töröl


FileAccess értékei

• Read

• Write

• ReadWrite


A file vizsgálata

• Létezik-e File.Exists()

• Elértük-e a végét : a beolvasott sor értéke

null


File-ba írás

Using System.IO;

StreamWriter sw=new

StreamWriter(@”c:\teszt.txt”,FileMode.Open,

FileAccess.Write, FileShare.None);

For (int i=0; i<10;++i)

{

sw.Write(i.ToString());

sw.Write(„\n”);

}

Sw.Close();



Teszt

1. A szamol() egy eljárás

2. Az „a” és „b” formális paraméterek

3. Console.WriteLine(„{0}”,szamol(5,6)); programsor helyes

4. Az int c=szamol(2,5) eredménye 2.5

5. Cím szerinti paraméterátadás van a 4. feladatban

6. A Main függvénynek is lehet paramétere

7. Lehet készíteni static int szamol( int a, int b) fejlécű függvényt is ugyanebben a programban

8. A függvény szignatúrája a neve és paramétereinek típusa

Static int szamol(int a, double b)

{return b/a;}


Rekurzió fogalma

• A rekurzió a ciklusnál bonyolultabb

programszerkezet, de ugyanarra való –

egy tevékenység ismételt végrehajtására.

• Rekurzió: Egy függvény saját magát hívja

meg (közvetve, vagy közvetlenül).


Definíció (Specifikáció)

1. feladat: Számítsuk ki N faktoriálist

• Iteratív definíció • Rekurzív definíció

01

0)!1(*!

nha

nhannn1

0!

1 0

n

i

i nn

n


Rekurzió fogalma

1. feladat: Számítsuk ki N faktoriálist

static int faktor(int n)

{

if (n == 0) return 1;

int f=1;

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

{

f = f * i;

}

return f;

}

static int frek(int k)

{

if (k > 0) return k*frek(k-1);

return 1;

}


Kérdések

1. Hogy kerül ugyanazzal a kóddal megvalósított

eljáráshoz mindig más bemenő érték? –

Bemenő érték problémája

2. Hogy kerül a hívó eljárásban a függvényérték

„felszínre”? – Értékvisszaadás problémája

3. Lokális a k változó. Melyik a sok közül? – A

lokális változók problémája


Rekurzív algoritmus készítése • Közvetlen rekurzió: Ha az A algoritmus egyik lépése az

A algoritmus végrehajtását írja elő.

• Közvetett rekurzió: Ha az A algoritmus egyik lépése a B

algoritmus végrehajtása, a B algoritmus előírja az A

algoritmus végrehajtását.

• Rekurzív algoritmusok végességének

kritériumai – Az algoritmusnak tartalmaznia kell egy alapesetet,

amely közvetlenül megvalósítható

– Minden hivatkozásnál közelebb kell kerülni ehhez az

alapesethez


Rekurzió alkalmazása a

feladatmegoldásban • Rekurzív specifikáció

• Rekurzív algoritmus

• Rekurzív

programnyelv

• Nemrekurzív specifikáció

• Nemrekurzív algoritmus

• Nemrekurzív

programnyelv

• Számítógép


2. Feladat

A Fibonacci-számok

• Nyúlpár szaporodását írja le

• 0,1,1,2,3,5,8,13,21,34,55…

• Def: 0 0

( ) 1 1

( 1) ( 2) 1

ha n

Fib n ha n

Fib n Fib n ha n


Faktoriális számítás sebességének

vizsgálata

N Iteratív Rekurzív

10 0,04 0,2

20 0,08 0,42

50 0,2 1,05

70 0,28 1,5


RekurzióIteráció

Fibonacci sor, faktoriális számítás, Pascal-háromszög

1. Rekurzió helyettesíthető iterációval

2. Az f(n-1), f(n-2)… értékek tárolhatók tömbben

Fib(N)

F[0]=0, F[1]=1

Ciklus I=2 –től N-ig

F[I]=F[I-1]+F[I-2]

Ciklus vége

Fib=F[N]

Eljárás vége


Jobbrekurzió

Példa: Egy szöveg betűinek kiírása

Betűk(X)

Ha X nem üres akkor Ki: Első(X)

Betűk(Elsőutániak(X))

Eljárás vége

• A rekurzív hívás a függvény végén van, utána már nincs szükség a függvény lokális változóira. A paraméterek az eredményt tartalmazzák, vagy a rekurzió szervezését segítik.


Balrekurzió

Példa: Egy bekért számnál kisebb 2 hatványok

kiírása visszafelé

(Szöveg kiírása betűnként visszafelé)

Hatványok(K,M)

Ha K<=M akkor Hatványok(2*K,M); Ki:K

Eljárás vége

• A Rekurzív hívás az eljárás elején van

• Sorozat megfordítása igényli, hogy az elemeket valamilyen adatszerkezetben tároljuk (verem, de lehet tömb is).


Nevezetes feladatok rekurzióra

• Hanoi tornyai

• Pascal háromszög

• Koch-fraktál

• Backtrack algoritmus – 8 királynő

problémája

Programtranszformációk

Rekurzió-iteráció

Elöltesztelő ciklus

R_iteratív(x)

Ciklus amig xxx

S(x)

Ciklus vége

Eljárás vége

R_rekurziv(x)

Ha xxx akkor

S(x)

R_rekurziv(x)

Elágazás vége

Eljárás vége

FeltételUtasításRekurzív

hívás




Hátultesztelő ciklus

R_it(x)

Ciklus

s(x)

Amíg xxx

Ciklus vége

Eljárás vége

R_rek

s(x)

Ha xxx akkor R_rek(x)

Eljárás vége

UFR




számlálós ciklus~előltesztelős

i=kezdet

Ciklus amíg i<=vég

ciklusmag

Ciklus vége

Rek_it(i,n)

Ha i<n

ciklusmag

Rek_it(i+1,n)

Eljárás vége



ItElj(X)

Y=g(X)

ciklus amíg p(X,Y)

S(X,Y)

ciklus vége

X=h(X,Y)

Eljárás vége

Rek0Elj(X,Y)

Ha p(X,Y) akkor S(X,Y)

Rek0Elj(X,Y)

Eljárás vége

Rek1Elj(X)

Y=g(X)

Rek0Elj(X,Y)

X=h(X,Y)

Eljárás vége



Iteráció rekurzió

Miez Eljárás(A,X,K,E,V)

K=(E+V)div 2

Ha A[K]<X akkor E=K+1

Ha A[K]>X akkor V(K-1)

Ha A[K]!=X akkor

Miez(A,X,K,E,V)

Eljárás vége


Programozási tételek rekurzív

megvalósítása:Összegzés

1. Szumma(I,N)

Ha I<=N akkor Szumma=A[I]+Szumma(I+1,N)

Különben Szumma=0;

Függvény vége

2. Szumma(N)

Ha N>0 akkor Szumma=Szumma(N-1)+A(N)

Különben Szumma=0

Függvény vége


A Quicksort rendezés

Hoare (1960)

Módszer: A() a rendezendő sorozat, X kulcs

1. Lépés: Válasszuk az első elemet kulcsnak.

X=A(0)

2. Felosztás. A tömböt két részre bontjuk úgy,

hogy egy K előtt ne legyen nála nagyobb, K

után ne legyen nála kisebb elem

3. A K előtti, és a K utáni részt ugyanezzel a

módszerrel külön-külön rendezzük.


Rendezés menete

5 3 2 6 9 1 4 7 X=5

i j

4 3 2 6 9 1 5 7

i j

4 3 2 1 9 6 5 7

i j<

4 3 2 1 9 6 5 7

K=j

4 3 2 1 9 6 5 7 X=4

i j

1 3 2 4 9 6 5 7

i j<

1 3 2 4 9 6 5 7 X=1

i j

i j=

1 3 2 4 9 6 5 7 X=3

1 2 3 4 9 6 5 7


Algoritmus Quick(A, E,V)

Szétválogat(A,E,V,K)

Ha K-E>1 akkor Quick(A,E,K-1)

Ha V-K>1 akkor Quick(A, K+1,V)

Eljárás vége

Szétválogat2(A,E,V,K)

K=E; J=V; X=A[K]

Ciklus amíg K<J és A[J]>=X

J=J-1

Ciklus vége

Ha K<J akkor A[K]=A[J]; K=K+1

Ciklus amíg K<J és A[K]<=X

K=K+1

Ciklus vége

Ha K<J akkor A[J]=A[K]; J=J-1

Elágazás vége

Ciklus vége

A[K]=X

Eljárás vége

Szétválogat1(A,E,V,K)

K=E; J=V; I=E; X=A[J]

Ciklus amíg J>I

Ciklus amíg A[J]>X

J=J-1

Ciklus vége

Ciklus amíg A[I]<X

i=I+1

Ciklus vége

Ha J>I akkor csere(A[I],A[J])

K=J

Ciklus vége

Egyszerű szétválogatás

sok cserével

X a helyére kerül

az eljárásban

Quicksort rendezés jellemzői

• Rendezés stabilitása: Az azonos értékű

elemek ugyanabban a sorrendben

jelennek meg a kimeneti tömbben, ahogy

a bemeneti tömbben szerepeltek.

• Quicksort nem stabil rendezés

• Keressünk példákat stabil rendezésekre!



Quicksort algoritmus

időbonyolultsága

• Legjobb eset:O(n*log(n))

• Legrosszabb eset:O(n2)

• Átlagos eset:O(k*n*log(n))

n log2(n!) "n*log(n) "n2" 1 0 0 1

10 21 33,21928 100 100 524 664,3856 10 000

1000 8 526 9 965,784 1 000 000

Quicksort iteratív algoritmusa veremmel


5 3 2 6 9 1 4 7

4 3 2 1 9 6 5 7

1 3 2 4 9 6 5 7

1 2 3 4 9 6 5 7

1 2

4 7

0 0

Eleje 0 0 0 1

Vége 7 3 2 2

Közepe 3 2 0 2

Változók értékei:

Verem: eleje, vége


Gyorsrendezés iterációval

verem segítségével lehet Quick(A,E,V)

Verembe(0,0)

Ciklus Ciklus

Szétválogat(A,E,V,K)

Ha V-K>1 akkor Verembe(K+1,V)

V=K

amíg V-E>0

Ciklus vége

Veremből(E,V)

Amíg E>0

Ciklus vége

Eljárás vége


Teszt

• Készítsen rekurzív maximumkiválasztási

algoritmust, és specifikációt!

• Készítsen rekurzív megszámolási

algoritmust és specifikációt!


Objektum Orientált paradigma

• A szoftver krízis a szoftverfejlesztés válsága,

miszerint egy hagyományos módszer (strukturált

programozás) már nem képes az igényeknek

megfelelő, minőségi szoftver előállítására.

• Cél:

– Olcsó

– Jó minőségű szoftver

– Szoftver elemek újrafelhasználhatósága

– Szoftver fejlesztés csapatmunkában

– (design és kód különválasztása)


Objektum definíció

• Elv: Legkisebb modul az objektum, melyben

adatok és eljárások össze vannak zárva.

• Objektumok jellemzője:

– Egységbe zárás (Encapsulation)

• Felelősség

• Zártság

• Osztályozás

– Polimorfizmus

– Öröklődés

– Futás alatti kötés


Előzmények

• SIMULA67: Algol verzió , hajók

modellezése objektumokkal

• 1969 Alan Kay egyetemista szakdolgozata

az objektum orientált programozásról.

• 1970 Xerox Smalltalk az első tiszta

objektumorientált nyelv

• 80-as évek: OO paradigma általánosan

elfogadottá vált


Objektum

• Elv: Legkisebb modul az objektum, melyben adatok és eljárások össze vannak zárva.

• Objektumok jellemzője: – Zártság : a mezők tárolják az információt, a

metódusok kommunikálnak a külvilággal. Az osztály változóit csak a metódusokon keresztül változtathatjuk meg.

– Felelősség

– Polimorfizmus

– Osztályozás

– Öröklődés

– Futás alatti kötés


UML feladata

• Egységesített modellező nyelv

• A program osztályainak és objektumainak megtervezését, és elemzését segítő modellező nyelv

• Jogilag is szabványos jelölésrendszer

• Grafikus nyelv, azaz a modellt diagramok segítségével ábrázolja

• Alkalmazható a vállalatok közötti információcsere eszközeként

• Nincs matematikailag bizonyítva a helyessége


UML Unified Modeling Language 1.0

1997.01.13.

Rumbaugh

Booch

Jacobsen

• Az Objektumorientált rendszer saját feladattal bíró, egymással kommunikáló objektumok összesége. – Felhasználói interfész

– Kontroll

– Implementáció objektum – konténer

– Információ hordozó


Osztály fogalma

• Az osztály: Névvel ellátott típus, ami az

adattagokat és a rajtuk végzett

műveleteket egységben kezeli.

Class Kutya

{

private int lábszám;

private int kg;

public int Ugat(paraméterek)

{kód}

}

Osztály

-lábszám int

-kg int

+ Ugat()

UML

adatta

g

Metódus

Felület: műveletek

összesége


Programnyelvek csoportosítása

• Tiszta OO nyelv pl. C# - Programozás

csak oo alapon képzelhető el. Minden

komponens objektum. Feladat a saját

osztályok elhelyezése a hierarchiában.

• Hibrid nyelvek pl. Turbo Pascal, C++ -

kétféle paradigma mentén is elképzelhető

a programozás.

• Objektum alapú nyelvek pl.


Objektum

• Az osztály példányosításával keletkezik

• Referencia típusú változó

• Kutya k=new Kutya();

• Általában az Osztály nevét nagy

kezdőbetűvel, az objektum nevét kis

kezdőbetűvel írjuk


Láthatóságok

- Privát- „private” csakis az osztályon belül elérhető

# Védett – „protected” hasonló mint a private, de a leszármazott osztályok módosíthatják

+ Nyilvános - „public” mindenki láthatja

Zárt – „sealed” –Nem lehet örökítéssel továbbadni

Belső – „internal”

Védett, belső – „protected internal”

Osztály szintű adat vagy metódus – „static”


Adattagok módosítói

• const – értékadás deklarációkor

– Minden példányban ugyanaz az értéke

• readonly – értékadás konstruktorban

– Példányonként lehet más-más értéke


Átdefiniálás (overloading)

• Függvények túlterhelése

• Ugyanolyan nevű, de különböző

szignatúrájú függvényeket létrehozhatunk

osztályon belül is.


Konstruktor

• kötött a neve –ugyanaz mint az osztály neve

(C++, Java, C#)

• nincs visszatérési típusa

• fő feladata az objektum mezőinek inicializálása

• végrehajtódik, mielőtt bármely metódus

meghívódhatna

• Túlterhelhető

• Egyik konstruktor hívhatja a másikat

• Másoló konstruktor


Destruktor

• Ezen metódusok gondoskodnak arról, hogy az objektum használatának befejeztekor az objektum által lefoglalt erőforrások (memória, file- ok, háttértároló, csatolt eszközök, stb.) felszabadításra kerüljenek.

• Destruktor neve ~jellel kezdődik, nincs visszatérési értéke és nincs paramétere, nincs hozzáférés módosítója

• Nincs destruktor túlterhelés

• A destruktorok meghívásának három módja lehet: – a. explicit módon (programozó által // desktruktor jelleg)dispose

– b. implicit módon (objektum megszűnésekor (ref. számláló))null

– c. automatikusan (objektum nincs már használatban (garbage collector = gc))referencia „elveszett”

GC

• A destruktor automatikus meghívásának a

folyamatát szemétgyűjtési algoritmusnak

nevezzük (garbage collection, GC).

• A garbage collector az osztály Finalize

függvényét hívja meg – a destruktor

függvényt a fordító egy Finalize

függvényre alakítja

• Determinált destrukciós folyamatot az ún.

Dispose metódus implementálásával

oldhatjuk meg. Programozási paradigmák és technikák Dr. Hajnal Éva 70

Szemétgyűjtő algoritmus

• Nemdeterminisztikus

• GC működésbe lép, ha a processzor

kihasználtsága csökken

• GC működésbe lép, ha a rendelkezésre

álló memória lecsökken

• GC működésbe lép, ha „hívjuk”.

• A felszabadítás „sorban” történik


Dispose() használata

bool disposed=false;

…

protected void Dispose( bool disposing )

{ if( !disposed )

{if (disposing)

{// ide jön az erőforrás felszabadító kód

}

this.disposed=true; // nem kell több hívás ha van

ősosztály, akkor annak dispose hívása

base.Dispose( disposing );//Ős destruktor hívása

GC.SupressFinalize(this);///GC kikapcsolása

}

}


Tanács

• C#: Általában szükséges minden általunk

létrehozott osztályhoz konstruktort/kat

definiálni.

• C#: Általában nem szükséges desktruktort

definiálni, megelégedhetünk az

alapértelmezettel.



Tulajdonság

public int X

{

get { return x; }

set { this.x = value; }

}

• Tulajdonság egy speciális függvény

• Nincs paramétere

• Használata értékadás formájú

• Set és get blokk

• Speciális változó value

• Figyelem X!=x

• Privát adattagok hozzáférhetők biztonságos módon

• Csak írható, csak olvasható tulajdonságok beállíthatók


Felbontott típusok (partial types)

//file1.cs

partial class PClass

{ public PClass()

{

}

}

//file2.cs

partial class PClass

{

public void….

}

? Hol találkozhatunk

felbontott típusokkal


Beágyazott osztályok • Egy osztály tartalmazhat más osztályokat is.

• A beágyazott osztály hozzáfér az őt tartalmazó osztály minden adatához.

• Úgy viselkedik, mint egy lokális változó

• Pl. form és a rajta levő vezérlők class Outer

{private class Inner //a beágyazott osztály nem látható

{ }

}

class Outer //de most már igen

{public class Inner

{} }

Outer.Inner innerClass = new Outer.Inner(); //pélányosítás


Fogalmak

• Osztály

• Objektum

• Attributum

• Metódus

• Példányosítás

• Inicializálás

• Felület

• Tulajdonság

• Konstruktor

• Destruktor

Tanácsok • Ha egy programelem önálló értelmezéssel, feladattal,

tulajdonságokkal rendelkezik, akkor definiáljuk ezt az

elemet önálló osztályként.

• Ha egy programrész adata önálló objektumként

értelmezhető, akkor definiáljuk őt a kívánt osztálytípus

objektumaként.

• Ha két osztály közös tulajdonságokkal rendelkezik, akkor

használjuk az öröklés lehetőségét.

• Általában is elmondható, hogy ha a programokban az

osztályok közös vonásokkal rendelkeznek, akkor

törekedni kell univerzális bázisosztály létrehozására.

Gyakran ezt absztrakt bázisosztálynak is nevezzük.

• Az osztályok definiálásakor kerüljük a „nyitott” (publikus)

adatmezők használatát. Programozási paradigmák és technikák Dr. Hajnal Éva

78


Öröklődés - Inheritance

• Egy, már létező típust terjeszthetünk ki, vagy

bővíthetjük tetszőleges szolgáltatással.

• Az eredeti osztályt ősosztálynak nevezzük

(szülő – base class)

• Az továbbfejlesztett osztályt származtatott

osztálynak (gyerek – derived class)

• Egy ősből több származtatott osztályt

készíthetünk (C++) vagy,

• Egy származtatott osztálynak egy őse van (C#),

viszont lehetőség van interfész definiálásra.

Öröklés példa

class utódnév: ősnév

{

// …

}


ősnév

utódnév

class ős

{

private int i; // privát mező

protected int j; // protected mezőtag

public int k; // publikus mezők

public void f(int j)

{ i=j; };

}

class utód: ős

{

…

}; Programozási paradigmák és technikák Dr. Hajnal Éva

81


Öröklés típusai

• Más programnyelvben: public, protected,

privát – csak szűkíteni lehet a

láthatóságot!

• C# - csak publikus öröklés, a mezők

változatlan láthatósággal adódnak tovább


Konstruktor, destruktor végrehajtási

sorrendje • Konstruktor nem öröklődik, hanem hívódik

• Ős. konstruktor() // ha nincs direkt őskonstruktor hívás (base)

• Utód.konstruktor

• …

• Utód.destruktor

• Ős.destruktor

• Paraméteres konstruktor hívása:

utod(paraméterek):base(paraméterek)

{ }


Lezárt osztály

Sealed kulcsszó

• Megtiltjuk, hogy új osztályt származtassunk belőle (public sealed

class kutya:allat)

• Lezárt függvény - nem lehet a

későbbiekben átdefiniálni

public sealed override void

eat(){}

„Zárt osztály” – nem lehet belőle

leszármaztatni sealed class végleges

{

public végleges()

{

Console.WriteLine( "A konstruktor" );

}

class utód:végleges // fordítási hiba

{

} Programozási paradigmák és technikák Dr. Hajnal Éva

85


Korai kötés

• A példányváltozó típusa fordítási időben rögzül

• Metódustábla

e=m;

e.kiir(); //Mi történik?

m.kiir(); //??

A döntést a fordító még akkor meghozza, amikor a

„class elso” osztályt fordítja le. A döntést később már

nem másíthatja meg, hiába definiáljuk felül a

visszaad metódust.


Korai kötés

• A példányváltozó típusa fordítási időben

rögzül

• Metódustábla

• E e=new E(); H h=new H();

• E ős és H az utód, vagy H ős és E az

utód?

e=h;

e.kiir(); //Mi történik?

h.kiir()


Késői kötés

• Az OOP viselkedését, hogy egy metódus

belsejében szereplő másik metódushívás más-

más viselkedést mutat (más-más tényleges

eljárás hívás történik a futtatás során) –

sokalakúságnak, polimorfizmusnak nevezzük.

• A példányváltozó típusa futás alatt változhat

– virtual-override

– new - sealed


Késői kötés

• A példányváltozó típusa futás alatt változhat

• Virtuális metódus tábla

– virtual-override

– sealed-new

http://www.scribd.com/doc/26458586/Programozas-C-

nyelven


Késői kötés class elso

{ public virtual int visszaad() { return 1; }

public void kiir() {

System.Console.WriteLine("Érték={0}", visszaad());

} }

class masodik:elso

{

override public int visszaad() { return 2;

} }

Elso a=new elso();

masodik b = new masodik();

a.kiir();

b.kiir();

Mi kerül a képernyőre?


Típuskonverzió

• Típus lekérdezése object.GetType()

• Is és as

– Típusazonosság lekérdezéséhez (is) if (a is

object)

– Típuskonverzióhoz (as) referenciatípusnál

• Castolás (Button)sender

– Pl. (sender as Button) referencia és érték

típusnál

object Button

Absztrakt osztály – megköveteljük, hogy a

leszármazott osztály implementálja a

metódust

abstract class os

{private int e;…

public abstract int szamol();}

class szamolo:os

{

public szamolo():base(3)

{…}

public override int szamol()

{ }

} Programozási paradigmák és technikák Dr. Hajnal Éva 92


TESZT public new void Close()

{

i++;

this.Text = i.ToString();

System.Threading.Thread.Sleep(5000);

if (i < 5) Close();

else

{

MessageBox.Show("Most zárom!");

base.Close();

}

}

private void button1_Click(object sender, EventArgs e)

{

this.Close();

}

Mit csinál az alábbi

program?


Öröklődés - Adattagok

• A származtatott osztály

Tartalmazza (örökli) a public mezőket és fel is

használhatja

• Tartalmazza (örökli) a protected mezőket és fel

is használhatja

• Tartalmazza a private mezőket, a

memóriaigénybe beszámít, de nem használhatja

azokat. De!! Az örökölt metódusok használhatják

a privát mezőket.


Példa class TPont{

private int x,y;

public void Balra_tol(){if(x>0) x--;}

…

}

class Tkor:Tpont{

public void KorBalratol(){

Balra_tol(); //működik?

X--; //működik??

}

}


Új adatok a származtatott

osztályban class elso

{private int x;

protected int y;

public int z;

}

class masodik:elso

{

int x; //??

int y; //??

int z; //??

}

vagy

class masodik:elso

{

int x; //??

new int y; //??

new int z; //??

}

• new kulcsszóval jelezzük a fordítóprogramnak: szándékos átdefiniálás!


Örökölt mezők II. • Nem lehetséges a típus megváltoztatása

• De new kulcsszóval újra bevezethetjük.

• Átdefiniálással a mezők hatáskörét változtatjuk

meg. Az örökölt mezők hatásköre az ősosztály,

az átdefiniált az utódra vonatkozik.

class elso

{private int x;

protected int y;

Public int z;

}

Class masodik:elso

{

int x; //??

new float y; //??

new double z; //??

}

Régi mezők elérése minősített névvel: …

new float z;

Public akarmi() {

z=1.1; //float

elso.z=1; //örökölt z

}


Öröklődés - metódusok class elso

{

public int visszaad() { return 1;}

public void kiir() {

System.Console.WriteLine(„érték:{0}”, visszaad())

}

}

class masodik:elso

{

new public int visszaad(){return2;}

}

Class Test

{

Static void Main(){

Masodik a=new masodik();

a.kiir(); }

}

Mi kerül a képernyőre? 1 v 2


Örökölt metódusok II.

• A gyerekosztályban lehet ugyanolyan

nevű metódust létrehozni

• Ha a paraméterezése ugyanaz, használni

kell a new kulcsszót

• Ha a szignatúra nem ugyanaz akkor nem

kell a new (overloading)

• Az új metódust az ős osztály metódusai

nem látják


Virtuális Metódus Tábla (VMT) • Késői kötésre csak a virtuális metódusok meghívásakor kerülhet sor.

• Ilyenkor a fordító nem egy konkrét eljáráshívást fordít le, hanem egy

utasítássorozatot, amely futás közben egy keresést hajt végre, hogy

meghatározza, melyik metódusverziót kell konkrétan meghívni. (az

elérhető legfrissebbet)

• A nyilvántartást végzi a VMT

• A táblázatban a metódusok indításához szükséges információk

vannak eltárolva (pl. a metódusok memóriacímei, amely alapján

azokat el lehet indítani)

• Mindig egy osztályhoz tartozik

VMT Algoritmus

1. Induláskor megegyezik az ős VMT-jével.

2. Virtual kulcsszóval bevezetett metódusok bekerülnek a VMT-be (a

végére)

3. Ha override kulcsszóval felüldefiniáltunk egy létező virtuális

metódust, akkor a VMT bejegyzés kicserélődik az új metódusra.


VMT

• Előny: – A késői kötést feloldó programkód rövid, egyszerű, gyors

• Hátrány – VMT tábla készítése – fordítási idő

– A példányokhoz a VMT táblát hozzá kell rendelni - futási időben a konstruktor

– Memóriaigény

Class elso VMT

Int visszaad() Elso.visszaad()

Void kiir() Elso.kiir()

Class masodik VMT

Int visszaad() Masodik.visszaad()

Void kiir() Elso.kiir()

class elso {

public virtual int metodus_ a() { ... }

public virtual int metodus_ d() { ... }

public void metodus_ c() { metodus_ a(); } }

class masodik: elso {

public override int metodus_ a() { ... }

public virtual int metodus_ b() { ... } }


class elso VMT.

Int metodus_ a() elso. metodus_ a

Int metodus_ d() elso. metodus_ d

class masodik VMT

Int metodus_ a() masodik. metodus_ a

Int metodus_ d() elso. metodus_ d

Int metodus_ b() masodik. metodus_ b

• A késői kötés fordítása során olyan programkód

kerül fordításra, amely a VMT táblázat alapján hozza

meg a döntést, hogy melyik konkrét metódust kell

meghívni.

• Az „e.metodus_c()” esetén az „e” példányhoz az

„class elso” VMT tábla tartozik, hiszen az „e”

példány az „elso” osztály egy példánya! Ezért a

késői kötés a „class elso” VMT tábla szerint a

„metodus_a()” hívás esetén az elso.metodus_a()”

metódust kell meghívni.

• A „m.metodus_c()” esetén az „m” példányhoz az

„class masodik” VMT tábla tartozik, hiszen az „m”

példány az „masodik” osztály egy példánya! Ezért a

késői kötés a „class masodik” VMT tábla szerint a

„metodus_a()” hívás esetén a

„masodik.metodus_a()” metódust kell meghívni.


Dinamikus Metódus Tábla • A szerepe megfelel a VMT-nek (késői kötés

feloldását támogatni)

• Kevesebb memóriaigénye van, mint a VMT-nek

• Lassúbb a kezelése

Felépítése:

– Hasonló, mint a VMT

– Osztályhoz van hozzárendelve

– A DMT induláskor üres

– Ha az osztályban bevezetünk egy új virtuális metódust a

„virtual” kulcsszóval, akkor ezen metódus bekerül a

táblázatba (a végére)

– Ha az osztályban felüldefiniáltunk egy már létező virtuális

metódust az „override” kulcsszóval, akkor ez is bekerül a

táblázatba Programozási paradigmák és technikák Dr. Hajnal Éva

104


Virtualitás újrakezdése

• New virtual kulcsszavakkal ellátott

metódus lesz az új metódussorozat

gyökere. A fordító új sor kezd, amikor

felépíti a VMT táblát.


Absztrakt osztály • Az absztrakt osztály létrehozásának célja az, hogy közös

felületet biztosítsunk a leszármazottainak. – Abstrakt osztályt nem lehet példányosítani

– Absztrakt metódusnak nem lehet definíciója

– Leszármazottnak definiálni kell az öröklött absztrakt metódusokat

Abstract class Animal

{abstract public void eat();}

Class dog:Animal

{Animal(){}

Public override void eat()

{Console.WriteLine(„Kutya eszik”);

}}


TESZT

public class Dimensions { public const double PI = Math.PI; protected double x, y; public Dimensions() { } public Dimensions(double x, double y) { this.x = x; this.y = y; } public virtual double Area() { return x * y; } } public class Circle : Dimensions { public Circle(double r) : base(r, 0) { } public override double Area() { return PI * x * x; } }


Interfész definiálása • Igény: Általánosabb leírás érdekében ne egy osztály

keretében fogalmazzuk meg a leírást, hanem kisebb tulajdonságcsoportokat fogjunk össze

• Az interface nem tartalmaz konkrétumot, hanem a kívánt előírásokat tartalmazza (nincs függvény definíció)

• Megegyezés szerint I-vel kezdődik a nevük

• Interface előírásai közé: függvények, tulajdonságok, indexer megadása is beletartozhat

• Interface-nek megadhatunk láthatóságot, az adattagokra is ez a láthatóság vonatkozik

Módosító interface név

{

//deklarációs fejlécek

}


Interface használata

• Class osztálynév: implementálandó név

• Pl.

class jonatan:IAlma

{

Private int kor;

….

}

• Ha egy osztályból másik osztályt származtatunk, ami megvalósít interfészeket is,

Class jonatan:gyumolcs,Ialma,…

{

}


Interface kompozíció • Az interface egységek tervezésekor lehetőség van egy vagy

több már meglevő interface felhasználásával ezekből újabbat definiálni.

Public interface Ialma

{

Bool nyári();

Double termésátlag();

}

Public interface Iszállítható

{

Bool szállit();

}

Public interface szállítható_alma:Ialma,Iszállítható

{

String csomagolás_módja();

}


Típuskonverzió

• A definiált új típusra vonatkozóan használhatjuk mind az is mind az

as operátort.

If (j is IALMA) Console.WriteLine(„Ez alma volt!”);

Ialma a=j as Ialma; //Ialma típusra konvertálás

a.termesatlag();

Implicit konverzió:

Ialma ia=new jonatan(); // működik, ahogy az

osztályoknál is

Explicit konverzió:

MyClass mc=new Myclass();

Ione iface=(Ione)mc;


foreach

Olyan ciklus ami végigiterál egy tömbön,

gyűjteményen ill. minden olyan

objektumon ami megvalósítja az

Ienumerable és Ienumerator intefészeket.

Foreach(int x in a)

{

Console.WriteLine(x);

}


Iterátor példa public class Animal

{ private string name;

public Animal(string _name){}

public Name { get{return this.name;}}}

public class

AnimalContainer:IEnumerable,IEnumerator

{ private Animal[] container=new Animal[10];

private int currPosition=-1;

public AnimalContainer()

{container[0]=new Animal(„Rex”);…

…//MoveNext, Current,Reset, Ienumerator

GetEnumerator()

Foreach(Animal a in ac){ }


Index függvény

• Az indexer függvény definiálása a vektorhasználat és a tulajdonság függvény kombinációja. – Paraméter: index

– Neve: this

• Az aktuális példányt indexeli, soha nem lehet statikus class valami

{int [] v=new int[10];

Public int this[int i]

{get {return v[i];}

set{v[i]=value;}}}

//Main

Valami a=new valami();

A[2]=5;

Console.WriteLine(a[2]);}}


Indexer és a vektor különbsége

• Az indexer függvény, paramétere nem

csak egész lehet

• Az indexer átdefiniálható (overloading)


Kivételkezelés • Programrész végrehajtása eredményesség

szempontjából – Semmilyen rendellenesség nincs

– Programrész paraméterei nem teljesítik az előírásainkat, hibás végrehajtás

– Előre nem látható hibajelenség lép fel.

• Az előre nem megjósolható hiba kivételt (exception) okoz, ezeknek a programkódban történő kezelése a kivételkezelés (exception handling).

• A kivétel kezelés elegáns megoldás, ami futási időben biztosítja a hibák kezelését.

• A C# kivételkezelés az aszinkron kivételek kezelését nem támogatja (hardver megszakítások…)


Kivételkezelés használata • Alapszavak

• try mely után a kritikus programrész következik

• catch ha probléma van, mit kell csinálni

• throw kifejezés, kivételkezelés átadása (dobás)

• finally a kritikus blokk végén biztosan végrehajtódik

try {

…

}

Catch (típus[név]) {

..

}

Finally {

…

}


Kivétel dobása

• Nemcsak a keretrendszer generálhat kivételt, hanem maga a programozó is.

• Chacked és unchecked

• Throw

• A dobott kivételt példányosítani kell!

• Kivételkezelések egymásba ágyazhatók

• A kivétel a következő catch-nek, vagy a keretrendszer kivételkezelőjének továbbadható (throw paraméter nélkül).


Kivétel elkapása

• A try blokkot követheti legalább egy catch

• Ha nincs catch, vagy a catch blokk típusa nem egyezik a keletkezett kivétellel, akkor a keretrendszer kivételkezelő felügyelete veszi át a vezérlést

• A catch típusa az Exception osztálytípus vagy ennek utóda lehet.

• Saját típust is lehet az Exception osztályból származtatni


Saját hibatípus definiálása

• Az öröklődés lehetőségét kihasználhatjuk az egyes hiba lehetőségek szétválasztására.

• HibaIndexhiba vigyázni kell a hibakezelő paraméterezésére

• A catch blokkokat az öröklődés fordított sorrendjében kell definiálni!!!!

public class Hiba:Exception

{public Hiba():base(){ }

public Hiba(string s):base(s) { } }

Public class IndexHiba:Hiba

{ public IndexHiba():base() { }

public IndexHiba(string s):base(s){ } }


Kivételek egymásba ágyazása

• A catch blokkokat az öröklődés fordított sorrendjében

kell definiálni!!!!

J.Zs.Cs.: Vizuális programozás (c) 2010 122

Kivételosztályok

System.Object

System.Exception

System.SystemException

System.ApplicationException

System.ArgumentException

System.ArgumentNullException

System.ArgumentOutOfRangeException

System.FormatException

System.IndexOutOfRangeException

System.IO.IOException

System.NotImplementedException

System.ArithmeticException

System.DivideByZeroException

System.OverflowException

System.NullReferenceException


Felkészülés többfajta kivétel

kezelésére

• Minden hibatípushoz külön catch blokk

• Közös catch

blokk általánosabb

kivételosztállyal

• Általános catch blokk


Kivétel továbbadása - A finally blokk

használata


Kivételek előidézése

if (perc < 1 || perc >= 60)

{ throw new InvalidTimeException(perc +

" érvénytelen percérték");

// !! ide már nem jut el a vezérlés !!

}


Aritmetikai túlcsordulás

• alapértelmezés szerint nincs ellenőrizve

• programban utasításra

checked

{ int szam = int.MaxValue;

Console.WriteLine(++szam); // OverflowException

}

unchecked

{ int szam = int.MaxValue;

Console.WriteLine(++szam); //-2147483648

}

• programban kifejezésre: (checked(++szam))

using használata

• Akkor használhatjuk, ha az osztály megvalósítja

az IDisposable felületet (interfészt)

• Érdemes használni, ha az osztálynak

maradhatnak lezáratlan erőforrásai.


using(StreamReader sr=new

StreamReader(„szoveg.txt”))

{

…

}

try

{

StreamReader sr=new

StreamReader(„szoveg.txt”);

…

}

finally

{

sr.Close();

}


Generikus függvények

• A kód újra felhasználás egyik módszere, osztály, interface vagy metódus általános formában

• T(Template) az aktuális típus, generikus paraméter • Felhasználáskor a fordító felismeri, hogy melyik típust

használjuk,vagy megadhatjuk explicit módon

• A C# a specializált metódusokat futási időben készíti el.

• A fordító formailag ellenőriz, és csak a biztonságosan végrehajtható függvényeket fogadja el.

static public void Swap<T>(ref T x, ref T y)

{ T tmp=x;

x=y;

y=tmp;

}


Generikus osztályok

• Általános definíció – object típusú adattagok vagy paraméterek, mert az object minden objektum őse

• Generikus osztály

class Tomb<T>

{

T[] t;

public Tomb(int meret)

{

t=new T[meret]

}…}


Generikus osztály jellemzői

• Nem kasztolhatók az őstípusra (cast!)

• Generikus megszorítások – Típus szűkítése where kulcsszóval

– Szűkítés: alaposztály, interface, osztály, new(), U

– Az osztály csak akkor példányosítható, ha a megadott típusra igaz a feltétel

class NewClass<T> where

T:BaseClass, IFace, new()

{ }


Generikus gyűjtemények • System.Collections.Generic névtérben

találhatóak

– List, SortedList, LinkedList

– HashSet

– SortedList

– Dictionary, SortedDictionary

– Stack, Queue

• Generikus interfészek

– Pl. IEnumerable és IEnumerator segítségével lehet megvalósítani a generikus osztályokban metódusokat


ZH 04.02

• 50% elmélet

• 50% feladat megoldás

• Elmélet:

• Függvények, rekurzió:órai vázlatok, kiadott prezentációk

• Objektumorientált programozás: órai vázlatok, kiadott prezentációk, C#.pdf 54.o-117.o

• Tanulás papír, toll


TESZT

C# programozás állásinterjú kérdések

Tegnap volt szerencsém egy hazánkban is fejlesztőket foglalkoztató multi állásinterjúkon alkalmazott C# tesztsorával egészen közelről megismerkedni. 12 papíron megválaszolandó kérdés, a szintidő 40 perc. Meg tudod oldani?

A teszt eredetileg angol, a fordítás tőlem származik.

1. Mire jó a new kulcsszó?

3. Nevezzen meg négy hozzáférés módosítót (access modifier) és magyarázza meg a jelentésüket! Van-e ötödik?

4. Mi a különbség az absztrakt osztály és az interfész között elsősorban implementáció és öröklés szempontjából?

5. Írjon kódot, amelyben:

Definiál egy IDoSomething interfészt egy f() metódussal.

Definiál egy IDoSomethingElse interfészt egy f() és egy g() metódussal.

Készítsen egy osztályt, amelyikben implementálja az IDoSomething és az IDoSomethingElse interfészeket úgy, hogy mindegyik metódus kiírja a konzolra a az interfész és a metódus nevét.

Készítsen egy példányt az osztályból és hívja meg a metódusait.

6. Nevezzen meg legalább négy különbséget az érték típus és a referencia típus között!

8. Írja le, hogyan működik a szemétgyűjtő (garbage collector)!


12. Mit ír ki:

{ class Base

{ public Base() { Console.WriteLine( "Base()" ); }

static Base() { Console.WriteLine( "static

Base()" ); } }

class Child : Base

{ public Child() { Console.WriteLine( "Child()" ); }

static Child() { Console.WriteLine( "static

Child()" ); } }

class Program { static void Main( string[] args ) {

Child b = new Child(); } } }


Operátor átdefiniálás (overloading)

• Az értékadás = és az index [ ] operátor nem

újradefiniálható

• Újradefiniálható:

Egyoperandusú: + - ! ~ ++ -- true false

Kétoperandusú: + - * / % & | ^ << >><= >= == != <

>

• Típuskonverziós függvény definiálható


Operátor átdefiniálás

• Precedencia nem változtatható

• Operandusok száma nem változtatható

Static visszatérési_érték operator?(argumentum)

{

//függvénytörzs

}


Példa: + komplex számhoz egész

hozzáadása Public static komplex

operator+(komplex k, int a)

{

komplex y=new komplex(0,0);

y.Re=a+k.Re;

y.Im=k.Im;

return y;

}

y=4+k; //(y és k komplex) ???


Implicit konverziós operátor

• Implicit konvrzió: a forráskódban nem jelöljük

a konverzió műveletét

• Pl. k=4+y; //intkomplex konverzió public static implicit operator komplex(int a)

{


y.Re=a;

return y;

}


Explicit konverziós operator

• Explicit konverzió: konverzió a

forráskódban is jelölve van

• Pl. komplex k=(komplex) 5;

public static explicit operator

komplex(int a)

{


y.Re=a; //lehetne a kód más mint az

implicit konverziónál

return y;

}


++ operator újradefiniálása

Public static komplex operator++(komplex a)

{

a.Re=a.Re+1;

a.Im=a.Im+1;

Return a;

}

K++; vagy ++K; //???


True, false definiálása • Megkötés: mindkettőt egyszerre újra kell

definiálni

public static bool operator

true(komplex x)

{

return x.Re>0;

}

public static bool operator

false(komplex x)

{

return x.Re<=0;

}


Párban újradefiniálható operátorok

• ==, !=

• <,>

• <=, >=

• True, false


Main függvény paraméterei

• Ha a programot paraméterekkel indítjuk a

parancssorból (pl. type autorun.inf), a

paramétereket parancssor

argumentumoknak nevezzük

• Indításkor a Main függvény az operációs

rendszertől átveszi a vezérlést

• Main függvénynek 1 paramétere van, egy

string tömb (args)


Main paraméterei (példa) static void Main(string[ ] args)

{

int i=0;

while (i<args.Length)

{

Consol. WriteLine(args[i]);

i++;

}

{

--------------------------------------------------------

C:\parancs.exe Kellemes húsvéti ünnepeket!

Project/Properties/Configuration Properties/Debugging/Command Line Arguments


Függvények változó számú

paraméterrel • Ha nem tudjuk a függvény készítésekor, hogy hány

paramétere lesz a függvénynek, a params kulcsszóval egy vektorparamétert definiálunk.

public static void intparaméterek(params int[] list)

{

for(int i=0;i<list.Length;i++)

Console.WriteLine(list[i]);

Console.WriteLine();

}

Hívása: intparaméterek(1,2,3,4);

int[] myarray=new int[3]{10,11,12};

intparaméterek(myarray);

? Ha különböző típusú

paramétert szeretnénk

átadni?


Függvények változó és fix

paraméterrel • A fixen megadott paramétereknek kötelezően meg kell

előzni a változó paramétereket.

public static void valtozo(int x, params

object[] list)

{

Console.WriteLine(x);

foreach (object o in list)

Console.WriteLine(o);

}

//Main

valtozo(20,”alma”,”barack”);


Delegáltak - Metódusreferencia • Feladat: egy menüponthoz függvényhívást

rendelni

• Megoldás:

– Hagyományos C vagy C++ programban a

függvénymutató segítségével lehet

– C#-ban a mutatók használata nem engedélyezett –

delegált

• A delegált egy függvénytípus-definíció

• Mindig a fogadó osztályban kell elhelyezni!

delegate típus delegáltnév(típus paraméternév,…);


Delegált példa Public static int negyzet(int i) //statikus

függvény

{

Console.Writeline(„A négyzet területe:”);

return i*i;

}

delegate int pelda(int x);//delegált def.hiányzik a kódblokk

Használata: pelda f=new pelda(negyzet);

Console.WriteLine(f(5));

Vagy

Pelda f=negyzet;

int result=f(5);

Mi az eredmény?


Delegált visszatérési értéke

• Ha a visszatérési érték void, akkor egy

delegált több végrehajtandó függvényt tud

meghívni (multicast – összetett delegált)

• Ha a visszatérési érték nem void, akkor

egy delegált csak egy végrehajtandó

függvényt tud meghívni (single cast –

egyszerű delegált)

MyDelegate d=MethodOne;

d+=MethodTwo;

d();


Windows alkalmazás - eseménykezelés

• Button1.click – delegált függvény

• System.EventHandler - eseménykezelő

this.button1.Click += new

System.EventHandler(this.button1_Click);

Eseménykezelés

• Esemény (event): az osztály saját állapota

megváltozásáról értesít más osztályokat

• A „megfigyelő” osztály feliratkozik a

„megfigyelt” osztály eseményére –

eseménykezelő metódus

• Az esemény megtörténtekor ezek a

metódusok futnak le (speciális delegate)


public delegate void

LenyomásEseményKezelo();

class Gomb

{public event

LenyomásEseményKezelo

EseményKezelo;

public void Lenyomás()

{

{

for (int i = 0; i < 10;

i++) ;

Random vél = new Random();

if (vél.Next(100) <= 50 &&

EseményKezelı != null)

EseményKezelı();

}

}

}

class Program

{

void GombKattintásKezelı()

{Console.WriteLine("Itt történt vmi!");}

void run()

{

Gomb obj = new Gomb();

obj.EseményKezelı+= new

LenyomásEseményKezelı(GombKattintásKe

zelı);

obj.Lenyomás();

}

static void Main(string[] args)

{

new Program().run();

}

}



Dinamikus memóriakezelés

• Segédeszközei: mutatók (pointer) – unsafe módban

• C# arraylist – Object típusú elemeket tárol - típuskonverzió az elemeire

hivatkozásnál

– Változó elemszámú tömböt kezel

– Alapértelmezett kapacitása 16, ha betelik, akkor 16-ként növeli a kapacitást.

– System.Collections névtér tartalmazza

ArrayList list=new ArrayList(); //nem kell megadni az elemszámot

For(int i=0;i<10;i++)

list.Add(i);

if (list.Count>4) //elemszám lekérdezése

int x=(int)list[4]; //explicit konverzió


Adatszerkezet

Az adatszerkezet az adatelemek egy olyan véges halmaza, amelyben az adatelemek között szerkezeti összefüggések vannak.

Az összekapcsolódás módja határozza meg az elemek egymáshoz való viszonyát, illetve azokat a műveleteket, amelyeket rajta végezhetünk.

(Adatelem az a legkisebb adategység, amelyre hivatkozni lehet. )


Matematikai adatszerkezet

<A,R>

rendezett pár, ahol

– A: adatelemek halmaza

– R: az A halmazon értelmezett valamilyen

reláció

• A matematikai adatszerkezetek az R

reláció bonyolultsága alapján

csoportosíthatók


Az adatszerkezetek

osztályozása

Szerkezet szerinti csoportosítás

I. Homogén adatszerkezetek

(Azonos típusú adatelemekből épül fel)

• I.A Struktúra nélküli adatszerkezet

– Az egyes adatelemek között nincs kapcsolat.

Nem beszélhetünk az elemek sorrendjéről.


Az adatszerkezetek

osztályozása

Szerkezet szerinti csoportosítás • I. B Asszociatív adatszerkezet

– Az adatelemek között lényegi kapcsolat nincs. Ez az adatszerkezet valamilyen közös tulajdonság alapján összeállított halmaz, amelyekből részismérvek alapján részhalmazokat választhatunk ki. Az adatszerkezet elemei tartalmuk alapján címezhetők. pl.: tömb, ritka mátrixok, táblák.

• Közvetlen elérésű

• Véletlen elérésű


Az adatszerkezetek osztályozása

Szerkezet szerinti csoportosítás

• I. C Szekvenciális adatszerkezetek

– A szekvenciális adatszerkezet olyan <A, R> rendezett

pár amelynél az R reláció tranzitív lezártja teljes

rendezési reláció

– Szekvenciális adatszerkezetben az egyes adatelemek

egymás után helyezkednek el. Az adatok között egy-

egy jellegű a kapcsolat: minden adatelem csak egy

helyről érhető el és az adott elemről csak egy másik

látható. Pl. egyszerű lista


Az adatszerkezetek

osztályozása

Szerkezet szerinti csoportosítás • I.D Hierarchikus adatszerkezetek

– A hierarchikus adatszerkezet olyan <A,R> rendezett pár, amelynél van egy kitüntetett elem a gyökérelem úgy, hogy

– A gyökér nem lehet végpont Bármely gyökértől különböző elem egyszer és csak egyszer lehet végpont Bármely gyökértől különböző elem a gyökértől elérhető

– A hierarchikus adatszerkezeteknél az adatelemek között egy-sok jellegű kapcsolat áll fenn. Minden adatelem csak egy helyről érhető el, de egy adott elemből tetszés szerinti számú adatelem látható. Pl. fa, összetett lista


Az adatszerkezetek

osztályozása

Szerkezet szerinti csoportosítás • I.E Hálós adatszerkezetek

– A hálós adatszerkezet olyan <A,R> rendezett pár,

amelynél az R relációra semmilyen kikötés nincs.

– A hálós adatszerkezetek adatelemei között a

kapcsolat sok-sok jellegű: bármelyik adatelemre több

helyről is eljuthatunk, és bármelyik adatelemtől elvileg

több irányban is mehetünk tovább.

– Pl. gráf, irányított gráf


II. Heterogén adatszerkezetek

• Különböző típusú adatokból épül fel.

• pl.: Record


Memóriában történő helyfoglalás

szerinti csoportosítás • I. Statikus adatszerkezetek

– Véges számú adatelemből épül fel és ezek

csak értéküket változtathatják hosszukat nem

– pl.: Tömb, rekord, halmaz


Memóriában történő helyfoglalás

szerinti csoportosítás • II. Dinamikus adatszerkezetek

– Adatelemek száma tetszőleges, az

adatelemek száma változhat.

– pl.: Lista, Fa, Gráf


Továbbá

• Lehet rekurzív, melynek definíciója

önmagára való hivatkozást tartalmaz. Nem

lineáris, ha több ilyen hivatkozás van.

• file-ok: nem rekurzív

• láncolt lista: rekurzív lineáris

• összetett lista, fa, gráf: rekurzív, nem

lineáris


Összetett adattípusok

• Tömb

• Füzér

• Lista

– Verem

– Sor

• Bináris fa

• Kupac, halmaz...


Műveletek adatszerkezetekkel

• Az adatszerkezetek meghatározzák, a

rajtuk végezhető műveleteket

• Lehetnek konstrukciós vagy szelekciós

műveletek



– Tömb: Műveletek, csak az egyedi

összetevőkön végezhetők (kivétel a

paraméterátadás)

– Rekord: A mezőkön, a mező típusának

megfelelő műveletek végezhetők



Halmaz:

• Csak a teljes halmazon végezhetők műveletek:

– létrehozás: (feltétellel, felsorolással)

– in: az adott elem benne van-e a halmazban

– +: unió

– *: metszet

– -: különbség összehasonlítás



• Láncolt lista:

– beszúrások

– törlések

– bejárás,

– feldolgozás (pozícionálás, érték kiolvasása)

– jelzés: üres-e, van-e következő elem



• Verem, sor:

– elem be

– elem ki

– üres-e

• Összetett lista

– Cons

– Append

– List



• fa:

elem hozzáadása (levél, gyökér)

törlés (levél, 1 leágazású csúcs, 2 leágazású

csúcs)

bejárás (preorder, postorder, inorder)

tesztek (levél-e, van-e adott oldali részfája)...



Mindegyiken elvégezhető: üres szerkezet inicializálása

• Adatelemeken végezhető műveletek (ahol ez engedélyezett) – csere - egy adatelem értékének megváltoztatása

– rendezés

– keresés - egy adott értékű vagy adott feltételt kielégítő adatelemek helyének megkeresése

– bejárás - valamennyi adatelem egyszeri elérése, feldolgozás


Absztrakt társzerkezetek

• A matematikai adatszerkezetek elméleti

adataszerkezetek –le kell őket képezni a

tárolókra

• címezhető tárolókra (lemez, memória)

• Nem címezhetőkre, ha csak sorosan

szekvenciálisan járjuk be


• 1. Vektor

Címezhető absztrakt

társzerkezetek

1 2 3 n

Elemei direkt elérhetők

Kezelése egyszerű, megfelel az egydimenziós

tömbének

Ha a matematikai adatszerkezet és a társzerkezet

rokon, akkor jó

Asszociatív és szekvenciális , konstans méretű,

kevésbé átszervezendő adatszerkezet


2. Lista (sorozat)

• Elemtípusa bármi, akár lista is

• [a1, a2,…ai-1][ai, ai+1,…an]

• Fejrész, farok-rész


Műveletek

• Létesítés

• Megszüntet

• Üres

• Üres-e

• Elejére

• Végére

• Tovább

• Kiolvas

• Módosít

• Bővít

• töröl

• kapcsol


Műveletek

• Létesítés

[][] [a1, a2,…ai-1][ai, ai+1,…an]

• Megszűntet

[a1, a2,…ai-1][ai, ai+1,…an] [][]


Verem és a sor

• Olyan dinamikus adatszerkezetek, amelyekben előre meghatározott az az elem, amelyet a Töröl művelettel eltávolíthatunk.

• Verem: a legutoljára beszúrt elemet törölhetjük LIFO (last in first out) stratégia

• Sor: mindig a legrégebben beérkezett elemet lehet törölni, FIFO (first in first out) stratégia


Verem statikus megvalósítása tömb

segítségével

• Jellemző adatok: – Veremmutató – stack pointer- az első üres elemre

mutat

– Veremméret – capacity

• Jellemző műveletek – Pop – (veremből)egy elem kivétele a veremből

– Push – (verembe)egy elem verembe helyezése

– Top – (tető) a következő kivehető adat olvasása

– Empty – (üres) van-e adat a veremben

– Full - (tele) tele van-e a verem

1

15

2

2

3

3

4

9

5 6

VM=3

1

15

2

2

3 4 5 6

VM=5

Push(3)

Push(9)

1

15

2

2

3

3

4

9

5 6

VM=4

Pop()


Verem műveletek megvalósítása Logikai függvény Üres()

ha veremmutató=0 akkor return igaz

különben return hamis

Függvény vége

Eljárás verembe(mit) // push()

ha veremmutato>=veremmeret

akkor hiba „túlcsordulás”

ha veremmutató<veremméret akkor

verem[veremmutato]=mit

veremmutató=veremmutató+1;

elágazás vége

Eljárás vége

Függvény veremből() //pop

ha Üres() akkor hiba „alulcsordulás”

ha nem Üres() akkor

veremmutató=veremmutató-1;

return verem[veremmutató]

elágazás vége

Függvény vége


Sorok

• Jellemző adat

– Sor feje : a kiolvasható adatra mutat

– Sor vége: az első üres helyre mutat

– Sor mérete //kapacitás

• Jellemző műveletek

– Sorból

– Sorba


Sor statikus megvalósítása tömb segítségével

1 2 3

15

4

4

5 6

Fej=3 vége=5

1

1

2 3

15

4

4

5

6

6

3

Fej=3 vége=2

1

1

2 3

15

4

4

5

6

6

3

Fej=5 vége=2

sorba

sorból


Sorműveletek megvalósítása Eljárás sorba(mit)

ha Vége=Fej akkor hiba „túlcsordul”

különben Sor[vége]=mit

ha

Vége=Méret-1 akkor Vége=0 egyébként Vége=Vége+1

Elágazás vége

Eljárás vége

Függvény sorból

ha Üres akkor hiba „alulcsordulás”

Különben ha Fej=Méret-1 akkor Fej=0 különben Fej=Fej+1

return S[Fej] //üres sor kezelése

ha Fej=Vége akkor Fej=Méret-1 Vége=0

Elágazás vége

Függvény vége


Klasszikus feladatok veremmel • Matematikai kifejezések kiértékelése verem

segítségével – lengyel forma létrehozása és kiértékelése

1. Lengyel forma létrehozása verem segítségével(prefix, infix, postfix

alak)

5+6 lengyelformája 5 6 +

5+6*2 lengyelformája 5 6 2 * +

5+6*2-3 lengyelformája 5 6 2 * + 3 –

2. Kiértékelés verem segítségével

2

6

5

* 12

5

+ 3

17

-

14 A veremben lévő utolsó

szám: végeredmény


Lengyel forma létrehozásának szabályai • A lengyelforma lényege, hogy nincsenek benne zárójelek és prioritási

sorrendek, verem segítségével balról jobbra egyszerűen kiértékelhető.

• Az összetevőket szóköz választja el, a műveleti jel az operandusokat követi.

• Prioritási sorrend – 0 nem műveleti jelek

– 1 (

– 2 + -

– 3 * /

– 4 )

• Szabály (az input és az output is string) 1. Az input sztring balról jobbra karakterenként kerül feldolgozásra.

2. A számok változatlan formában átkerülnek az outputra szóközzel elválasztva

3. A ( bekerül a verembe

4. A ) esetén a legelső (-ig kiürítjük a vermet, és a zárójeleken kívüli jelek az output sztringbe kerülnek

5. Egyéb műveleti jelnél a veremből kivesszük az összes, a jelenlegi jelnél nem kisebb prioritású műveletet, és az otput sztringbe írjuk, a jelenlegi műveleti jel a verembe kerül

6. Ha az input sztring végére értünk a verem tartalmát az outputhoz hozzáírjuk

5+6*2-3 lengyelformája 5 6 2 * + 3 –


class Stack<T>

{

T[] t;

int veremmutato; //stack pointer

readonly int veremmeret; //stack size

public Stack(int meret)

{ t = new T[meret];

veremmeret = meret;

veremmutato = 0; }

public void Push(T _in)

{ if (veremmutato >= veremmeret)

{throw (new StackOverflowException("Tele van a verem")); }

t[veremmutato] = _in;

++veremmutato;

}


public object Pop()

{ --veremmutato;

if (veremmutato >= 0)

{return t[veremmutato]; }

veremmutato = 0;

throw(new InvalidOperationException("Üres a verem, nem lehet kivenni")); }

public object Top()

{ if (veremmutato <= 0)

{throw (new InvalidOperationException("Üres a verem")); }

return t[veremmutato - 1];

}

public bool Empty()

{ if (veremmutato > 0)

return false;

return true; }

}

Listák


Egyszerű láncolt lista

1 2 3 ø fej

Adat

tartalom

Mutató a

következő

elemre

Vége

NULL

Törlés a listából

1 2 3 ø fej

Általában nem

szükséges tényleges

törlés

Láncolt lista • Olyan adatszerkezet, amelyben az elemek lieáris

sorrendben követik egymást

• A lineáris sorrendet mutatók (C# referenciák)

segítségével valósíthatjuk meg.

Típusai:

• Szerkezet szerint

– Egyszeresen láncolt

– Kétszeresen láncolt

– Ciklikus

• Szervezés szerint – Rendezett

– Nem rendezett

Programozási paradigmák és technikák Dr. Hajnal Éva

190


Kétirányú láncolt lista

• A lánc minden eleme két hivatkozást tartalmaz, az előző és az őt követő elemre

• A lánc végét az utolsó elem következő részének kitüntetett értéke jelzi

• A lánc elejét az első elem előző részének kitűntetett értéke jelzi

• Az első elem címét a listafej tartalmazza

• Az utolsó elem címét érdemes tárolni (vége)

• Előny az egyirányú listához képest: kevesebb műveletigény a keresés, törlés, beszúrásnál

• Hátrány: helyfoglalás, bonyolultabb algoritmus

1 ø 2 3 ø L

(fej)

vége előző következő

adat

Keresés listában (az első k

kulcsú elem keresése) Listában-keres(L,k) //L lista fej referenciája

X=L //L a lista feje

Ciklus amíg x<>null és x.kulcs<>k

x=x.következő

Ciklus vége

Return x

Programozási paradigmák és technikák Dr. Hajnal Éva

192


Beszúrás lista elejére

Listába-beszúr(L,x)

K=Elemfoglal(x)

K.következő=L

Ha L<>null

L.előző=K

L=K

K.előző=null

Törlés láncolt listából

Listából-töröl(L,x) //x referencia

Ha x.előző<>null

Akkor (x.előző).következő=x.következő

Különben L=x.következő

Ha x.következő<>null

Akkor (x.következő).előző=x.előző



Strátzsa (őrszem, sentinel)

technika • Strázsa elemek: a lista elejére és/vagy a

végére felvett kiegészítő elemek. Értékes adatot nem tárolnak, csak technikai szerepük van. Kiküszöbölik az első, utolsó elemek problémáját

• Előnyök: egyszerűbb, gyorsabb beszúrás és törlés

• Hátrány: helyfoglalás, bejárás körülményesebb

Ciklikus kétirányú strázsás lista


1 2 3

előző következő adat

üres

Törlés(L,x)

(X.előző).következő=x.következő

(X.következő).előző=x.előző

L


Klasszikus feladatok listákra

• Polinomok műveletei

• Feladat: Két polinom összeadása

– Adjunk össze két x,y,z változójú polinomot!

– ExAyBzC polinom a kitevők szerint csökkenően

rendezettek


Bináris keresőfák (BST Binary Searching

Tree) • Definíció: Olyan bináris fa, amelyben minden

csúcsra igaz, hogy a baloldali részfájában a kulcsok(adattartalom) kisebbek vagy egyenlőek, a jobb oldali részfábanpedig nagyobbak vagy egyenlőek.

• Tetszőleges kulcs elérhető a gyökértől induló keresőútvonalon úgy, hogy minden csúcsból a bal, vagy a jobb részfa felé haladunk, és a döntéshez csak a csúcsot vizsgáljuk.

• Gyökérközepű bejárása? 25

10 43

5 33 50

48


Keresőfa építése

• 42,30,37,70,50,20,61,57,90,25 elemekből

42 42

30

42

30

37

42

30

37

70


Beszúrás keresőfába

Függvény beszúrás (x,k)

ha x=null akkor

elemlétrehozás(x)

x.kulcs=k x.bal=null x.jobb=null

return x

különben

ha x.kulcs>k akkor

return beszúrás(x.bal,k)

különben

ha x.kulcs<k akkor

return beszúrás(x.jobb,k)

return x

Elágazás vége


Keresés BST-ben

Fában-keres(x,k) //x a gyökér, k a keresett

kulcs

Ha x=null vagy k=kulcs[x]

akkor return x

Ha k<kulcs[x]

akkor return Fában-

keres(bal[x],k)

különben return Fában-

keres(jobb[x],k)

Függvény vége


Iteratív keresés

Fában-i-keres(x,k)

Cilkus amíg x!=null vagy k!=kulcs[x]

Ha k<kulcs[x]

Akkor x=bal[x]

Különben x=jobb[x]

Elágazás vége

Ciklus vége

Return x

Függvény vége


Törlés bináris fából


Törlés keresőfából

• Feladat: adott kulcsú elem törlése a keresőfából

Esetek

1. elemnél kisebbbalra le

2. Elemnél nagyobb jobbra le

3. = akkor

1. Ha levélelem törlés (1.eset)

2. Ha nem levélelem törlés, és a részfák kapcsolása (2. és 3. eset)

25

10 43

5 33 50

48 52

49

1.

2.

3.


Tökéletesen kiegyensúlyozott

fák • Def. Ha minden csúcsnak a bal és a jobb

oldali részfájában lévő csúcsok száma legfeljebb eggyel tér el.

Kiegyensúlyozás

Ha N=0 a fa üres

Ha N>0 1. Használjunk el egy csúcsot gyökérnek

2. Készítsük el az N/2 csúcsból álló bal részfát

3. Készítsük el az N-(N/2)-1 csúcsból álló jobb részfát


Kiegyensúlyozás


Kiegyensúlyozott fák

• Def. Ha minden csúcsra legfeljebb egy a

különbség a bal és a jobboldali részfa

magassága között.

• Ha a keresőfában nagy a magasságbeli

különbség a szintek között, akkor a

keresés időigénye függ a keresendő elem

értékétől.


Piros-fekete fák

• Piros-fekete fa olyan bináris keresőfa,melynek

minden csúcsa egy extra bit információt hordoz.

• A színek korlátozásával biztosítható, hogy a

gyökértől a levélig vezető út hossza nem lehet

nagyobb, mint a legrövidebb ilyen út hosszának

a kétszerese

• Piros-fekete fák megközelítőleg

kiegyensúlyozottak.

• Csúcs adatai: szín, kulcs, bal, jobb, szülő


Tulajdonságok

1. Minden csúcs színe piros vagy fekete

2. Gyökér színe fekete

3. Levél:fekete (gyakran nem is ábrázoljuk)

4. Piros csúcs mindkét gyereke fekete

5. Bármely csúcsból bármely levélig vezető

úton ugyanannyi fekete csúcs van.


Piros-fekete fa

Fekete mélység: Adott

csúcsból, ahol ő maga

nem számít az

eredménybe, a levélig

vezető úton a fekete

csúcsok száma.


Műveletek

• Forgatások (balra, jobbra forgat)

• Beszúrás

• Törlés

AVL-fa

• Az AVL fa olyan bináris keresőfa amely

magasság kiegyensúlyozott:

– A bal és jobb részfa magassága legfeljebb 1-

gyel különbözik.

• Megvalósítás +mező :magasság



B-fa

• Nagyméretű keresőfák esetén előfordul,

hogy az egész fa nem fér el az operatív

tárban.

• A fát részfákra bontjuk, és a részfákat

(lapoknak nevezzük) olyan egységként

ábrázoljuk, amelyek elemeire együtt

hivatkozhatunk.

• Minden lap n és 2n közötti tételt tartalmaz


B-fa definíciója


B-fa tulajdonságai

1. Minden lap legfeljebb 2n tételt tartalmaz

2. Minden lapon a gyökér lapjának

kivételével legalább n tétel van.

3. Egy lap lehet levéllap(utód nélküli), vagy

m+1 utóddal rendelkezik, ahol m a lapon

levő kulcsok száma

4. Minden levéllap ugyanazon a szinten

helyezkedik el.


Teszt

• Adja meg egy adott elem listába

beszúrásának algoritmusát

• Építsen BST fát a következő elemekből

12, 35, 3, 4, 89, 12, 56, 20


Radix rendezés

• Legtermészetesebb rendezés, ha sok névből álló, vagy sokjegyű számokból álló listát kell rendezni.

• Pl. decimális számokra

• Először az utolsó számjegy szerint csoportokba szétválogatom, és a csoportokat újra összevonom

• Utána az utolsó előtti számjegy szerint szétválogatom stb.


A radix rendezés bonyolultsága Ha A1, A2…An az n elemet tartalmazó lista.

d az alap, vagyis a válogatás során kialakítandó csoportok száma (d=10 decimális számoknál, d=26 betűknél stb.)

s a számjegyek száma, karakterek száma stb., ennyi menetben kell végezni a szétválogatást

• Összehasonlítások száma<=d*s*n

• d független n értékétől, de s függ tőle:

• log n<=s<=n O(n*log(n))

• Tárigénye: d*n, ezt dinamikus helyfoglalással 2*n-ig lehet csökkenteni.


Kupac adatszerkezet

definíciója

• Kupac • Olyan (bináris) fa, amely teljesíti a

kupactulajdonságot.

• Kupactulajdonság • Ha B A gyereke, akkor a (maximális)

kupactulajdonság: kulcs(A) ≥ kulcs(B)

Vagyis

Minden elem kisebb kell legyen mint a

szülő


Rendezések - Kupac rendezés

• Kupac:

– Olyan tömb, melynek elemeit egy bináris fa

csomópontjaiként képzeljük,

– K(1) a fa gyökere,

– ahol a j indexű szülő gyerekei a 2*j és 2*j+1

indexű elemek (K(2*j) és K(2*j+1)

– K([j/2])>=K(j) 1<=[j/2]<j<=n-re


1. Az algoritmus első fázisa

Kiindulás:



Az elemeket egyesével bevonjuk a kupacba

A levélelemekre automatikusan teljesül

a kupac tulajdonság

Az m=j/2 esetre kell biztosítani a kupac

tulajdonság teljesülését az elemek

cseréjével, úgy, hogy mindig csak az m

csúcs gyökerű részfán dolgozunk.









A kupac elkészült


1. Az algoritmus második fázisa






Az algoritmus második fázisa













Végeredmény


Algoritmus I. Kupacrendezés

algoritmusa

KupacRend(T/*tömb*/, int n /*hossz*/)

{ // épít egy kupacot

for (int i = n / 2; i >= 0; --i) Sullyeszt(T, i, n);

// a kupac legnagyobb elemét kicseréli az utolsó elemmel

// majd kijavítja a kupacot, ami mostmár nem a teljes, hossz,

hanem csak az "utolsó" előtti elemtől számít

for (int i = n; i >= 0; --i)

{ csere(T[0], T[i]); Sullyeszt(T, 0, i - 1);

}

}


Algoritmus I. Kupac tulajdonság fenntartása Sullyeszt(T /*kupac*/, int pont, int m)

int apa = pont; int fiu; temp = kupac[pont];

Ciklus amíg ((fiu = 2*apa + 1) < m ) //a nulla indexelés miatt a 2*apa + 1 adja a bal gyereket

//pelda: 8, 2, 5, 7, 6. a 0 indexelés szerinti 1. elem azaz a "2" bal gyermeke a "2*1 + 1 = 3" indexű elem, azaz a "7".

// jobb gyerek > bal gyerek, akkor átlép jobb gyerekre

ha (T[fiu + 1] > T[fiu]) fiu++;// ha

teljesül a kupac tulajdonság, akkor megáll

ha (temp >= T[fiu]) break; // a gyereket

feljebb hozza

T[apa] = T[fiu]; apa = fiu;

Ciklus vége // a javítandó elemet beteszi az utolsó emelt gyerek

helyére

T[apa] = temp;

Eljárás vége


Algoritmus II. Kupac-építése

Kupacot épít(T ) // T tömb

m=n-1 //utolsó index értékét kapja

ciklus i=(n-1)/2-től 0-ig

maximum-kupacol(T,i)

ciklus vége

Eljárás vége


Algoritmus II. (rekurzív) Kupactulajdonság

fenntartása Maximum-kupacol(T,i)

L=i*2+1 //bal

R=i*2+2 //jobb

ha L<=m és T[L]>T[i] //m a kupacméret

akkor legnagyobb=L

különben legnagyobb=i

ha r<=m és T[R]>T[legnagyobb]

akkor legnagyobb=r

ha legnagyobb!=i

akkor csere(T[i], T[legnagyobb])

Maximum-kupacol(T,legnagyobb)

elágazás vége

Eljárás vége


Algoritmus II. Rendezés

Kupacrendezés(T)

Kupacot épít(T)

ciklus i=n-1-től 1-ig

csere(T[0],T[i])

m=m-1 //kupac méret csökkentése

maximum-kupacol(T,0)

ciklus vége

Eljárás vége


Rendezés jellemzői

• Tárigény: n (helyben rendező algoritmus)

• Időbonyolultság:

– Kupac kialakítása:

• Legjobb eset: 0 mozgatás

• Legrosszabb eset: n/2 mozgatás

– Kupac lebontása:

• log(n-1)+log(n-2)+….<n*log(n)

• Összesen O(n*log(n)/2)


Huffman-kód • Széles körben használt, nagyon hatékony

módszer állományok tömörítésére

• Az állomány karaktereinek gyakoriságát alapul

vevő, állandó vagy változó hosszúságú kód.

• Prefix kód: olyan kódszavakat tartalmaz,

amelyekre igaz az, hogy egyik kód sem

kezdőszelete a másiknak.

– Pl.ha a = 0 akkor a többi karakter kódja csak 1-gyel

kezdődhet

– pl. b=10 akkor 10 –val több nem kezdődhet


Huffman-kódhoz tartozó bináris

fa

Azonos hosszúságú kódok, minden

levélelem ugyanazon a szinten

helyezkedik el. Változó hosszúságú prefix kódot

tartalmazó bináris fa


2-es Fa jellemzői:

• Külső csomópontok száma eggyel

több mint a belső csomópontok száma

• A kód hossza a levélelemek magassága

• Ha az egyes csomópontokban a

karakterek gyakorisága, vagy a bal és jobb

gyerek súlyának összege a súly, akkor a

legtömörebb kódolást a legkisebb

súlyozott külső útvonalhosszúságú fával

érhetjük el.

Huffmann-algoritmus

• Tegyük fel, hogy adott az n darab súly

(karakterek gyakorisága), w1,w2…wn

növekvő sorrendben.

• T minimális súlyozott útvonal-hosszúságú

fa előállítása: w1+w2 külső csomópontot

helyettesítjük a

részfával


w1 w2

Példa • Tegyük fel, hogy az A, B, C, D, E, F, G, H

karakterekhez az alábbi súlyok tartoznak: A 22

B 5

C 11

D 19

E 2

F 11

G 25

H 5


22

A

5

B

11

C

19

D

2

E

11

F

25

G

5

H

22

A

5

B

11

C

19

D

2

E

11

F

25

G

5

H 7

1.

2.

...


Algoritmus

Huffman(C)

Karaktergyakoriságok megállapítása

Q kupac létrehozása (minimum-kupacol

eljárással)

Ciklus i=1 től n-1 ig

új z csúcs létesítése

bal[z]=x kivesz-min(Q)

jobb[z]=y kivesz-min(Q)

beszúr(Q, x gyakorisága+y gyakorisága)

Ciklus vége

Return kivesz-min(Q)


Emlékeztető - Tematika

Teszt

• Építsen maximum-kupacot a következő

elemekből

12, 35, 3, 4, 89, 56, 20

A rendezés i=4. lépésében írja fel a kupacot

és a vektorból képzett bináris fát!


Hasító táblázat

• Tömb adatszerkezet általánosítása

• Jól alkalmazható adatszerkezet, ha

Beszúr(), Keres() és Töröl() műveleteket

megvalósító dinamikus halmazra van

szükség.

• Beszúr(), Keres(), Töröl()-

szótárműveletek



Halmaz megvalósítása közvetlen címzésű

táblázattal

Feltételek:

Kisméretű kulcsuniverzum

Nincs két egyforma kulcsú elem


Közvetlen címzésű táblázat

• T[0…m-1] tömb segítségével

• Táblázat helyei – rés – megfelelnek a kulcsoknak

• K. rés a halmaz k kulcsú elemére mutat.

• Ha nincs k kulcsú elem akkot T[k]=null

• Műveletek – Közvetlen címzéssel – végrehajtási idő O(1) Keres(T,k)

return T[k]

Beszúrás(T,x /*adat*/) T[kulcs[x]] x

Törlés(T,x/*adat*/) T[kulcs[x]]=null


Adatelemek tárolása

• Magában a közvetlen címzésű

táblázatban, gyakran a kulcsmező tárolása

sem szükséges

– Visszakeresés index alapján

– Ha nem tároljuk a kulcsmezőt, el kell tudni

dönteni, hogy a rés üres-e

• A réshez mutatóval kapcsolt külső

objektumban


Közvetlen címzés problémája

• Ha az U univerzum nagy és a tárolt elemek K halmaza U-hoz képes kicsi, akkor a T táblázat nagy helyet foglal, de nagy része üres, a kihasználtság kicsi

• Memóriaigény leszorítható egy alkalmasan választott függvény segítségével, amely a k kulcsú elemet egy k’ résben tárolja ahol k’=h(k), vagyis hasító függvényt használunk a k’ kiszámításához.

• h:U{0,1,…m-1}

• Új probléma: kulcsütközés


Kulcsütközés


Hasítófüggvények


Kulcsütközés

• Ha két kulcs ugyanarra a résre képződik le

• Kulcsütközés elvileg sem küszöbölhető ki,

mert U>m, tehát mindenképp kell lennie

legalább két kulcsnak, amelyek ugyanarra

a résre képződnek le.


Kulcsütközés feloldása I.

• Túlcsordulási terület használatával

• Csak akkor alkalmazható ha nagyon kevés a kulcsütközés

• Beszúrás: a, T[h(k)] =null → beszúrás T[h(k)]-ba

b, T[h(k)] ≠ null → beszúrás túlcsordulási területre

• Keresés: a, T[h(k)] = keresett → megvan

b, T[h(k)] = Ø → nincs

c, T[h(k)] ≠ keresett

keresett túlcsordulási terület → megvan

keresett túlcsordulási terület → nincs


Kulcsütközés feloldása

láncolással


Példa

• Kövessük végig láncolásos

ütközésfeloldás esetén az

5,28,19,15,20,33,12,17,10 kulcsok hasító

táblázatba való beszúrását. Legyen a

rések száma 9 és a hasító függvény

h(k)=k mod 9


Ütközésfeloldás láncolással II. • Ugyanarra a résre leképződő elemeket

összefogjuk egy láncolt listába

Láncolt-hasító-beszúrás(T,x)

1 beszúrás a T[h(kulcs[x])] lista elejére

Láncolt-hasító-keresés(T,k)

1 a k kulcsú elem keresése a T[h(k)] listában

Láncolt-hasító-törlés

1 x törlése a T[h(kulcs[x])] listából.

Beszúrás és törlés műveletigénye: O(1)

Rendezés?


Keresés időigénye

• Legrosszabb esetben a keresés időigénye

O(n)

• Jó esetben:

– Legyen =n/m ( a kitöltési tényező, vagyis a

láncba fűzött elemek átlagos száma)

– Egyenletes hasítás esetén O(1+), vagyis a

keresés átlagos ideje állandó


Hasító függvények

• Hogyan működik egy jó hasító függvény?

– Egyenletességi feltétel: egyenletesen ossza szét a kulcsokat

• Ehhez ismerni kellene a kulcsok eloszlás függvényét

– A hasonló kulcsokat véletlenszerűen ossza szét

– Kevés kulcsütközést produkáljon

– Egyszerűen kiszámítható legyen

– A hasítófüggvény kötelezően determinisztikus


A kulcsok természetes számokkal való

megjelenítése

• A kulcsokat természetes számként

kezeljük,

• Ha nem természetes szám akkor

természetes számmá kell alakítani pl.

ASCII kódok…

• h(k) = ΣKarakterkód(ki) (k є Szöveg)


Osztásos módszer

• h(k)=k mod m

• Jellemzői

– Gyors hasítás

– Jó, ha m egy kettőhatványhoz nem közeli prim.

– Rések száma m

– Példa:2000 db adat van a kitöltési tényező lehet ~3, tervezzük meg a hasítófüggvényt!


Szorzásos módszer

• h(k)=KözepeM(A*k)

• KözepeM(x) visszaadja az x középső M

darab helyiértékét

• Nevezetes módszer a négyzetközép

módszer: h(k)=KözepeM(k*k)


Az univerzális hasítás

• Véletlenszerűen kiválasztott

hasítófüggvénnyel próbálja minimalizálni a

kulcsütközést.


Kulcsütközés feloldása – Nyílt címzés III.

A duplikátumot egy előre definiált szisztematikus üres hely kereséssel helyezzük el!

• Beszúrás: Ha T[h(uj)] foglalt, egy/több lépés előre/hátra amíg nem találunk egy üres helyet, ide elmentjük

• Keresés: Ha T[h(keresett)] nem a keresendő elem, a beszúrásnál használt azonos lépések végrehajtása,amíg nem találjuk meg, vagy az első üres helyig. Ha az induló vagy bármelyik elem üres, akkor nincs a táblázatban

• Törlés:Keresés után az elem bejelölése töröltnek (nem üres!)


Kulcsütközés feloldása IV. – Dupla hasítás

• Használjunk két hasító függvényt (h1, h2)!

• Beszúrás: Ha a h1 függvény alkalmazásával

kulcsütközés lépne fel,

próbáljuk egy másik h2 függvénnyel, ami

máshova képez

• Keresés: Ha a h1 által megadott helyen nem

találjuk a keresett elemet, keressük a h2 szerint

is

• Törlés: A fenti kereséssel megtalált elemet

töröljük


Hasítótáblák felhasználása

• Adatbázisokban

• Fordítóprogramok szimbólumtábláiban


Példa

• Egy bitvektor egy biteket tartalmazó,

egydimenziós tömb. Egy m hosszúságú

bitvektor sokkal kevesebb helyet foglal el,

mint egy m mutatót tartalmazó tömb. Írjuk

le, hogyan lehetne egy dinamikus halmazt

bitvektorral megvalósítani, ha tudjuk, hogy

az elemek mind különbözők és nincs

kisérő adat.


Példa

• Készítsünk 3 jegyű számok rendezésére

alkalmas radix rendező algoritmust. A

szétválogatáshoz foglaljunk egy int[10,n] T

mátrixot, az egyes sorokban levő

elemszám tárolására alkalmazzunk egy

int[10] index vektort. Javasoljon más,

hatékony adatszerkezetet a feladat

megoldásához.

Documents

Programozási paradigmák és technikák - arek.uni-obuda.huhajnale/Cikkek_PDF/ppt.pdf · UML Rendszertervezés Programozási paradigmák és technikák Hogyan kell dokumentálni