V. Adatszerkezetek, kollekciók 20. Klasszikus adatszerkezetek 21. Kollekció keretrendszer

V. Adatszerkezetek, kollekciók 20. Klasszikus adatszerkezetek 1. Az adatszerkezetek rendszerezése 2. Absztrakt tárolók 3. Tömb 4. Tábla 5. Verem 6. Sor 7. Fa 8. Irányított gráf, hálózat

Adatszerkezetek Adatmodell, eljárásmodell Adatszerkezet: egymással kapcsolatban álló adatok, objektumok összessége Elemei: csomóponti adatok, kapcsolatok Reprezentáció: gráffal csomóponti adatok: gráf csúcsai kapcsolatok: gráf élei Műveletek Konstrukciós műveletek Szelekciós műveletek

Példa: Hallgató objektumok összekapcsolása Boldog Boglárka Fekete Farkas Madár Aladár Boldog Boglárka Fekete Farkas Madár Aladár

Adatszerkezetek rendszerezése az elemek közötti kapcsolatok alapján Asszociatív Szekvenciális Hierarchikus Hálós Tömb Tábla Verem Sor Fa Ir. gráf Hálózat

Asszociatív adatszerkezet Asszociatív csoport Szekvenciális adatszerkezet

Hierachikus adatszerkezet Hálós adatszerkezet

Absztrakt tárolók Egydimenziós tömb Címezhető tárolókon absztrakt tárolási lehetőségek: Egydimenziós tömb Láncolt lista Absztrakt tároló helye: bármilyen címezhető hardver elem (pl. memória, lemezes egység) Az adatszerkezetek leképezhetők absztrakt tárolókra Egydimenziós tömb A tárolt objektumok közvetlenül egymás után helyez-kednek el, ugyanolyan távolságra egymástól Elemei indexeléssel közvetlenül címezhetők

Egyirányú nyíltvégű láncolt lista Elemei mutatókon keresztül össze vannak kapcsolva A listát az első listaelem mutatója (L) meghatározza Egy listaelem: adat + mutató 1 2 3 n ... L Adat Mutató Végjel Egyirányú nyíltvégű láncolt lista

Láncolt lista (folyt.) Elemei fizikailag bárhol elhelyezkedhetnek Előnye: beszúrás, törlés egyszerű Változatai: Nyíltvégű lista Cirkuláris (zárt) lista Rendezett lista Kétirányú (szimmetrikus) lista Fejelt lista Multilista (többszörös lista)

Tömb Általános tömb Asszociatív adatszerkezet Fajtái: Általános tömb Ritka mátrix Általános tömb Elemei indexeléssel közvetlenül elérhetők Hátrányai méretét előre meg kell adni indexhatárok dimenziónként kötöttek Tárolás: egydimenziós tömbben (az adatszerkezet általában maga a tároló)

Ritka mátrix Olyan többdimenziós tömb, ahol a tömb nagy része kihasználatlan Tárolás: láncolt listában

Tábla Asszociatív adatszerkezet Egy elem: egyedi kulcs + adat Tárolás: egydimenziós tömbben vagy láncolt listában Kérem azt az adatot, melynek kulcsa ...

Táblák osztályzása (tárolási mód alapján) Soros tábla Önátrendező tábla Rendezett tábla Hasító (kulcstranszformációs) tábla Hasítótábla (hash table) Hasítófüggvény (kulcstranszformációs függvény): kulcs  elem fizikai címe Hasonlítgatások száma minimális Legjobb táblaszervezési mód: egyértelmű leképezés a kulcsok és a fizikai címek között Szinonímák azonos címre leképezett kulcsok megvalósítás: láncolt listával

Hasítótábla egyértelmű leképezéssel Kulcs Hasítófüggvény Hasítótábla szinonímákkal Kulcs Hasító(Kulcs) Kulcs+Adat

Verem (stack) Szekvenciális adatszerkezet LIFO (Last In First Out) szerkezet Műveletei: PUSH, POP, TOP PUSH POP Legfiatalabb Legidősebb

Verem (folyt.) Tárolás: általában egydimenziós tömbben Alkalmazásai: Elemek sorrendjének megfordítása Visszatérési utak megjegyzése Memóriaverem: metódusok hívásakor a visszatérési címek és lokális változók tárolása

Sor (queue) Szekvenciális adatszerkezet FIFO (First In First Out) adatszerkezet Műveletei: PUT, GET, FIRST ... Első Legidősebb GET PUT Utolsó Legfiatalabb

