Egyenesvonalú ( lineáris ) adatszerkezetek

Egyenesvonalú (lineáris) adatszerkezetek

• Absztrakt Konkrét adatszerkezetek

• Specifikáció Megvalósítás

• Szekvenciális elérés (fájl. perifériák)

• Véletlen elérés (vektor, fájl, perifériák, RDBMS-ek, Random Access Memory)

• (Alap)műveletek és hatékonyságuk

– Olvasás (Szelektor)

– Beírás

– Létrehozás (Konstruktor) és Beszúrás

– Törlés

– Keresés

– Rendezés

Tömbök SILAN nyelven

class Person {

attribute String name;

attribute Person [0..*] child;};

class Person {

attribute String name;

attribute Set(Person) children;};

Példa: tömbök Java nyelven• tipus[] nevek; //tömbhivatkozás• nevek = new tipus [12]; //helyfoglalás• int[] szamok = {1, 2, 3}; //kezdőértékezés

(konstruktor)• DE!! HIBÁS!! szamok = {1, 2, 3};• szam = szamok[4]; //kiolvasás – szelektor• szamok[4] = szam; //beírás• Keresést, beszúrást, törlést ciklussal be kell

programozni!!

Többdimenziós tömbök• Kétdimenziós tömb: egydimenziós tömbök tömbje. Pl:

m méretű tömbökből felépített n méretű tömb:• tipus[n][m] nevek;

Rekordszerkezet• Több, esetleg különböző részekből összetett adattípus• Osztály, függvények nélkül, csak látható tagokkal• Véges, ha az összetevők végesek, és ha nem rekurzív

Dolgozó

keresztNév : StringvezetékNév : Stringnem : Nemszületett : Datevallás : Felekezetpárt : Párt

3DPont

x : Realy : Realz : Real

• Pascal: változtatható rekord: típusegyesítés

• Feltehetőleg: helytakarékosság célzatából

type geographicalLocation =record case kind:(WGS,EOV) of

WGS:(lat:Real,long:Real);EOV:(x,y:Real)

end

Visibi li tyKind

publicprotectedprivate

<<Enumeration>>

A Pascal halmazfogalma

• type halmazom = set of tipusom

• … ahol „tipusom” egy véges számosságú típus

• ábrázolása: karakterisztikus függvény, bitvektor

A Pascal fájl-fogalma• type filem = file of tipusom

Tetszés szerint növekedő sorozatok leírására

• type file2m = file of file of tipusom

Szegmentált fájlok leírására

• type text = file of char

standard szövegfájlok

Vermek és sorokLast In First Out (LIFO) – First In First Out (FIFO)

Sor

Üres() : BooleanBeszúr(elem : Integer)Kivesz() : Integer

VégesSor

Tele() : Boolean

Ugyanazt vesszük ki, ugyanolyan sorrendben, mint ahogy beletettük

ValódiSor

max : int = 100tomb : int = 0..maxfeje : int = 0farka : int = 0

Verem

Üres() : BooleanBeszúr(elem : Integer)Kivesz() : Integer

ugyanazt vesszük ki fordított sorrendben, mint amit betettünk

VégesVerem

Tele() : Boolean

ValódiVerem

max : int = 100tomb : int = 0..maxindex : int = 0

Vermek, megvalósítása

public class verem {int max = 100;int tomb[] = new int[max];int teteje=0;public boolean ures() {

return (teteje == 0);}public void beszur(int elem) {

tomb[teteje++]=elem;}public int kivesz() {

return (tomb[--teteje]);}public boolean tele() {

return (teteje==max);}}

int: teteje;(az első üres helyre mutat)

Sorok

int: farka;(az első üres helyre mutat, ide állítjuk az új elemet)

int: feje;(a legelső tele elemre mutat)

int: farka;(az első üres helyre mutat, ide állítjuk az új elemet)

int: feje;(a legelső tele elemre mutat)

Újabb állapotjelző

- Hogy néz ki az üres sor- Hogy néz ki a tele sor- Hogy valósítható meg az állapotdiagram

Kezdet

ÜresTele

NemTeleNemÜres

Kivesz:int

Betesz(int:elem)Betesz( int:elem )[ szabad=1 ]

Kivesz:int[ szabad<max-1 ]

Betesz( int:elem )[ szabad>1 ]

Kivesz:int[ szabad=max-1 ]

Kezdet

NemTeleNemÜres

TeleEUresE

Üres Tele

Betesz( elem:int )Kivesz:int

[ Tele ][ Ures ]

[ not Ures ] [ not Tele ]

Betesz(elem:int) Kivesz:int

Sorok (tovább)

• Másik megoldás két állapotjelzővel, de kicsit (talán) egyszerűbb algoritmussal

ÁllapotjelzőÁllapotjelző

Sorok (programkód)public class sor {

int max = 100;int tomb[] = new int[max];int feje=0;int farka=0;boolean ures=true;boolean tele=false;

public boolean ures() {return (ures);}

public boolean tele() {return (tele);}

public void beszur(int elem) {tomb[farka]=elem;ures = false;if (farka<max-1) farka++;else farka=0;if (farka == feje) tele = true;}

public int kivesz() {int elem;elem = tomb[feje];tele = false;if (feje<max-1) feje++;else feje = 0;if (feje == farka) ures = true;return (elem);}

}

