Datenstrukturen und Algorithmen. Vorlesung 6

Transkript

1 Datenstrukturen und Algorithmen Vorlesung 6

2 Heap (auch Halde oder Haufen) Binäre Heaps sind eine einfache und effiziente Implementierung von Prioritätswarteschlangen (priority queues) Ein binären Heap ist ein Hybrid zwischen dynamisches Array und Binärbaum Ein binären Heap ist ein Array, welches man als fast vollständigen binären Baum mit besonderen Eigenschaften auffassen kann

3 Heap Nehmen wir an, dass folgendes Array auf der oberen Zeile Positionen und auf der unteren Zeile Elemente enthält: Man kann dieses Array als Binärbaum visualisieren, indem jeder Knoten genau zwei Kinder hat, außer der letzten zwei Niveaus, wo die Knoten von links nach rechts ausgefüllt werden

4 Heap

5 Heap Wenn die Elemente des Arrays a 1, a 2, a 2, a 3,... a n sind, dann gilt Folgendes: a 1 stellt die Wurzel dar Die Kinder der Wurzel entsprechen a 2 und a 3 Die Kinder von Knoten i haben Indizes 2 * i und 2 * i+1 (falls diese Zahlen in 1..n liegen). Der Vorgänger eines Knotens i, mit 2 i n, hat den Index [i/2].

6 Heap Ein binären Heap ist ein Array, das als Binärbaum visualisiert werden kann und, dass zusätzlich die Heap-Struktur und Heap-Eigenschaft besitzt Heap-Struktur: ein Binärbaum, in welchem jeder Knoten genau zwei Kinder hat, außer der letzten zwei Niveaus, wo die Knoten von links nach rechts ausgefüllt werden Heap-Eigenschaft: a i a 2*i (falls 2 i n) und a i a 2*i + 1 (falls 2 i +1 n) Ein Baum erfüllt die Heap-Eigenschaft bezüglich einer Vergleichsrelation auf den Schlüsselwerten genau dann, wenn für jeden Knoten u des Baums gilt, dass u.wert v.wert für alle Knoten v aus den Unterbäumen von u (man kann jedwelche Vergleichsrelation auswählen)

7 Heap In Abhängigkeit von der gewählten Vergleichsrelation erhält man nun einen Baum, der entweder das Minimum oder das Maximum in der Wurzel enthält: Ein binärer Baum, der die Heap-Eigenschaft mit der Relation erfüllt, wird als Max-Heap bezeichnet. Ein binärer Baum, der die Heap-Eigenschaft mit der Relation erfüllt, wird als Min-Heap bezeichnet. Der Baum, der ein binärer Heap mit Größe n repräsentiert, besitzt eine Höhe von log 2 n, also ist die Komplexität der Operationen auf einem Heap O(log 2 n)

8 Heap - Operationen Ein Heap kann als Repräsentierung für eine Prioritätswarteschlange benutzt werden und enthält zwei spezifische Operationen: Füge ein neues Element in einem Heap ein (sodass man die Struktur des Heaps und die Heap-Eigenschaft behaltet) Lösche ein Element man löscht immer nur die Wurzel des Heaps und kein anderes Element

9 Heap - Repräsentierung Heap: cap: Integer len: Integer elems: TElem[] Für die Implementierung nehmen wir an, dass es um eine Max-Heap geht

10 Heap add Sei der folgende Max-Heap: Füge das Element 55 in den Heap ein

11 Heap add Um die Heap-Struktur zu behalten, fügen wir den neuen Knoten als das rechte Kind von dem Knoten mit Wert 14 ein (das letzte Element in dem Array)

12 Heap add Die Heap-Eigenschaft ist nicht erfüllt: 14 hat als Kind ein Knoten mit Wert 55 (in einem Max-Heap sollte jeder Knoten größer als seine Kinder sein) Um die Heap-Eigenschaft zu bewahren, beginnt man die Einträge der Knoten zu vertauschen: Man lässt den neuen Knoten durch sukzessives Vertauschen mit seinem Vaterknoten soweit im Baum hochsteigen, bis die Heap- Eigenschaft wiederhergestellt ist (bubble-up)

13 Heap add Nach dem bubble-up:

14 Heap add subalgorithm add(heap, e) is: //heap - ein Heap //e - das Element, das eingefügt werden muss if heap.len = heap.cap resize end-if heap.elems[heap.len+1] e heap.len heap.len + 1 bubble-up(heap, heap.len) end-subalgorithm