Sor (folyt.) Tárolás: egydimenziós tömbben vagy láncolt listában Ciklikus tárolás egydimenziós tömbben: Alkalmazása: elemek feldolgozása érkezési sorrendben Például: pufferek (billentyűzetpuffer, nyomtatópuffer) Első 1. 2. 3. 4. 5. ... Max — 34 66 999 7 2 Utolsó

Fa Hierarchikus adatszerkezet Elemei: csomópontok és egyirányú kapcsolatok Rekurzív definíció, rekurzív algoritmusok e f a b g Gyökér Elágazás (3 fokú) Levél (0 fokú) 1. szint 3. szint Részfa c d 0. szint

Fával kapcsolatos fogalmak Kezdőpont, végpont Gyökér, elágazás, levél Csomópont foka, fa foka Szülő, gyerek Szintszám Fa magassága Rendezett fa Kiegyensúlyozott fa e f a b g c d

Fa bejárása Gyökérkezdő (preorder) a b c d g e f Gyökérvégző (postorder) b c a b d e f c a b g d e f c a e f a b g c d

Bináris fa Bejárása Gyökeréből legfeljebb két részfa ágazik: baloldali és jobboldali részfa Bejárása Gyökérkezdő (preorder) a b d c e g h i j f Gyökérközepű (inorder) d b a g e i h j c f Gyökérvégző (postorder) d b g i j h e f c a a d c b f e h g j i

Rendezett bináris fa Keresési fa (kereső fa, rendező fa) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Keresési fa (kereső fa, rendező fa) A baloldali részfa összes eleme kisebb, mint a szülő A jobboldali részfa összes eleme nagyobb, mint a szülő Egy n szintű fa elemeinek száma maximum 2n+1-1 Egy elemet maximum n+1 lépésben megtalálunk

Kiegyensúlyozott bináris fa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Elemek beszúrási sorrendje: 8, 4, 12, 10, 9, 14, 2, 3, 6, 1, 15, 5, 7, 13, 11

Degenerált bináris fa Elemek beszúrási sorrendje: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Elemek beszúrási sorrendje: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

Fa tárolása multilistában d a b c f e g

Hálós adatszerkezetek Irányított gráf b e a c d Hálózat 1 9 b d a c 4 7 2

V. Adatszerkezetek, kollekciók 21. Kollekció keretrendszer 1. A kollekció keretrendszer felépítése 2. A Collection interfész és leszármazottai 3. A HashSet osztály – hasítási technika 4. A TreeSet osztály – Comparator 5. Iterátor 6. A List interfész implementációi 7. A Map és a SortedMap interfész 8. A Hashtable osztály 9. A TreeMap osztály

Kollekció keretrendszer (Collections Framework) Interfészeket és osztályokat definiál különböző konténerek hatékony létrehozása céljából Elemei: Interfészek kollekció térkép iterátor Implementációk (osztályok) Algoritmusok (Collections osztály)

Kollekció keretrendszer TreeSet «interfész» Collection Set SortedSet List HashSet Vector ArrayList LinkedList Stack Iterator ListIterator Collections Interfészek Algoritmusok TreeMap Map SortedMap Hashtable HashMap Osztályok Kollekció keretrendszer

A Collection interfész és leszármazottai TreeSet «interfész» Collection Set SortedSet HashSet List Vector ArrayList LinkedList Stack

Collection interfész (kollekció) Objektumokat tárol Van legalább két konstruktora: paraméter nélküli kollekcióval paraméterezett Nincs példányosítható implementációja a keretrendszerben Bejárás iterátorral «interfész» Collection size(): int isEmpty(): boolean contains(elem: Object): boolean containsAll(c: Collection): boolean add(elem: Object): boolean addAll(c: Collection): boolean remove(elem: Object): boolean removeAll(c: Collection): boolean retainAll(c: Collection): boolean clear() equals(o: Object): boolean toArray():Object[] toArray(Object a[]):Object[] iterator(): Iterator

Set interfész (halmaz) Elemei egyediek nem rendezettek Implementációja: HashSet SortedSet interfész (rendezett halmaz) rendezettek Implementációja: TreeSet «interfész» Set SortedSet first(): Object last(): Object comparator(): Comparator headSet(toElement: Object): SortedSet tailSet(fromElement: Object): SortedSet subSet(fromElement: Object, toElement: Object): SortedSet

List interfész (lista) Elemei nem egyediek egy meghatározott sorrendben követik egymást indexelhetők Implementációi: ArrayList, Vector, LinkedList, Stack «interfész» List get(index: int): Object set(index: int, elem: Object): Object add(index: int, elem: Object) addAll(index: int, c: Collection): boolean remove(index: int): Object indexOf(o: Object): int lastIndexOf(o: Object): int listIterator():ListIterator listIterator(index: int): ListIterator