Láncolt listák

LáncoltLista

tartalom : Integerkövetkező : LáncolLista = NIL

Üres() : BooleanBeszúr(elem : LáncoltLista)Töröl(elem : LáncoltLista)Keres(mit : Integer) : LáncoltLista

Láncolt2Lista

tartalom : Integerelőző : Láncolt2Lista = NILkövetkező : Láncolt2Lista = NIL

Üres() : BooleanBeszúr(elem : Láncolt2Lista)Töröl(elem : Láncolt2Lista)Keres(mit : Integer) : Láncolt2Lista

A listaelemek nem feltétlenül helyezkednek el növekvő sorrendben!!!

Megvalósítás? Házi feladat…

Változók helyfoglalása

public static int RFactorial(int n) {

if (n==0) return 1;

return RFactorial(n-1)*n;}

public static void main (String[] args)

{…

int n=5;

int [] szamok = new int[5];

System.out.println(RFactorial(n));

…}

Helyi változók

Dinamikus memória

(heap)

Hely szerint:- helyi- globális

Mód szerint:- változó értékét tároljuk- változó hivatkozást tároljuk

Eljárás belépéskor a vermen helyet

foglalunk

Eljárásból kilépéskor a vermet ürítjük, és elengedjük a

globálisan foglalt területeket

Dinamikus memóriakezelés• Lefoglalás(C): malloc(int size):long

• Elengedés: mfree(long address)

• Meglehetősen gyakori művelet (átlag: 40% proc. idő!!)

• Megvalósítás: szabad memória (növekvő) láncolt listában

• Malloc: a szabadlistán megkeressük az első megfelelő méretű szegmenst

• Mfree: a szabadlistába beszúrjuk az új szabad szegmenst

• (+ esetleg egyesítjük a mellette levővel, ha van ilyen)

• Multi-tasking/Multi-threading környezetekben (ha a heap közös/globális erőforrás), ronthatja a hatékonyságot

- Lefoglalási stratégiák: (malloc(1000))- cím szerinti sorrendben- az első megfelelőt keressük- a legjobban illeszkedőt keressük

- Problémák:- feltöredezés: bár még van hely, egy darabban

mégsincs elegendő- lassú: régóta futó alkalmazások esetén végig kell

futni a láncon, az pedig hosszú

- Felszabadítási stratégiák: (mfree)- megkeressük a közvetlen előtte ill. utána levő szabad

blokkot- megvizsgáljuk, hogy van-e illeszkedő szabad blokk- a szabad blokkokat egyesítjük

Szemétgyűjtés• Ötlet: elmozdítva a foglalt mezőket a

szabad mezők egyesíthetők

• Probléma: ellenőrizhetetlen mutatók

• Megoldás lényege: ellenőrizhetetlen mutatók ellenőrzése

• Pl: mutatótáblával

Ellenőrizhető mutatók

Ellenőrizhetetlen mutatók

Programfutás/memóriahasználat lokalitása

• Mennyi a valószínűsége annak, hogy két egymás utáni utasítás/memória adathozzáférés egymástól ennyi távolságban van…

• Jó lokalitás: hegyes (pl. program), rossz lokalitás (lapos)

0

10

20

30

40

50

60

70

80

90

100

ProgramAdat

• Többféle lefoglalási stratégia (kicsi, közepes, nagy szegmensekre)

• Idő-Tárhely (bizonytalansági reláció)

• Fix méretű szegmensek 256byte alatt (a legelső elemet vehetjük) / (a leggyakoribb foglalási méret <256!) / fix méretű struktúrákhoz

• Minden mérethez külön szabad lánc!

• Középméret (256-64kB)

• Virtuális memória / swapping szabadlista végigjárása

• Laptáblában a szabad memória méretét is tároljuk, laponként külön szabad lista csak 1 lapon belül keresünk szabad helyet egymás utáni foglalások lehetőleg ugyanarra a lapra esnek jobb a program lokalitása

• Nagy szegmensekre (ami nagyobb, mint a lapméret) normál foglalási algoritmus

MicroQuill:SmartHeap Dinamikus memóriakezelés

Dinamikus memóriakezelés tipikus hibái• Lefoglalt terület előtti vagy mögötti tilos területre írás (pl. string összefűzéskor)• Felszabadított terület írása/olvasása

mfree(pointer);mfree(pointer); //dupla felszabadítás

pointer=malloc(1000);Pointer=0; //memória-lyuk (leaking memory, Speicherloch)

Dinamikus memóriakezelés referenciaszámlálóval (pl. Java, VB)

Employee munkas = new Employee;

Employee dolgozo = munkas;

dolgozo = new Employee;

munkas = new Employee;

Employee1munkas

Employee2munkasdolgozo

Employee1dolgozomunkas Employee1

Employee0dolgozomunkas Employee1

Employee1