Vorlesung Datenstrukturen

Transkript

1 Vorlesung Datenstrukturen Lineare Listen (2) Doppelt verkettete Listen Ringlisten, Stapel, Schlangen Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 175

2 Doppelt verkettete Listen Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 176

3 Motivation Problem Speziell beim Löschen eines Listenelements haben wir gesehen, dass es sich hierbei um eine Operation konstanter Laufzeit handelt, wenn das Vorgängerelement bekannt ist. Bisher konnten wir den Vorgänger eines bekannten Listenelementes jedoch nur bestimmen, wenn wir die Liste bis zum bekannten Listenelement sequentiell durchmustert haben. Abhilfe Dieser zusätzliche Aufwand an Rechenzeit lässt sich vermeiden, wenn wir die bisher bekannte Datenstruktur Liste so modifizieren, dass zusätzlich zum Verweis auf den Nachfolger eines Listenelements auch noch ein Verweis auf seinen Vorgänger erfolgt. Vorteil Somit lässt sich konkret für die Operation des Löschens eines Listenelements sein Vorgänger direkt bestimmen und wir haben pauschal lediglich eine Laufzeit von O(1) für das Löschen eines Listenelements. Des Weiteren lassen sich durch die Bidirektionalität der Verkettung der Datenstruktur Liste auch noch weitere typische Listenoperationen beschleunigen. Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 177