A HashSet osztály – hasítási technika Csoportindex 9 ... 7 6 2 1 a t H e o n "Hottentotta" karaktereinek hasítása Character kar = new Character('H'); kar.hashCode() == 72 csoportindex == kar.hashCode()%10 == 2 Kapacitás: 10 Elemszám: 6 Telítettség: 0.6 Telítettségi küszöb: 0.9 Hasítókód (hashCode, hasítófüggvény) Kapacitás: hasítással előállított csoportok száma Hasítókód normalizálása: csoportindex = obj.hashCode() % kapacitás Telítettség: elemszám / kapacitás Telítettségi küszöb

Hasítófüggvény készítésének szabályai Egy objektumnak mindig ugyanazt a hasítókódot kell generálnia o1.equals(o2)  hashCode(o1)==hashCode(o2) Egyenletes eloszlásra törekvés Hashset-be beteendő objektumok osztályában (szükség esetén) átírandó metódusok: hashCode equals

HashSet osztály Konstruktorok, metódusok Halmaz (Set interfész implementációja) Megvalósítás: hasítási technikával (hasítótáblával) Gyors műveletek, megjósolhatatlan bejárás Alkalmazás Egyedi, rendezetlen elemeket tartalmazó kollekció Nagy elemszám esetén nagyon hatékony! Konstruktorok, metódusok HashSet() HashSet(int initialCapacity) HashSet(int initialCapacity, float loadFactor) HashSet(Collection c) String toString()  [elem,elem,...]

Feladat – HashSetBetuk Kérjünk be konzolról egy karakterláncot! Írjuk ki a benne szereplő betűket ábécérendben (mindegyiket csak egy-szer)! Együttműködési diagram HashSetBetuk betuk: HashSet :Character szoveg:String add() contains()? charAt()