15 Heap add subalgorithm bubble-up (heap, p) is: //heap - ein Heap //p - Position von welchem man den neuen Knoten hochsteigen muss poz p elem heap.elems[p] parent p / 2 while poz > 1 and elem > heap.elems[parent] execute //der Vaterknoten wird nach unten verschoben heap.elems[poz] heap.elems[parent] poz parent parent poz / 2 end-while heap.elems[poz] elem end-subalgorithm Komplexität: O(log 2 n) - da wir pro Ebene des Baumes nur konstanten Aufwand investieren und der Baum logarithmische Höhe besitzt

16 Heap remove Aus einem Heap kann man nur die Wurzel löschen

17 Heap remove Um die Heap-Struktur zu behalten, ersetzt man die Wurzel durch das letzte Element aus dem Array

18 Heap remove Die Heap-Eigenschaft ist nicht erfüllt: die Wurzel ist nicht mehr das größte Element Nun lassen wir die neue Wurzel im Heap durch Vertauschen mit dem größten Kind soweit im Heap absinken, bis die Heap-Eigenschaft wieder erfüllt ist (bis der Knoten ein Blatt oder größer als beide Kinder ist) (bubble-down)

19 Heap remove Nach dem bubble-down:

20 Heap remove function remove(heap) is: //heap - ist ein Heap if heap.len = 0 error - leeren Heap end-if deletedelem heap.elems[1] heap.elems[1] heap.elems[heap.len] heap.len heap.len - 1 bubble-down(heap, 1) remove deletedelem end-function

21 Heap remove subalgorithm bubble-down(heap, p) is: //heap - ist ein Heap //p - Position von welchem man den neuen Knoten absinken muss poz p elem heap.elems[p] while poz < heap.len execute maxchild -1 if poz * 2 heap.len then //es gibt ein linkes Kind maxchild poz*2 end-if if poz*2+1 heap.len and heap.elems[2*poz+1] > heap.elems[2*poz] then //der Knoten hat zwei Kinder und das rechte ist größer maxchild poz*2 + 1 end-if //Fortsetzung auf der nächsten Folie

22 Heap remove if maxchild -1 and heap.elems[maxchild] > elem then heap.elems[poz] heap.elems[maxchild] poz maxchild else heap.elems[poz] elem poz heap.len + 1 //um die while-schleife zu stoppen end-if end-while end-subalgorithm Komplexität: O(log 2 n)

23 ? Wo kann man in einem Max-Heap: Das größte Element des Arrays finden? Das kleinste Element des Arrays finden?

24 Naiver Heapaufbau (top-down Strategie) Der Heap wird von oben nach unten (top-down) aufgebaut, indem: Ein neues Element möglichst weit links eingefügt wird und Rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist Wird benutzt, wenn die Elemente des Heaps nicht von Anfang an bekannt sind (man erstellt also den Heap durch n-faches Einfügen eines Elementes) Zeitkomplexität der Einfüge-Operation ist O(log 2 n) zum Aufbau eines Heaps mit n Elementen benötigt man O(nlog 2 n)

25 Verbessertes Heapaufbau (bottom-up Strategie) Das Erstellen des Heaps kann verbessert werden wenn man alle Elemente des Heaps vom Anfang an kennt (ein Array, das nicht sortiert ist) Man nimmt an, dass die zweite Hälfte des Arrays nur Blätter enthält Anfangend von dem ersten Element in der Mitte des Arrays, das nicht ein Blatt ist, bis zu dem ersten Element des Arrays, ruft man bubble-up auf Zeitkomplexität: O(n)

26 Heapsort Heapsort ist ein Sortierverfahren basiert auf Heap Nehmen wir an, dass folgende Sequenz in steigender Reihenfolge sortiert werden muss: 6, 1, 3, 9, 11, 4, 2, 5

27 Heapsort naive Vorgehensweise Idee: Erstelle ein Min-Heap und füge alle Elemente der Sequenz ein (Naiver Heapaufbau) Lösche der Reihe nach alle Elemente aus dem Heap: diese werden in aufsteigender Reihenfolge gelöscht, da immer nur die Wurzel gelöscht wird

28 Heapsort naive Vorgehensweise Min-Heap mit den Elementen der Sequenz: Bei dem Löschen der Elemente werden diese in folgender Reihenfolge gelöscht: 1, 2, 3, 4, 5, 6, 8, 11

