Spezielle Datenstrukturen

Transkript

1 Spezielle Datenstrukturen Stapel (Stack) Beschreibung der Datenstruktur Stapel Ein Stapel (engl. Stack), auch Stapelspeicher oder Keller bzw. Kellerspeicher genannt, ist eine Datenstruktur, in der Daten nach dem LIFO-Prinzip verwaltet werden. LIFO steht für Last In First Out und bedeutet: Was zuletzt auf den Stack kommt (Last In), verlässt den Stack als Erstes (First Out). Stellen Sie sich einen Spielkartenstapel vor. Wenn Sie eine Karte ziehen möchten, dürfen Sie nur die oberste Karte vom Stapel nehmen. Wollen Sie eine Karte ablegen, wird sie stets oben auf den Stapel gelegt. Die zuletzt auf den Stapel gelegte Karte (Last in) muss als Erste vom Stapel genommen werden (First Out). Stack mit n Elementen Operationen für einen Stapel Neues Element hinzufügen push: Das neue Element wird oben in den Stack eingefügt. Der Stapelzeiger auf das oberste Element des Stapels wird entsprechend angepasst. Element entfernen pop: Das oberste Element wird vom Stack gelöscht. Der Stapelzeiger auf das oberste Element des Stacks wird entsprechend angepasst. Prüfen, ob Stack leer ist empty: Ein Stapelunterlauf tritt ein, wenn versucht wird, aus einem Stack zu lesen, obwohl dieser leer ist. Deshalb sollte vor dem Löschen eines Elements überprüft werden, ob der Stack noch Elemente besitzt. Für Stacks, die eine feste maximale Größe besitzen, ist auch das Gegenteil möglich, der Stapelüberlauf. Push Element in einen Stack einfügen Pop Element von einem Stack entfernen Java stellt die Datenstruktur Stapel mit der Klasse Stack <E> zur Verfügung, wobei <E> Platzhalter für den Datentyp des Objekts ist. HERDT-Verlag 1

2 Operationen für einen Stapel s in Java s.empty() s.peek() s.pop() s.push(item) s.search(item) Liefert als Ergebnis true, falls der Stack leer ist, sonst false Liefert das oberste Element des Stacks, ohne das Element zu entfernen, oder eine Fehlermeldung, falls der Stack leer ist Liefert das oberste Element des Stacks und löscht es vom Stack oder liefert eine Fehlermeldung, falls der Stack leer ist Legt das übergebene Element (item) auf dem Stack ab und liefert dieses Element auch als Ergebnis Durchsucht die Elemente des Stacks von Anfang (Top) an und übergibt die erste gefundene Position, an der das Element mit dem übergebenen Element (item) übereinstimmt. Ein Ergebnis von -1 bedeutet, dass das Element nicht im Stack vorhanden ist. Beispiel für die Anwendung eines Stapels in Java: TestPalindrome.java Mithilfe eines Stacks soll herausgefunden werden, ob Wörter (bzw. Sätze) Palindrome sind, also Wörter, die vorwärts und rückwärts gelesen gleich sind, z. B. RADAR. Die zu prüfende Zeichenfolge wird zeichenweise in einem Stack abgelegt und danach zeichenweise wieder ausgelesen. Das Resultat ist automatisch die Zeichenfolge in umgekehrter Reihenfolge. Um herauszufinden, ob ein Palindrom vorliegt, wird die zu prüfende Zeichenkette mit der ausgelesenen Zeichenkette verglichen. import java.util.*; public class TestPalindrome... Stack<Character> palindrome = new Stack<Character>(); String original = "reliefpfeiler"; //Testwort String reverse = ""; for (int i = 0; i < original.length(); i++) palindrome.push(character.valueof(original.charat(i))); if (palindrome.empty()) System.out.println("Der Stapel war leer."); else 2 HERDT-Verlag

