Nachtrag: Vergleich der Implementierungen von Stack

Transkript

1 Nachtrag: Vergleich der Implementierungen von Stack In der letzten Vorlesung hatten wir zwei Implementierung der Klasse Stack: eine Implementierung als Liste (Array): liststack eine Implementierung als Verkettung von Objekten: linkedstack Beim folgenden Verdopplungstest werden zuerst n Elemente in den Keller geschrieben und anschließend alle Elemente wieder aus dem Keller entfernt.

2 Man kann erkennen, dass beide Implementierung lineare Rechenzeit haben. Allerdings braucht linkedstack etwa 5mal so lange wie liststack. Das liegt daran, dass der Zugriff auf Speicherplatz bei Python-Listen mit zusätzlichen Tricks programmiert ist, die wir bei der Implemetierung von linkedstack nicht benutzen konnten. liststack linkedstack n ratio time (s) ratio time (s) 2000: : : : : : : : : : : :

3 4.3.2 Warteschlangen FIFO Queue Eine Warteschlange ist eine Aneinanderreihung von Objekten ähnlich wie beim Keller. Der Keller hat das last in first out (LIFO) Prinzip: was zuletzt in den Keller getan wurde, kommt als erstes wieder raus. Die Warteschlange hat das first in first out (FIFO) Prinzip: was zuerst in die Warteschlange getan wurde, kommt als erstes wieder raus Wer neu zur Warteschlange dazukommt, muss sich hinten anstellen. Wer vorne steht, kann aus der Warteschlange raus. Wir werden die Warteschlange (bzw. Liste) als Datenstruktur für Graphen und zum Durchsuchen von Graphen benutzen.

4 Die API für Queue Operation Queue() q.isempty() q.enqueue(elem) q.top() q.dequeue() str(q) Beschreibung eine neue (leere) Warteschlange True, falls die Warteschlange leer ist, anderenfalls False fügt elem ans Ende der Warteschlange an gibt das erste Element der Warteschlange als Ergebnis zurück entfernt das erste Element der Warteschlange und gibt es als Ergebnis zurück Darstellung der Warteschlange als string

5 Implementierung der Queue (I) Bei der ersten Implementierung benutzen wir wieder Arrays. Das Anhängen eines neuen Elements an ein Array kennen wir bereits. Es geht in konstanter Zeit. In Python gibt es die Operation del a[i], mit der man aus Array a den Eintrag mit Index i entfernen kann. Die Operation benötigt lineare Zeit (in der Größe des Arrays). Das Entfernen des Kopfes der Schlange geht also mit del a[0]. Der Nachteil ist, dass diese Operation sehr viel Zeit verschlingt.

6 # # listqueue.py # # A Queue object is a first-in-first-out container. class Queue: # # Construct listqueue object self as an empty list. def init (self): self._a = [] # The list/array that realizes the queue. # # Return True, if self is empty, and False otherwise. def isempty(self): return len(self._a)==0 # # Add item to the end of self. def enqueue(self,elem): self._a += [elem]

7 # # Remove the first item of self and return it. def dequeue(self): result = self._a[0] del self._a[0] return result # # Return the first item of self. def top(self): return self._a[0] # # Return a string representation of self. def str (self): result = '' for s in self._a: results += s + ' ' return result

8 Implementierung der Queue (II) Bei der zweiten Implementierung benutzen wir die Verkettung von Objekten.

9 # linkedqueue.py class Queue: def init (self): self._start = None self._ende = None def enqueue(self,item): neu = _queueitem(item,none) if self._start is None: self._start = neu self._ende = neu else: self._ende.next = neu self._ende = neu def dequeue(self): if self._start is not None: item = self._start.item self._start = self._start.next return item else: return None def top(self): if self._start is not None: return self._start.item def isempty(self): return self._start is None def str (self): erg = '' link = self._start while link is not None: erg += str(link.item) + ' ' link = link.next return erg class _queueitem: def init (self,item,next): self.item = item self.next = next def str (self): return str(self.item)

10 Queue als Iterator Beim Durchsuchen von Graphen müssen wir häufig alle Nachbarn eines Knotens untersuchen d.h. für alle Nachbarn eines Knotens etwas machen. In Python liegt es nahe, dazu eine for-schleife zu benutzen. Wenn wir alle Elemente einer Warteschlange durchlaufen wollen, dann müssen wir den Datentyp als iterator implementieren. Dazu benutzen wir die speziellen Methoden iter () und next() (bzw. next in Python 3) in der Implementierung von Queue. Das ergibt folgende (geänderte) Implementierung von Queue.

11 # linkedqueue.py class Queue: def init (self): self._start = None self._ende = None self._ilink = None def enqueue(self,item):... def dequeue(self):... def top(self):... def isempty(self):... def iter (self): self._ilink = self._start return self def next(self): if self._ilink is None: raise StopIteration else: item = self._ilink.item self._ilink = self._ilink.next return item def str (self): erg = "" for elem in self: erg += " " + elem return erg

12 Vergleich der Implementierungen von Queue Man kann erkennen, dass listqueue quadratische Rechenzeit hat. Das liegt daran, dass beim Entfernen des ersten Elementes der Rest der Queue eine Stelle nach links verschoben wird. Das ist bei linkedqueue nicht nötig. listqueue linkedqueue n ratio time (s) ratio time (s) 2000: : : : : : : : :