29 Heapsort naive Vorgehensweise Welche ist die Zeitkomplexität der naiven Vorgehensweise? O(nlog 2 n) (n-faches Einfügen nlog 2 n, n-faches Löschen nlog 2 n) Welche ist die Speicherkomplexität? Braucht man zusätzliches Speicherplatz? man braucht ein zusätzliches Array Θ(n)

30 Heapsort verbesserte Vorgehensweise Wenn man eine Sequenz in aufsteigender Reihenfolge sortieren will, dann benutzt man ein Max-Heap dann braucht man kein zusätzliches Speicherplatz für ein Array Warum? Zusätzlich kann man den verbesserten Heapaufbau benutzen

31 Heapsort verbesserte Vorgehensweise Welche ist die Zeitkomplexität der verbesserten Vorgehensweise? die Komplexität für den Heapaufbau ist O(n), aber die Komplexität für das Löschen des Elementes bleibt O(nlog 2 n) Welche ist die Speicherkomplexität? Man braucht kein zusätzliches Speicherplatz

32 ADT Liste Eine Liste ist eine endliche Folge von null oder mehr Elementen eines gegebenen Typs <l 1, l 2,..., l n >, wobei die Reihenfolge der Elemente bekannt ist, und jedes Element eine Position hat In einer Liste ist die Reihenfolge der Elemente wichtig (im Gegenteil zu ADT Set zum Beispiel) Die Anzahl der Elemente aus der Liste heißt Länge der Liste. Eine Liste ohne Elemente heißt leer. Die Position, an der ein Element e steht, wird auch als Vorkommen von e bezeichnet.

33 ADT Liste Eine Liste ist ein Container, der entweder leer ist oder: Es enthält wenigstens ein Element Für jedes Element, außer des letzten, gibt es einen eindeutigen Nachfolger Für jedes Element, außer des ersten, gibt es einen eindeutigen Vorgänger In einer Liste kann man Elemente auf einer bestimmten Position einfügen, von einer gegebenen Position löschen, auf den Nachfolger und Vorgänger eines gegebenen Elementes zugreifen, auf das Element an einer bestimmten Position zugreifen

34 ADT Liste Positionen Jedes Element aus der Liste hat eine eindeutige Position: Positionen sind relativ zur Liste Die Position eines Elementes: bestimmt/identifiziert das Element bestimmt die Position des Nachfolgers und des Vorgängers (falls diese exitieren)

35 ADT Liste Positionen Die Position eines Elementes kann unterschiedlich betrachtet werden: Als Rang des Elementes in der Liste (erste, zweite, usw.) Ähnlich wie bei Arrays, wo die Position gleich ist mit dem Index des Elementes Als Referenz zu dem Speicherplatz, wo das Element gespeichert wird Z.B. ein Pointer zu der Adresse des Elementes Damit wir die Position allgemein betrachten können, benutzen wir den abstrakten Typ TPosition für die Position eines Elementes

36 ADT Liste Positionen Eine Position p ist gültig (valid) falls es ein Element in der Liste gibt mit der entsprechenden Position: Falls p ein Pointer ist zu einer Adresse im Speicherplatz, dann ist p gültig falls diese die Adresse eines Elementes der Liste ist (und nicht NIL oder die Adresse von irgendwas anderes) Falls p der Rang eines Elementes ist, dann ist p gültig falls es einen Wert zwischen 1 und der Anzahl der Elemente enthält Für ungültige Positionen benutzen wir die Notation:

37 ADT Liste Domäne des ADT Liste: L = {l l ist eine Liste mit Elementen vom Typ TElem, wobei jedes Element eine eindeutige Position vom Typ TPosition in l hat}

38 ADT Liste Interface init(l) descr: erstellt eine neue, leere Liste pre: wahr post: l L, l ist eine leere Liste first(l) descr: gibt die TPosition des ersten Elementes zurück pre: l L post: first p TPosition die Position des ersten Elementes aus l, p ቊ, ansonsten falls l

39 ADT Liste Interface last(l) descr: gibt die TPosition des letzten Elementes zurück pre: l L post: last p TPosition die Position des letzten Elementes aus l, p ቊ, ansonsten falls l

40 ADT Liste Interface valid(l, p) descr: überprüft ob ein TPosition gültig ist pre: l L, p TPosition wahr, falls p eine gültige Position in l ist post: valid ቊ falsch, ansonsten

41 ADT Liste Interface next (l, p) descr: gibt die TPosition des nächsten Elementes aus der Liste zurück pre: l L, p TPosition post: next q TPosition die Position des nächsten Elementes nach p, falls p nicht die letzte Position in l ist q ቊ, ansonsten throws: ein Exception, falls p ungültig ist