3 ... for (int i = 0; i < original.length(); i++) reverse = reverse + palindrome.pop(); if (original.equals(reverse)) System.out.println(original+" ist ein Palindrom."); else System.out.println(original+" ist kein Palindrom."); In Java stehen viele fertige Klassen für die Anwendung in Programmen zur Verfügung. Standard- Klassen, z. B. für die Ausgabe, stehen automatisch in den Programmen zur Verfügung, andere müssen explizit eingebunden werden. Mit der import-anweisung wird dem Programm z. B. mitgeteilt, wo die benötigte Klasse Stack<E> zu finden ist. Ein neuer Stack vom Typ Character wird erstellt. Da die Klasse Stack<E> für E einen sogenannten Objektdatentyp verlangt, wird anstelle des Datentyps char der Objektdatentyp Character verwendet, der den Wert eines Zeichens in ein Objekt umwandelt. Zwei Zeichenketten (Datentyp String) werden angelegt. Die Zeichenkette original enthält den zu vergleichenden Begriff; in der Zeichenkette reverse soll die rückwärts gelesene Zeichenkette gespeichert werden. In der ersten Schleife werden die einzelnen Zeichen der Zeichenkette der Reihe nach in den Stack geschrieben (push). Die Anzahl der Schleifendurchläufe entspricht der Anzahl der Zeichen der Zeichenkette, die mit original.length()ermittelt wird. Mit original.charat(i)wird das Zeichen an der Stelle i in der Zeichenkette ermittelt. Character.valueOf(c) liefert für das Zeichen c das entsprechende Zeichenobjekt, danach wird das Zeichenobjekt x mit palindrome.push(x)auf den Stack gelegt. Falls der Stack leer ist, wird eine Meldung ausgegeben. Die zweite Schleife dient dazu, die einzelnen Zeichen wieder aus dem Stack zu lesen und zu entfernen (pop). Jedes gelesene Zeichen wird an die Zeichenkette reverse angehängt. Da das erste ausgelesene Zeichen das letzte Zeichen der Originalzeichenkette ist, kehrt sich die Reihenfolge der Buchstaben um. Entspricht das Originalwort (Variable original) dem Wort in umgekehrter Richtung (Variable reverse), handelt es sich um ein Palindrom. Je nach Ergebnis des Vergleichs erfolgt eine entsprechende Ausgabe. Wo werden Stacks angewendet? Stacks werden beispielsweise zur Programmierung folgender Anwendungen eingesetzt: Auswerten von geklammerten Ausdrücken Ausführen rekursiver Prozeduren Durchsuchen von Baumstrukturen (traversieren) HERDT-Verlag 3

4 8.2 Schlangen (Queue) Beschreibung der Datenstruktur Schlange Schlangen (engl. Queue), sind wie Stapel Datenstrukturen mit eingeschränkten Zugriffsmöglichkeiten. Im Gegensatz zu Stacks arbeiten sie jedoch nach dem FIFO-Prinzip (First In, First Out), das heißt, dass das Element, welches als Erstes in die Schlange eingefügt wurde, sich somit am Kopf der Schlange befindet, auch als Erstes wieder ausgelesen wird. Neue Elemente werden stets am Ende der Queue angefügt. Das ist der gleiche Vorgang wie bei einer Warteschlange von Autos an einer roten Ampel. Hinzukommende Fahrzeuge reihen sich hinten ein, das Fahrzeug am Anfang der Schlange fährt als Erstes weiter. Bei einer Queue werden nur das erste und das letzte Element betrachtet. Die Elemente werden genau in der Reihenfolge aus der Queue ausgelesen, in der sie eingefügt wurden. Schlange mit n Elementen Operationen für eine Queue Neues Element hinzufügen enqueue: Das neue Element wird am Ende der Queue eingefügt. Der Zeiger auf das Ende der Queue wird entsprechend angepasst. Element entfernen dequeue: Das erste Element wird aus der Queue gelöscht. Der Zeiger auf den Kopf der Queue wird entsprechend angepasst. Enqueue ein Element einer Queue hinzufügen Dequeue ein Element aus einer Queue löschen Wo werden Queues angewendet? Queues werden beispielsweise zur Programmierung folgender Anwendungen eingesetzt: Verwaltung von sequenziell abzuarbeitenden Aufgaben (Druckaufträge, Prozessverwaltung, Tastatureingaben usw.) Speicherverwaltung (Paging) 4 HERDT-Verlag