… public class HashSetBetuk { public static void main(String[] args) { HashSet betuk = new HashSet(); String szoveg = Console.readLine("Szöveg= "); for (int i=0; i<szoveg.length(); i++) betuk.add(new Character(szoveg.charAt(i))); System.out.println(betuk); for (char c=0; c<Character.MAX_VALUE; c++) if (betuk.contains(new Character(c))) System.out.print(c); System.out.println(); }

Feladat – HashTorpe Az emberre jellemző a neve és a magassága: e két adattal inicializáljuk őket. Tartsunk nyilván embereket, de két ugyanolyan nevű ember nem szerepelhet a nyil- vántartásban! Vegyük nyilvántartásba a hét törpét! Végül listázzuk ki a felvitt emberek adatait (név, magasság) egymás után!

A 26 felé hasított hét törpe K M S T V ... 122 Hapci 126 Tudor 146 Szundi 128 Vidor 104 Szende 112 Morgó Kuka

… class Ember { private String nev; private int magassag; public Ember(String nev, int magassag) { this.nev = nev; this.magassag = magassag; } public String getNev() { return nev; } public int getMagassag() { return magassag; }

public int hashCode() { if (nev.length() == 0) return 0; return Character.toUpperCase(nev.charAt(0)); } public boolean equals(Object obj) { if ((obj != null) && (obj instanceof Ember)) return nev.equals(((Ember)obj).getNev()); return false;

public String toString() { return Format.left(nev,10) + Format.right(magassag,3); } } // Ember public class HashTorpe { public static void main(String[] args) { HashSet torpek = new HashSet(26); torpek.add(new Ember("Morgó",112)); torpek.add(new Ember("Szende",104)); torpek.add(new Ember("Hapci",122));

torpek.add(new Ember("Kuka",126)); torpek.add(new Ember("Tudor",126)); torpek.add(new Ember("Szundi",146)); torpek.add(new Ember("Vidor",128)); torpek.add(new Ember("Hapci",100)); // Hatástalan torpek.add(new Ember("Tudor",128)); // Hatástalan System.out.println("Törpék száma: "+torpek.size()); System.out.println(torpek); } } // HashTorpe

A TreeSet osztály - Comparator Rendezett halmaz (SortedSet interfész impl.) Megvalósítás: kiegyensúlyozott fával Halmazba tett objektumok összehasonlíthatóak Két eset: Osztályuk implementálja a Comparable interfészt (természetes össszehasonlítás) TreeSet konstruktorában megadunk egy összehasonlító (comparator) objektumot Alkalmazás Egyedi, rendezett elemeket tartalmazó kollekció Nagy elemszámnál a keresés nagyon hatékony!

Konstruktorok, metódusok TreeSet() TreeSet(Collection c) TreeSet(SortedSet s) TreeSet(Comparator comp) Comparator comparator() Comparator interfész Céljai: más rendezettség megadása (a természetes rendezettségen túl) rendezettség megadása kívülről Implementációjának példánya egy összehasonlító objektum, mely átadható a TreeSet konstruktorának Metódusa public int compare(Object a, Object b)

Feladat – TreeSetNevek Tegyünk be keresztneveket egy konténerbe! Ne vigyünk be egyforma neveket! Írjuk ki a neveket először névsor szerint, azután névhosszúság szerinti rendezettségben! import java.util.*; public class TreeSetNevek { public static void main(String[] args) { TreeSet nevsor = new TreeSet(); nevsor.add("Soma"); nevsor.add("Jeremiás"); nevsor.add("Janka");

// Kiírás névsorban: System.out.println(nevsor); TreeSet nevek = new TreeSet(new Comparator() { public int compare(Object a, Object b) { return ((String)a).length() - ((String)b).length(); } } ); nevek.addAll(nevsor); System.out.println(nevek);

Iterátor Iterator interfész Iterátor: objektum, mellyel egy kollekció bejárható Egy kollekcióhoz több iterátor is kapcsolható Az iterátor objektum felelős a kollekció helyes bejárásáért Egy kollekció egy iterátorral csak egyszer járható be Iterátor elkérése a coll kollekciótól: Iterator iter = coll.iterator(); Az iterátornak implementálnia kell az Iterator interfészt Iterator interfész boolean hasNext() Object next() void remove()

Példa: tetszőleges kollekció bejárása iterátorral Collection c = new ...; ... Iterator iter = c.iterator(); while (iter.hasNext()) { Object current = iter.next(); // (Objektum osztálya)current.üzenet; } c:HashSet iter hasNext() next() remove() iterator()

Feladat – Országok Tegyünk be országokat egy HashSet kollekcióba! Listázzuk ki őket először a HashSet-be beépített módon, majd egy iterátorobjektum segítségével! import java.util.*; public class Orszagok { public static void main(String[] args) { String[] nevek = { "USA","Lengyelország","Nepál", "Magyarország","Kuba"};

HashSet orszagok = new HashSet(); for (int i = 0; i < nevek.length; i++) orszagok.add(nevek[i]); System.out.println(orszagok); System.out.println("Országok:"); Iterator iter = orszagok.iterator(); while (iter.hasNext()) System.out.println(iter.next()); }

A List interfész implementációi Vector ArrayList LinkedList Stack «interfész» Iterator ListIterator

ArrayList Vector LinkedList Stack Megvalósítás: újraméretezhető tömbbel Vector Metódusai szinkronizáltak LinkedList Megvalósítás: kétirányú láncolt listával Stack Speciális vektor Verem adatszerkezetet valósítja meg

ListIterator interfész Iterator interfész leszármazottja Segítségével a kollekció mindkét irányban bejárható Listaiterátor elkérése a lista listától: ListIterator iter = lista.listIterator(); Metódusok boolean hasNext() boolean hasPrevious() Object next() int nextIndex() Object previous() int previousIndex() void add(Object obj) void remove()

Feladat – LinkedListTest Vigyünk fel szövegeket egy láncolt listába! Ezután listázzuk ki a szövegeket a felvitel sorrendjében! visszafelé, s közben töröljük ki az A betűvel kezdődő szövegeket! s megint elölről! Végül írjuk ki az utolsó szöveget! public class LinkedListTest { public static void main(String[] args) { LinkedList lista = new LinkedList(); lista.add("Gergő"); lista.add("Anna"); lista.add("Matyi");

System.out.println("Listázás előre:"); ListIterator iter = lista.listIterator(); while (iter.hasNext()) System.out.println(iter.next()); System.out.println("\nListázás visszafelé, közben az "+ "A betűsök törlése:"); while (iter.hasPrevious()) { String str = (String)iter.previous(); System.out.println(str); if (str.startsWith("A")) iter.remove(); }

System.out.println("\nListázás előre: "); iter = lista.listIterator(); while (iter.hasNext()) { System.out.println(iter.next()); } System.out.println("\nUtolsó elem: " + lista.get(lista.size()-1)); } // main

A Map és a SortedMap interfész size(): int isEmpty(): boolean remove(key: Object) clear() get(key: Object): Object put(key: Object, value: Object): Object putAll(entries: Map) containsKey(key: Object): boolean containsValue(value: Object): boolean keySet(): Set values(): Collection SortedMap comparator():Comparator firstKey(): Object lastKey(): Object TreeMap HashMap Hashtable A Map és a SortedMap interfész Térkép Kulcs-érték párokat tárol

A Hashtable osztály Konstruktorok Map interfész implementációja Rendezetlen térkép, mely kulcs-érték párokat tárol Megvalósítás: hasítási technikával (hasítótáblával) Konstruktorok Hashtable() Hashtable(Map entries) Hashtable(int initialCapacity) Hashtable(int initialCapacity, float loadFactor)

Feladat – HashtableAuto Vigyünk fel autók adatait! A rendszámot és a hozzá tartozó autómárkát egy-egy szövegben tároljuk. A rendszám egyedi adat. Ezután Írjuk ki az autók adatait a Hashtable.toString által felkínált formában! Írjuk ki külön a kulcsokat, majd külön az értékeket (autómárkákat)! Keressük meg a megadott rendszámú autót! Írjuk ki az autó márkáját. Cseréljünk ki egy megadott rendszámú autó márkáját! Írjuk ki egyenként, sorszámozva az autók adatait!

import java.util.*; public class HashtableAuto { public static void main(String[] args) { Hashtable autok = new Hashtable(); autok.put("BIT-442", "Piros Romeo"); autok.put("SIT-999", "Fehér Merci"); autok.put("CAR-152", "Zöld Mazda"); // A tejles térkép összes bejegyzésének kiírása: System.out.println(autok);

// Kulcsok, értékek kiírása: System.out.println("Kulcsok: "+autok.keySet()); System.out.println("Értékek: "+autok.values()); // Adott kulcsú bejegyzés keresése: String rendszam = "CAR-152"; if (autok.containsKey(rendszam)) System.out.println(rendszam+" megvan, "+ autok.get(rendszam)); // Csere: autok.put(rendszam, "Fekete Trabant");

// Kiírás iterátorral: Iterator iter = autok.keySet().iterator(); int n = 0; while (iter.hasNext()) { Object key = iter.next(); System.out.println(++n + ". " + autok.get(key)); }

A TreeMap osztály Konstruktorok SortedMap interfész implementációja Rendezett kulcsokat tartalmazó térkép Megvalósítás: kiegyensúlyozott fával (a kulcsok összehasonlíthatók) Konstruktorok TreeMap() TreeMap(Comparator c) TreeMap(Map m) TreeMap(SortedMap m)

Feladat – TreeMapUser Egy internetszolgáltató tárolni akarja a felhasználók adatait: a felhasználó nevét, jelszavát és a legutóbbi látogatásának időpontját. A használati esetek a következők: Új felhasználó felvitele Felhasználók számának kiírása Felhasználónevek listázása ábécé szerint A jelszó és a legutóbbi látogatás kiírása a felhasználónév alapján A használati eseteket hajtsuk végre egymás után!

import java.util.*; import java.text.DateFormat; class User { private String userName; // felhasználónév private String password; // jelszó private Date lastVisited; // a legutóbbi belépés időpontja public User(String userName, String password) { this.userName = userName; this.password = password; this.lastVisited = new Date(); // mai dátum }

public User(String userName) { this(userName,""); } public String getUserName() { return userName; } public String getPassword() { return password; } public String getLastVisited() { return DateFormat.getDateTimeInstance(). format(lastVisited);

public void setLastVisited() { lastVisited = new Date(); } public String toString() { return userName+", "+password+", "+getLastVisited(); } // class User

public class TreeMapUser { public static void main(String[] args) { TreeMap users = new TreeMap(); users.put("Nagybuta", new User("NagyButa", "netuddmeg")); users.put("Bendegúz", new User("Bendegúz", "anyukád")); users.put("Erzsébet", new User("Erzsébet", "kimást")); users.put("Naspolya", new User("Naspolya", "eddmeg"));

System.out.println("Felhasználók száma: " +users.size()); // Felhasználónevek listázása: System.out.println("\nFelhasználónevek:"); Iterator iter = users.keySet().iterator(); while (iter.hasNext()) System.out.println(iter.next()); // Felhasználók adatai: System.out.println("\nFelhasználók adatai:"); Collection values = users.values(); iter = values.iterator();

// Megadott felhasználó jelszavának kiírása: String userName = "Bendegúz"; User user = (User)users.get(userName); if (user == null) System.out.println("\nNincs " + userName); else { System.out.println("\n" + userName + " jelszava: " + user.getPassword() + ", legutóbbi látogatása: " + user.getLastVisited()); }