42 ADT Liste Interface previous (l, p) descr: gibt die TPosition des vorigen Elementes aus der Liste zurück pre: l L, p TPosition post: previous q TPosition die Position des Elementes vor p, falls p nicht die erste Position in l ist q ቊ, ansonsten throws: ein Exception, falls p ungültig ist

43 ADT Liste Interface getelement(l, p, e) descr: gibt das Element von einer gegebenen TPosition zurück pre: l L, p TPosition, valid(p) post: e TElem, e = das Element an der Position p in l throws: ein Exception, falls p ungültig ist

44 ADT Liste Interface position (l, e) descr: gibt die TPosition eines Elementes zurück pre: l L, e TElem post: position p TPosition die Position des Elementes e aus l, p ቊ, ansonsten falls e l

45 ADT Liste Interface modify (l, p, e) descr: ersetzt das Element an der gegebenen TPosition mit einem neuen Element pre: l L, p TPosition, e TElem, valid(p) post: l L, das Element an der Position p aus l ist e throws: ein Exception, falls p ungültig ist insertfirst (l, e) descr: fügt ein neues Element am Anfang der Liste ein pre: l L, e TElem post: l L, das Element e wurde am Anfang der Liste eingefügt

46 ADT Liste Interface insertlast (l, e) descr: fügt ein neues Element am Ende der Liste ein pre: l L, e TElem post: l L, das Element e wurde am Ende der Liste eingefügt insertafter (l, p, e) descr: fügt ein neues Element nach der gegebenen Position ein pre: l L, p TPosition, e TElem, valid(p) post: l L, das Element e wurde nach Position p in l eingefügt (position(l, e) = next(l, p)) throws: ein Exception, falls p ungültig ist

47 ADT Liste Interface insertbefore (l, p, e) descr: fügt ein neues Element vor der gegebenen Position ein pre: l L, p TPosition, e TElem, valid(p) post: l L, das Element e wurde vor Position p in l eingefügt (position(l, e) = previous(l, p)) throws: ein Exception, falls p ungültig ist

48 ADT Liste Interface remove (l, p, e) descr: löscht das Element von der gegebenen Position pre: l L, p TPosition, valid(p) post: e TElem, e ist das Element an der Position p aus l, l L, l = l e throws: ein Exception, falls p ungültig ist search (l, e) descr: sucht ein Element in der Liste pre: l L, e TElem wahr, falls e l post: search ቊ falsch, ansonsten

49 ADT Liste Interface isempty (l) descr: überprüft ob eine Liste leer ist pre: l L wahr, falls l = post: isempty ቊ falsch, ansonsten size (l) descr: gibt die Anzahl der Elemente aus der Liste zurück pre: l L post: size Anzahl der Elemente aus l

50 ADT Liste Interface destroy (l) descr: zerstört eine Liste pre: l L post: l wurde zerstört iterator (l, it) descr: gibt ein Iterator für die Liste zurück pre: l L post: i I, i ist ein Iterator für l

51 TPosition Wenn man TPosition in dem Interface von ADT Liste benutzt, dann gibt es auch Nachteile: Der Typ des TPositions kann unterschiedlich sein wenn man unterschiedliche Represäntierungen für Liste hat Das Interface enthält viele Operationen

52 TPosition C++ In STL, wird TPosition durch einen Iterator dargestellt Die Operationen valid, next, previous, getelement sind eigentlich Operationen des Iterators Zum Beispiel vector: iterator insert(iterator position, const value_type& val) iterator erase(iterator position) Zum Beispiel list: iterator insert(iterator position, const value_type& val) iterator erase(iterator position)

53 TPosition Java In Java, wird TPosition als Index dargestellt Das Einfügen, Löschen und Zugreifen auf Elemente werden mit Hilfe von Indexe implementiert Es gibt wenigere Operationen in dem Interface der Liste Zum Beispiel: void add(int index, E element) E get(int index) E remove(int index)

54 ADT SortedList In einer Liste können die Elemente basierend auf einer Ordnungsrelation sortiert werden SortedList Man kann immer noch mit Hilfe der Positionen auf die Elemente zugreifen Unterschiede in dem Interface: init hat auch die Relation als Parameter Es gibt nur eine Einfügeoperation Es gibt keine Änderungsoperation (modify)