5 8.3 Listen (List) Einführung in die Datenstruktur Liste Eine Liste (engl. List) ist eine Datenstruktur, bei der die Elemente, auch Knoten (engl. node) genannt, durch Zeiger verkettet sind. Die Elemente der List haben alle denselben Datentyp. Jedes Element enthält einen Datenteil zum Speichern der eigentlichen Informationen und einen Adressteil, der einen Zeiger auf seinen Nachfolger, das nächste Element in der List, enthält. Eine Ausnahme bildet das letzte Element der Liste. Da es keinen Nachfolger hat, verweist sein Zeiger auf NULL. Eine List ist eine dynamische Datenstruktur, da sie durch Einfügen von Elementen wächst und durch Löschen von Elementen schrumpft. Für die Verwaltung der List wird ein Zeiger auf den Anfang der List benötigt. Arten von Listen Bei einfach verketteten Listen enthalten die Listenelemente einen Zeiger auf den jeweiligen Nachfolger. In doppelt verketteten Listen wird im Listenelement zusätzlich zum Zeiger auf den Nachfolger ein Zeiger auf den Vorgänger gespeichert. 8.4 Einfach verkettete Listen Aufbau einer einfach verketteten Liste Bei einfach verketteten Listen besitzen die Knoten einen Zeiger, der auf den Nachfolger des Elements verweist. Im Kopfteil (Header) der List wird ein Laufzeiger cursor abgelegt, der sich frei durch die List bewegen lässt. Die Angaben zu den Nummern von Elementen in den Schrittfolgen beziehen sich auf die jeweilige Beispielabbildung. HERDT-Verlag 5

6 Einen Knoten hinzufügen (insert) Datenteil Adressteil mit Zeiger auf den Nachfolger Setzen Sie den Laufzeiger auf den 2. Knoten. Nach dem 2. Knoten soll das neue Element eingefügt werden. Speichern Sie den Zeiger auf den Nachfolger des 2. Knotens in einer Hilfsvariablen. Erstellen Sie den neuen Knoten. Im Beispiel wird der neue Knoten zum 3. Knoten. Speichern Sie die Adresse des neuen Knotens im Zeiger auf den Nachfolger des 2. Knotens. Weisen Sie den zwischengespeicherten Zeiger dem Zeiger auf den Nachfolger des neuen Knotens zu. Setzen Sie den Laufzeiger auf die Position des eingefügten Knotens und füllen Sie den Datenteil des neuen Knotens. Einen Knoten löschen (delete) Setzen Sie den Laufzeiger auf den zu löschenden Knoten (im Beispiel 2. Knoten). Speichern Sie den Zeiger auf den Nachfolger des zu löschenden Knotens in einer Hilfsvariablen. Setzen Sie den Laufzeiger auf den Vorgänger des zu löschenden Knotens (TOP-Knoten). Weisen Sie dem Zeiger auf den Nachfolger des aktuellen Knotens (TOP-Knoten) den zwischengespeicherten Zeiger zu. Der zweite Knoten der ursprünglichen Liste wird gelöscht. 6 HERDT-Verlag