4 Typdefinition eines Listenelements struct node { node* ; // Verweis auf Vorgänger Elementtyp data; node* next; // Verweis auf Nachfolger }; data next Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 178

5 Listenkonstruktion Konstruktion des Listenkopfes In Ergänzung zur einfach verketteten Liste muss jetzt auch das Vorgängerelement mit dem Nullzeiger initialisiert werden. struct node { node* ; Elementtyp data; node* next; }; node* head = new node; head-> = 0; head->next = 0; head data next 0 0 Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 179

6 Einfügen am Listenanfang node* temp = new node; // Bereitstellen des Speicherplatzes head-> = temp; temp->next = head; temp-> = 0; /* Vorgänger des alten Listenkopfes muss auf das neue Element verweisen */ /* Nachfolger des neuen Elements muss auf den alten Listenkopf zeigen */ /* Vorgänger des neuen Elements wird der Nullzeiger zugewiesen */ head = temp; // eingefügtes Element ist neuer Listenkopf head temp data next data next 0 head Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 180

7 Einfügen am Listenende Voraussetzung Zeiger last auf letztes Listenelement existiert node* temp = new node; // Bereitstellen des Speicherplatzes temp-> = last; /* Vorgänger des neuen Listenelements ist das bisherige letzte Element */ last->next = temp; temp->next = 0; last = temp; /* Nachfolger des bisher letzten Elements ist das neue Listenelement */ /* Nachfolger des neuen Elements wird der Nullzeiger */ // eingefügtes Listenelement ist letztes last data next data next 0 last temp Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 181

8 Einfügen in Listenrumpf Voraussetzung Existenz eines Zeigers, der auf das Listenelement zeigt, hinter dem eingefügt werden soll temp = new node; // Bereitstellen des Speicherplatzes temp-> = ; /* Vorgänger des neuen Listenelements ist das Element, auf das verweist */ temp->next = ->next; /* Nachfolger des neuen Elements ist der Nachfolger des Elements */ ->next-> = temp; /* Nachfolger des Vorgängers des neuen ->next = temp; Elements wird das erzeugte Element */ // Element wird Nachfolger des Vorgängers data next data next data next temp Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 182

9 Beispielliste struct node { unsigned char data; node*, node* next; }; node* head = new node; head->data = 'A'; head-> = 0; node* last = head; // Erzeugen des Listenkopfs // Kopf besitzt keinen Vorgänger for ( int i = 1; i < 10; i++ ) { // Erzeugen des Listenrumpfs node* temp = new node; temp->data = 'A' + i; temp-> = last; // Verknüpfe erzeugtes Element mit Vorgänger last->next = temp; // Verknüpfe Vorgänger mit erzeugtem Element last = temp; // Merke erzeugtes Listenelement } last->next = 0; // Markiere Listenende Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 183

10 Löschen des Listenkopfs Voraussetzung Zu löschendes Element elem entspricht dem Listenkopf head Beachte Situation Potentielle Erzeugung der leeren Liste nach dem Löschen des Listenkopfes head = head->next; // Neuer Listenkopf ist Nachfolger des alten Kopfes if (head) // Wenn Liste nicht leer ist, dann head-> = 0; // Listenkopf hat keinen Vorgänger delete elem; // Belegten Speicherplatz freigeben!!! elem = 0; // Zeiger mit Nullzeiger initialisieren!!! head elem data next data next elem 0 head Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 184

11 Löschen des Listenendes Voraussetzung Zu löschendes Element elem entspricht dem letzten Listenelement Beachte Situation Potentielle Erzeugung der leeren Liste nach Löschen des letzten Elements node* = elem->; // Neues Listenende ist Vorgänger des alten if () // Wenn Liste nicht leer ist, dann ->next = 0; // Letztes Listenelement besitzt keinen Nachfolger delete elem; // Belegten Speicherplatz freigeben!!! elem = 0; // Zeiger mit Nullzeiger initialisieren!!! data next data next elem 0 elem Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 185

12 Löschen aus Listenrumpf Voraussetzung Der Zeiger elem verweist auf das zu löschende Listenelement, das jedoch nicht das erste oder letzte Element der Liste sein darf. node* = elem->; // Vorgänger des zu löschenden Listenelements node* next = elem->next; // Nachfolger des zu löschenden Listenelements ->next = next; // Nachfolger des Vorgängers wird der Nachfolger next-> = ; // Vorgänger des Nachfolgers wird der Vorgänger delete elem; // Belegten Speicherplatz freigeben!!! elem = 0; // Zeiger mit Nullzeiger initialisieren!!! data next data next data next elem next Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 186

13 Doppelt verkettete Listen Vorteil Wir haben durch Ergänzung der Struktur eines Listenelements um eine zusätzliche Zeigerkomponente die direkte Verbindung zu seinem Vorgänger realisiert. Mit Hilfe dieser doppelten Verkettung können wir durch eine Liste direkt bidirektional navigieren, womit einige typische Anwendungen auf Listen besser modellierbar und effizienter ausführbar werden. Nachteil Die Vorteile der doppelten Verkettung erkauft man sich auf Kosten des für die zusätzliche Komponente extra benötigten Speicherplatzes (je Listenelement). Des Weiteren sind auch die Verkettungsoperationen von Listenelementen bei Einfüge- und Löschoperationen umfangreicher und komplexer (und damit fehleranfälliger) geworden. Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 187

14 Ringlisten Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 188

15 Ringlisten Aufbau Der Nachfolger des letzten Elements einer Ringliste ist nicht der Nullzeiger sondern der Listenkopf. Deshalb besteht eine Ringliste grundsätzlich aus mindestens einem Element. Ringlisten können sowohl einfach als auch doppelt verkettet sein. data next data next data next Vorteile Es wird nur noch ein Zeiger auf ein beliebiges Listenelement benötigt, um alle Listenelemente adressieren zu können. Einfüge- und Löschoperationen können vereinfacht werden, denn es muss nicht mehr unterschieden werden, an welcher Listenposition die Operation stattfindet. Bestimmte Probleme können adäquat mit Hilfe einer Ringliste modelliert werden. Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 189

16 Problem des Josephus Legende Josephus Flavius war ein berühmter jüdischer Historiker des ersten Jahrhunderts. Während des Jüdisch-Römischen Krieges wurden er und seine Begleiter von römischen Soldaten umzingelt und in einer Höhle eingeschlossen. Nach der Legende entschieden sich die Juden, sich lieber selbst zu töten als in Gefangenschaft zu geraten. Sie bildeten deshalb einen Kreis und die jeweils dritte Person im Kreis sollte getötet werden, so lange bis nur noch einer übrig blieb, der nach dem Willen der Gruppe Selbstmord begehen sollte. Josephus hatte allerdings nicht die Absicht zu sterben. So fand er schnell die einzig sichere Position im Kreis und blieb deshalb am Leben. Modellierung mit Ringliste Welches Element aus einer zirkulären Liste von N Elementen bleibt nach der wiederholten Entfernung des jeweils M-ten Elements übrig? Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 190

17 Problem des Josephus N=8, M= Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 191

18 Listen - Zusammenfassung (1) Vorteile Listen belegen nur so viel Speicherplatz, wie zur Speicherung der in ihnen enthaltenen Elemente tatsächlich benötigt wird neue Elemente können während der Laufzeit beliebig hinzugefügt werden existierende Listenelemente können jederzeit gelöscht werden die Größe von Listen (Elementanzahl) wird nur durch den verfügbaren Speicherplatz begrenzt Einfügen eines Elements ist prinzipiell in O(1) möglich Entfernen eines Elements ist prinzipiell in O(1) möglich Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 192

19 Listen - Zusammenfassung (2) Nachteile auf einzelne Listenelemente kann nicht wahlfrei sondern nur navigierend über den jeweiligen Vorgänger oder Nachfolger (nur bei doppelter Verkettung) des selektierten Listenelements zugegriffen werden Die Suche benötigt (auch für sortierte Listen) immer eine Zeitkomplexität von O(n). Für Einfüge und Löschoperationen ist evtl. eine vorherige Durchmusterung der Liste nötig, um die Einfüge- bzw. Löschposition zu bestimmen O(n) Selbstprogrammierte Listen tendieren zu hoher Fehleranfälligkeit bei Verkettungsoperationen Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 193

20 Stapel und Schlangen Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 194

21 Stapel und Schlangen Motivation Für viele Anwendungsgebiete wird die komplette Funktionalität, die Datenstrukturen wie Felder oder Listen bieten, gar nicht benötigt. Konsequenz Ziel Einschränkung der selektierenden oder ändernden Zugriffsmöglichkeiten auf Datenstrukturen. Durch die Beschränkung der durchführbaren Operationen lassen sich Datenstrukturen einfacher und problemgerechter implementieren. Beispiele Ein Stapel (auch als Keller oder Stack bezeichnet) ist eine Datenstruktur, die eine Menge von Daten aufnehmen und in umgekehrter Reihenfolge wieder abgeben kann. Eine Schlange (auch als Queue bezeichnet) ist eine Datenstruktur, die eine Menge von Daten aufnehmen und diese in der Reihenfolge des Einfügens wieder abgeben kann. Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 195

22 Stapel Funktionen Eine Stapel-Datenstruktur kennt im Wesentlichen nur zwei Operationen: push pop Ablegen eines Elements auf dem Stapel Entnehmen des zuletzt abgelegten Elements vom Stapel Zuletzt eingefügte Elemente werden also zuerst wieder entnommen. Diese Art des Vorgehens wird auch als LIFO-Prinzip bezeichnet (Last In, First Out) Implementierung mit Liste Operationen zum Ablegen und Entnehmen eines Elements müssen auf dasselbe Listenende beschränkt werden. Beispiel (aus der Realwelt) Stapel Kaffeebecher in der Mensa Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 196

23 Stapel: Implementierung Vorbemerkung Zu einem späteren Zeitpunkt wird die Datenstruktur Stapel detailliert besprochen. An dieser Stelle erfolgt nur eine beispielhafte Demonstration einer möglichen Implementierung der Basisfunktionen mit Hilfe einer via head adressierten Liste. push Aufgrund der LIFO-Elementverarbeitung der Datenstruktur Stapel bietet sich zur Ablage das aus V3 bekannte Einfüge- verfahren am Listenanfang an: pop Da sich das zuletzt eingefügte Element am Listenkopf befindet, müssen wir dieses löschen und den Listenkopf entsprechend modifizieren: node* temp = new node; temp->next = head; head = temp; node* temp = head; head = head->next; delete temp; temp = 0; Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 197

24 Schlangen Funktionen Auch die Datenstruktur Schlange kennt nur zwei wesentliche Funktionen: enqueue dequeue Einfügen eines Elements an das Ende der Schlange Entfernen eines Elements vom Anfang der Schlange Eingefügte Elemente werden also in der Reihenfolge ihres Einfügens wieder entfernt. Dies wird auch als FIFO-Prinzip bezeichnet (First In, First Out) Realisierung mit Liste Bei Implementierung einer Schlange mit Hilfe einer Listenstruktur müssen die Operationen zum Ablegen und Entnehmen eines Elements auf die jeweils entgegengesetzten Listenenden beschränkt werden. Beispiel (aus der Realwelt) Schlange an der Essenausgabe in der Mensa Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 198

25 Schlange: Implementierung Vorbemerkung Analog der Datenstruktur Stapel erfolgt eine detaillierte Darstellung später. Anbei nur eine grobe Beispielimplementierung der zwei Grundoperationen auf Basis einer via head adressierten Liste. enqueue Wir fügen analog V2 am Listenende ein. Voraussetzung ist die Existenz eines Zeigers last auf das letzte Element der Liste head. dequeue Wir entnehmen das erste Element der Liste, löschen also am Listenanfang. dequeue entspricht daher der pop-funktion unserer Stapelimplementierung. node* temp = new node temp->next = 0; last->next = temp; last = temp; node* temp = head; head = head->next; delete temp; temp = 0; Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 199

26 Ende der Vorlesung Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 200