55 ADT List - Repräsentierung Um ADT List (oder ADT SortedList) zu implementieren kann man folgende Datenstrukturen für die Repräsentierung benutzen: (dynamisches) Array Die Elemente werden auf aufeinanderfolgende Speicherplätze gespeichert Wir haben direkter Zugriff auf die Elemente verkettete Liste Die Elemente werden in Knoten gespeichert Man hat keinen direkten Zugriff auf jedes Element

56 ADT Stack (Stapel/Keller/Kellerspeicher)

57 ADT Stack (Stapel/Keller/Kellerspeicher) ADT Stack ist ein Container, wo der Zugriff zu den Elementen auf ein Ende des Behälters (Top des Stacks) beschränkt ist: In einem Stack können Elemente nur von oben hinzugefügt (eingekellert) und von oben entnommen (ausgekellert) werden Man kann nur auf das oberste Element zugreifen Es gilt also das LIFO Prinzip (Last-in-First-Out-Prinzip) das letzte Element, das eingefügt wurde, wird als erstes gelöscht werden Statt Stack verwendet man auch die Bezeichnungen Stapel, Keller/Kellerspeicher oder LIFO-Liste

58 ADT Stack Ein Stack hat eine feste Kapazität. Wenn die Kapazität des Stacks gleich ist mit der Anzahl der Elemente aus dem Stack, dann ist der Stack voll. Ein Stack, der keine Elemente enthält, heißt leer.

59 Stack Beispiel Man fängt vom folgenden Stack an (grüner Pfeil zeigt den Top) Man fügt den Wert 33 ein (push) Man löscht ein Element (pop)

60 Stack Beispiel Man fängt vom folgenden Stack an (grüner Pfeil zeigt den Top) Man löscht ein Element (pop) Man fügt den Wert 72 ein (push)

61 ADT Stack Interface Domäne von ADT Stack: S = {s s ist ein Stack mit Elementen vom Typ TElem}

62 ADT Stack Interface init(s) descr: erstellt einen leeren Stack pre: wahr post: s S, s ist einen leeren Stack destroy(s) descr: zerstört einen Stack pre: s S post: s wurde zerstört

63 ADT Stack Interface push(s, e) descr: legt ein neues Element oben auf den Stack (Einfüge-Operation) pre: s S, e TElem post: s S, s = s e, e ist das oberste Element throws: ein Overflow Error, falls s voll ist pop(s) descr: liefert das oberste Objekt auf dem Stack und entfernt es vom Stack pre: s S post: pop e, e TElem, e ist das oberste Element aus s, s S, s = s e throws: ein Underflow Error, falls s leer ist

64 ADT Stack Interface top(s) descr: gibt das oberste Element auf dem Stack zurück (der Stack wird aber nicht geändert) pre: s S post: top e, e TElem, e ist das oberste Element aus s throws: ein Underflow Error, falls s leer ist isempty(s) descr: überprüft ob der Stack leer ist pre: s S wahr, falls s keine Elemente enthält post: isempty ቊ falsch, ansonsten

65 ADT Stack Interface isfull(s) descr: überprüft ob der Stack voll ist pre: s S wahr, falls s voll ist post: isfull ቊ falsch, ansonsten

66 ADT Stack Interface Bemerkung! Stacks können nicht iteriert werden! Dafür gibt es auch keine iterator Operation.

67 ADT Stack - Repräsentierung Um ADT Stack zu implementieren kann man folgende Datenstrukturen für die Repräsentierung benutzen: Arrays: Statische Arrays Dynamische Arrays Verkettete Liste Einfach verkettete Listen Doppelt verkettete Listen

68 ADT Stack Repräsentierung auf statische Arrays Wo sollte man den Top des Stacks speichern um eine gute Effizienz zu erreichen? Es gibt zwei Mölichkeiten: Den Top des Stacks am Anfang des Arrays zu speichern bei jeder push und pop Operation müssen alle Elemente des Arrays nach rechts, bzw. nach links, verschoben werden Den Top des Stacks am Ende des Arrays zu speichern bei den push und pop Operation müssen die Elemente des Arrays nicht mehr verschoben werden

69 ADT Stack Repräsentierung auf statische Arrays Heap: capacity: Integer top: Integer elements: TElem[0...capacity-1]

70 Init Implementierung mit statischen Arrays subalgorithm init(s) is: s.capacity MAX_CAPACITY //MAX_CAPACITY ist eine Konstante, welche die maximale Kapazität //bestimmt s.top Speicherplatz für die Elemente des Arrays end-subalgorithm Komplexität: Θ(1)