7 Beispiel für eine einfach verkettete Liste: SingleLinkedList.java Im folgenden Beispiel wird eine einfach verkettete List realisiert. Die Knoten können hier im Datenteil Informationen vom Datentyp String speichern und im Adressteil einen Verweis auf den nächsten Knoten. Dazu wird die Klasse Node definiert. class Node String data; Node next; Node (String data) this.data = data; Der Datentyp Node für die Knoten wird definiert., Der Knoten besteht aus einem Datenteil data und einem Adressteil next für den Verweis auf den nächsten Knoten oder null, falls kein nächster Knoten existiert. Der Konstruktor Node (vgl. Abschnitt 10.8) zur Erzeugung eines neuen Knotens wird erstellt. Die Liste wird über die Klasse SingleLinkedList bereit gestellt. Die Liste enthält einen Verweis auf den Anfang der Liste und verfügt über Funktionen zum Einfügen und Löschen eines Knotens sowie zum Drucken der Liste. public class SingleLinkedList Node head = null; public void insertnode(string data)... public void deletenode(string data)... public void printlist()... Im Beispiel werden Knoten nur am Anfang der Liste eingefügt: public void insertnode(string data) Node newnode = new Node(data); newnode.next = head; head = newnode; Der neue Knoten newnode wird mit dem gewünschten Datenteil erzeugt. Da der neue Knoten am Anfang der Liste eingefügt wird, wird der bisherige Listenanfang als Verweis auf den nächsten Knoten im neuen Knoten eingefügt. Der neue Knoten wird zum Listenanfang. HERDT-Verlag 7

8 Knoten mit bestimmtem Inhalt im Datenteil werden gesucht und gelöscht: public void deletenode(string data) Node cursor = head; Node prev = null; while (cursor!= null && cursor.data!= data) prev = cursor; cursor = cursor.next; if (cursor!= null) if (cursor == head) head = cursor.next; else prev.next = cursor.next;, cursor und prev werden benötigt, um den zu löschenden Knoten zu suchen und um sich dessen Vorgängerknoten zu merken. Solange die Liste noch nicht zu Ende ist und gleichzeitig der Datenteil des aktuellen Knotens mit dem Datenteil des zu löschenden Knotens nicht übereinstimmt, wird der aktuelle Knoten gespeichert und der nächste Knoten zum aktuellen Knoten. Falls ein übereinstimmender Datenteil gefunden wurde, die List also noch nicht zu Ende ist, wird geprüft, wo sich innerhalb der List der zu löschende Knoten befindet, und abhängig davon der Knoten gelöscht. Knoten mit bestimmtem Inhalt im Datenteil werden gesucht und ausgedruckt: public void printlist() Node cursor = head; int i = 0; if (cursor == null) System.out.println("Liste ist leer"); else if (cursor.next == null) System.out.println("Einziger Knoten der Liste - Inhalt : "+cursor.data); else while (cursor.next!= null) i++; System.out.println(i+". Knoten der Liste. Inhalt : "+cursor.data); cursor = cursor.next; System.out.println((i+1)+". Knoten der Liste. Inhalt : "+cursor.data); 8 HERDT-Verlag

9 Falls die List leer ist, erfolgt eine entsprechende Meldung. Enthält die List nur einen Knoten, wird dessen Datenteil ausgedruckt. Enthält die List mehr als einen Knoten, werden alle Knoten durchlaufen und der jeweilige Datenteil ausgedruckt. Der Programmcode zum Anwenden der einfach verketteten List steht in UseSingleLinkedList.java... SingleLinkedList mylist = new SingleLinkedList(); mylist.insertnode("london",1); mylist.insertnode("paris",2); mylist.insertnode("wien",3); mylist.deletenode(2); mylist.insertnode("berlin",2); mylist.insertnode("rom",3); mylist.insertnode("dublin",4); mylist.printlist();... Definition und Erzeugung einer einfach verketteten Liste Fügt ein Element in die Liste ein Löscht ein Element aus der Liste Druckt die Informationen der Elemente der Liste aus 1. Knoten der Liste. Inhalt : Dublin 2. Knoten der Liste. Inhalt : Rom 3. Knoten der Liste. Inhalt : Berlin 4. Knoten der Liste. Inhalt : Wien 5. Knoten der Liste. Inhalt : London Die Ausgabe des Programms Vorteile bei der Verwendung von einfach verketteten Listen Die Anzahl der Elemente ist nur durch den verfügbaren Speicherplatz begrenzt. Die List kann dynamisch erweitert bzw. verkleinert werden. Der Zugriff kann auf jedes Element zum Einfügen, Löschen oder Lesen erfolgen. Nachteile bei der Verwendung von einfach verketteten Listen Ein Zugriff auf den Vorgänger eines Elementes ist nur durch ein erneutes Durchlaufen der List von vorn möglich. Da das Durchlaufen der List nur über die Nachfolger erfolgt und nur in eine Richtung möglich ist, vom Anfang der List aus, ist das Verschieben von mehreren Elementen nur umständlich realisierbar. Das Arbeiten mit Listen ist im Vergleich zu Arrays relativ langsam, da nicht über einen Index zugegriffen werden kann. HERDT-Verlag 9