71 Push Implementierung mit statischen Arrays subalgorithm push(s, e) is: if s.capacity = s.top then //überprüfe ob s voll overflow (full stack) exception end-if s.elements[s.top] e s.top s.top + 1 end-subalgorithm Komplexität: Θ(1)

72 Pop Implementierung mit statischen Arrays function pop(s) is: if s.top = 0 then // überprüfe ob s leer underflow(empty stack) exception end-if topelem s.elements[s.top-1] s.top s.top -1 pop topelem end-function Komplexität: Θ(1)

73 Top Implementierung mit statischen Arrays function top(s) is: if s.top = 0 then // überprüfe ob s leer underflow(empty stack) exception end-if topelem s.elements[s.top-1] top topelem end-function Komplexität: Θ(1)

74 IsEmpty Implementierung mit statischen Arrays function isempty(s) is: if s.top = 0 then isempty True else isempty False end-if end-function Komplexität: Θ(1)

75 IsFull Implementierung mit statischen Arrays function isfull(s) is: if s.top = s.capacity then isfull True else isfull False end-if end-function Komplexität: Θ(1)

76 Implementierung mit dynamischen Arrays Welche Operationen müssen geändert werden, wenn man bei der Implementierung des Stacks ein dynamisches Array benutzt anstatt ein statisches Array? Wenn man ein dynamisches Array benutzt, dann kann man die Kapazität des Stacks in der Einfügeoperation vergrößern, sodass der Stack nie voll ist Die push Operation löst nie Overflow Error aus (eventuell out of Memory), sondern die Kapazität des Arrays wird verdoppelt, falls nötig Die isfull Operation wird immer falsch zurückgeben

77 ADT Stack Repräsentierung auf einfach verketteten Listen Wo sollte man den Top des Stacks speichern um eine gute Effizienz zu erreichen? Es gibt zwei Mölichkeiten: Den Top des Stacks am Ende der Liste zu speichern (sowie bei der Repräsentierung auf Arrays) bei jeder push und pop Operation muss man die ganze Liste durchlaufen um den letzten Element zu finden Den Top des Stacks am Anfang der Liste zu speichern bei den push und pop Operation muss die Liste nicht durchlaufen werden

78 ADT Stack Repräsentierung auf einfach verketteten Listen Node: elem: TElem next: Node Stack: top: Node

79 Init Implementierung mit einfach verketteten Listen subalgorithm init(s) is: s.top NIL end-subalgorithm Komplexität: Θ(1)

80 Destroy Implementierung mit einfach verketteten Listen subalgorithm destroy(s) is: while s.top NIL execute firstnode s.top s.top firstnode end-while end-subalgorithm Komplexität: Θ n, wobei n die Anzahl der Elemente ist

81 Push Implementierung mit einfach verketteten Listen subalgorithm push(s, e) is: //allokiere einen neuen Knoten und bestimme die Werte der newnode of type Node [newnode].elem e [newnode].next NIL if s.top = NIL then s.top newnode else [newnode].next s.top s.top newnode end-if end-subalgorithm Komplexität: Θ(1)

82 Pop Implementierung mit einfach verketteten Listen function pop(s) is: if s.top = NIL then //überprüfe ob s leer underflow (empty stack) exception end-if firstnode s.top topelem [firstnode].elem s.top firstnode pop topelem end-function Komplexität: Θ(1)

83 Top Implementierung mit einfach verketteten Listen function top(s) is: if s.top = NIL then // überprüfe ob s leer underflow (empty stack) exception end-if topelem [s.top].elem top topelem end-function Komplexität: Θ(1)

84 IsEmpty Implementierung mit einfach verketteten Listen function isempty(s) is: if s.top = NIL then isempty True else isempty False end-if end-function Komplexität: Θ(1)

85 IsFull Implementierung mit einfach verketteten Listen Es gibt keine maximale Kapazität bei einer verketteten Liste, also der Stack wird nie voll sein. Wenn man die Operation isfull implementiert, dann wird diese immer den Wert falsch zurückgeben function isfull(s) is: isfull False end-function Komplexität: Θ(1)

86 Stack mit fester Kapazität auf einfach verketteten Listen Wie kann man ein Stack mit einer festen Kapazität auf einfach verketteten Listen implementieren? Ähnlich wie bei der Implementierung auf statischen Arrays, kann man in der Struktur des Stacks zwei Integer Werte speichern: Die maximale Kapazität Die aktuelle Größe des Stacks (Anzahl der Elemente)