10 8.5 Doppelt verkettete Liste Aufbau einer doppelt verketteten List In doppelt verketteten Listen besitzt jeder Knoten zwei Zeiger. Ein Zeiger verweist auf den Vorgänger und der andere, wie bei einer einfach verketteten List, auf den Nachfolger. Der erste Knoten hat keinen Vorgänger und der letzte Knoten keinen Nachfolger, sodass die jeweiligen Zeiger auf NULL verweisen. Durch die doppelte Verkettung kann diese List in beide Richtungen durchlaufen werden. Zeiger auf Vorgänger Zeiger auf Nachfolger Einen Knoten hinzufügen Setzen Sie den Laufzeiger auf den 2. Knoten. Nach dem 2. Knoten soll das neue Element eingefügt werden. Speichern Sie den Zeiger auf den Nachfolger vom 2. Knoten in einer Hilfsvariablen. Speichern Sie den Zeiger auf den Vorgänger vom 3. Knoten in einer Hilfsvariablen. Erstellen Sie den neuen Knoten. Der neue Knoten wird zum 3. Knoten. Setzen Sie den Zeiger auf den Nachfolger des 2. Knotens auf den neuen Knoten (3.). Setzen Sie den Zeiger auf den Vorgänger des 4. Knotens auf den neuen Knoten (3.). Weisen Sie die zwischengespeicherten Zeiger auf Vorgänger und Nachfolger den entsprechenden Zeigern des eingefügten Knotens zu. Setzen Sie den Laufzeiger auf die Position des eingefügten Knotens und füllen Sie den Datenteil des neuen Knotens. 10 HERDT-Verlag

11 Einen Knoten löschen Setzen Sie den Laufzeiger auf den zu löschenden Knoten (im Beispiel 2. Knoten). Speichern Sie den Zeiger für den Vorgänger und den Nachfolger in Hilfsvariablen ab. Setzen Sie den Laufzeiger auf den nächsten Knoten (alter 3. Knoten). Weisen Sie dem Zeiger auf den Vorgänger den zwischengespeicherten Wert auf den Vorgänger zu. Setzen Sie den Laufzeiger auf den Vorgänger. Weisen Sie dem Zeiger auf den Nachfolger den zwischengespeicherten Wert auf den Nachfolger zu. Der zweite Knoten wird gelöscht. Vorteile bei der Verwendung von doppelt verketteten Listen Die doppelt verkettete Liste kann in beide Richtungen durchlaufen werden. Ein Zugriff auf das vorige und nachfolgende Element ist möglich. Die Anzahl der Elemente ist nur durch den verfügbaren Speicherplatz begrenzt. Die Liste kann dynamisch erweitert bzw. verkleinert werden. Der Zugriff kann auf jedes Element zum Einfügen, Löschen oder Lesen erfolgen. Eine Mehrfachverkettung der Liste, auch rückwärts, ist möglich. Nachteile bei der Verwendung von doppelt verketteten Listen Da das Durchlaufen der Liste nur über die Adressverweise erfolgt, ist das Verschieben von mehreren Elementen nur umständlich realisierbar. Das Arbeiten mit Listen ist im Vergleich zu Arrays relativ langsam. HERDT-Verlag 11