(29.11.2016): Elementare Datenstrukturen (Stapel

1
Algorithmen und Datenstrukturen
Wintersemester 2016/17
11. Vorlesung
Elementare Datenstrukturen:
Stapel + Schlange + Liste
Prof. Dr. Alexander Wolff
Lehrstuhl für Informatik I
2-1
Zur Erinnerung
Datenstruktur:
Konzept, mit dem man Daten speichert und anordnet,
so dass man sie schnell finden und ändern kann.
2-2
Zur Erinnerung
Datenstruktur:
Konzept, mit dem man Daten speichert und anordnet,
so dass man sie schnell finden und ändern kann.
Abstrakter Datentyp
Implementierung
2-3
Zur Erinnerung
Datenstruktur:
Konzept, mit dem man Daten speichert und anordnet,
so dass man sie schnell finden und ändern kann.
Abstrakter Datentyp
beschreibt die Schnittstelle“ einer Datenstruktur –
”
welche Operationen werden unterstützt?
Implementierung
2-4
Zur Erinnerung
Datenstruktur:
Konzept, mit dem man Daten speichert und anordnet,
so dass man sie schnell finden und ändern kann.
Abstrakter Datentyp
beschreibt die Schnittstelle“ einer Datenstruktur –
”
welche Operationen werden unterstützt?
Implementierung
wie wird die gewünschte Funktionalität realisiert:
– wie sind die Daten gespeichert (Feld, Liste, . . .)?
– welche Algorithmen implementieren die Operationen?
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
3-2
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
Implementierung 1
3-3
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
3-4
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-5
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-6
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-7
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
O (1)
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-8
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
O (1)
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-9
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
O (1)
stellt folgende Operationen bereit:
O (n )
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 1
– Daten werden in einem Feld (oder Liste) gespeichert
– neue Elemente werden hinten angehängt (unsortiert)
– Maximum wird immer aufrechterhalten
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 2
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
O (1)
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
Insert, FindMax, ExtractMax, IncreaseKey
O (1)
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
3-1
Beispiel
Prioritätsschlange:
verwaltet Elemente einer Menge M , wobei jedes
Element x ∈ M eine Priorität x .key hat.
Abstrakter Datentyp
stellt folgende Operationen bereit:
O (log n)
Insert, FindMax, ExtractMax, IncreaseKey
O (1)
Implementierung 2
– Daten werden in einem Heap gespeichert
– neue Elemente werden angehängt und raufgereicht
– Maximum steht immer in der Wurzel des Heaps
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
4-3
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-4
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
Zeiger (pointer, iterator) p
ptr Minimum()
M
ptr Maximum()
...
key 1
key 2
key n
ptr Predecessor(ptr x )
...
info 1
info 2
info n
ptr Successor(ptr x )
4-5
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Beispiel für die Anwendung:
Gib alle Elemente sortiert aus!
ptr p = M .Minimum()
while p 6= nil do
gib p .key aus
M
p = M .Successor(p )
...
key 1
key 2
key n
...
info 1
info 2
info n
4-6
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Beispiel für die Anwendung:
Gib alle Elemente sortiert aus!
ptr p = M .Minimum()
while p 6= nil do
gib p .key aus
M
p = M .Successor(p )
...
key 1
key 2
key n
...
info 1
info 2
info n
4-7
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Beispiel für die Anwendung:
Gib alle Elemente sortiert aus!
ptr p = M .Minimum()
while p 6= nil do
gib p .key aus
M
p = M .Successor(p )
...
key 1
key 2
key n
...
info 1
info 2
info n
4-8
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Beispiel für die Anwendung:
Gib alle Elemente sortiert aus!
ptr p = M .Minimum()
while p 6= nil do
gib p .key aus
M
p = M .Successor(p )
...
key 1
key 2
key n
...
info 1
info 2
info n
4-9
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i ) • lege neuen Datensatz (k , i ) an
• M = M ∪ {(k , i )}
• gib Zeiger auf (k , i ) zurück
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
• M = M \ {(x .key, x .info)}
Delete(ptr x )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
M
key 1
key 2
...
key n
info 1
info 2
...
info n
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
• falls vorhanden, gib Zeiger p
ptr Search(key k )
mit p .key = k zurück
• sonst gib Zeiger nil zurück
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
• sei M 0 = {(k , i ) ∈ M | k < x .key}
ptr Maximum()
• falls M 0 = ∅, gib nil zurück,
ptr Predecessor(ptr x ) • sonst gib Zeiger auf (k ? , i ? )
?
zur
ück,
wobei
k
= max(k ,i )∈M 0 k
ptr Successor(ptr x )
4-1
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Funktionalität
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
• sei M 0 = {(k , i ) ∈ M | k < x .key}
ptr Maximum()
• falls M 0 = ∅, gib nil zurück,
ptr Predecessor(ptr x ) • sonst gib Zeiger auf (k ? , i ? )
?
zur
ück,
wobei
k
= max(k ,i )∈M 0 k
ptr Successor(ptr x )
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
Änderungen















Anfragen
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
Änderungen


















W
örterbuch


Anfragen
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
Änderungen











W
örterbuch


Anfragen







Implementierung: je nachdem...
4-2
Teil III [CLRS]
Dynamische Menge:
verwaltet Elemente einer sich ändernden Menge M
Abstrakter Datentyp
ptr Insert(key k , info i )
Delete(ptr x )
ptr Search(key k )
ptr Minimum()
ptr Maximum()
ptr Predecessor(ptr x )
ptr Successor(ptr x )
Funktionalität
Änderungen











W
örterbuch


Anfragen







Implementierung: je nachdem... Drei Beispiele!
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
5-2
last-in first-out“
”
verwaltet sich ändernde Menge nach LIFO-Prinzip
I. Stapel
Abstr. Datentyp
Implementierung
5-3
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
boolean Empty()
Push(key k )
key Pop()
key Top()
Implementierung
5-4
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
5-5
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
if top == 0 then return true
else return false
key[ ] A
int top
5-6
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
if top == 0 then return true
else return false
top = top + 1
A[top] = k
key[ ] A
int top
5-7
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
Aufgabe:
Schreiben Sie Pseudocode, der das
oberste Element vom Stapel nimmt
und zurückgibt!
5-8
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
5-9
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Größe?
1 2 ...
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
key[ ] A
int top
boolean Empty()
Push(key k )
key Pop()
key Top()
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
boolean Empty()
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if top == 0 then return true
else return false
top = top + 1
A[top] = k
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
A = new key[1..n]
top = 0
boolean Empty()
if top == 0 then return true
else return false
top = top + 1
A[top] = k
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
A = new key[1..n]
top = 0
boolean Empty()
if top == 0 then return true
else return false
top = top + 1 if top > A.length then
error overflow“
A[top] = k
”
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if Empty() then error underflow“
”
else
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
A = new key[1..n]
top = 0
boolean Empty()
if top == 0 then return true
else return false
top = top + 1 if top > A.length then
error overflow“
A[top] = k
”
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if Empty() then error underflow“
”
else
Laufzeiten?
top = top − 1
return A[top + 1]
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
A = new ? key[1..n]
top = 0
boolean Empty()
if top == 0 then return true
else return false
top = top + 1 if top > A.length then
error overflow“
A[top] = k
”
Push(key k )
key Pop()
key Top()
key[ ] A
int top
if Empty() then error underflow“
”
else
Laufzeiten?
top = top − 1
Alle? O (1),
return A[top + 1]
d.h. konstant.
if Empty() then ... else return A[top]
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Stapel(int n)
boolean Empty()
Push(key k )
key Pop()
key Top()
Implementierung
key[ ] A
int top
5-1
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 








Push(key k )





Methoden
key Pop()














key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()














key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel














key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel


n




Attribute








Methoden
key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel


n – top: int




Attribute








Methoden
key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel


n – top: int




Attribute

– A: key[ ]







Methoden
key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel


n – top: int




Attribute

– A: key[ ]




+Empty(): boolean



Methoden
key Top()
5-2
I. Stapel
verwaltet sich ändernde Menge nach LIFO-Prinzip
Abstr. Datentyp
Implementierung
Stapel(int n)
key[ ] A
Konstruktor
Attribute
int top

boolean Empty() 
Aufgabe:





Fertigen Sie ein



Push(key k )

UML-Diagramm für




die Klasse Stapel an!
Methoden
key Pop()
Stapel


n – top: int




Attribute

– A: key[ ]




+Empty(): boolean



Methoden
+Push(key)
key Top()
...
6-1
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-2
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-3
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-4
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-5
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-6
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
6-7
II. Schlange
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
tail
head
6-8
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Implementierung
key[ ] A
int tail
int head
tail
head
6-9
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
boolean Empty()
Implementierung
A = new key[1..n]
tail = head = 1
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key Dequeue()
entnimm Element am
Kopf der Schlange
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
k = A[head ]
if head == A.length then head = 1
else head = head + 1
return k
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key Dequeue()
entnimm Element am
Kopf der Schlange
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
k = A[head ]
if head == A.length then head = 1
else head = head + 1
return k
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key Dequeue()
entnimm Element am
Kopf der Schlange
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
tail = head = 1
boolean Empty()
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
k = A[head ]
if head == A.length then head = 1
else head = head + 1
return k
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key Dequeue()
entnimm Element am
Kopf der Schlange
key[ ] A
int tail
int head
tail
head
6-1
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Aufgabe:
boolean Empty()
Enqueue(key k )
stelle neues Element
an den Schwanz der
Schlange an
key Dequeue()
entnimm Element am
Kopf der Schlange
Implementierung
A = new key[1..n]
tail = head = 1
key[ ] A
int tail
int head
if head == tail then return true
else return false
A[tail ] = k
if tail == A.length then tail = 1
else tail = tail + 1
k = A[head ]
if head == A.length then head = 1
else head = head + 1
return k
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
else head = head + 1
return k
6-2
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
else head = head + 1
return k
6-2
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
else head = head + 1
return k
6-2
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
else head = head + 1
return k
6-2
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
Laufzeiten?
else head = head + 1
return k
6-2
tail
head
II. Schlange
A
verwaltet sich ändernde Menge nach FIFO-Prinzip
Abs. Datentyp
Queue(int n)
Implementierung
A = new ? key[1..n]
key[ ] A
tail = head = 1
int tail
int head
Aufgabe: Fangen Sie underflow & overflow ab!
boolean Empty() if head == tail then return true
else return false
Enqueue(key k )
A[tail ] = k
stelle neues Element
if tail == A.length then tail = 1
an den Schwanz der
else tail = tail + 1
Schlange an
key Dequeue()
k = A[head ]
entnimm Element am if head == A.length then head = 1
Kopf der Schlange
Laufzeiten?
else head = head + 1
?
Alle
O (1).
return k
6-2
7-1
III. Liste
Abs. Datentyp
Implementierung
7-2
III. Liste
key
prev
Abs. Datentyp
Implementierung
next
7-3
III. Liste
prev
Abs. Datentyp
key0
key
Implementierung
next
nil
7-4
III. Liste
key00
nil
Abs. Datentyp
key0
key
prev
Implementierung
next
nil
7-5
III. Liste
head
key00
nil
Abs. Datentyp
key0
key
prev
Implementierung
next
nil
7-6
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
key00
nil
key0
key
prev
Implementierung
next
nil
7-7
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
key00
nil
key0
key
prev
next
nil
Implementierung
ptr head
7-8
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
key00
nil
key0
key
prev
next
nil
Implementierung
key key
ptr prev
ptr next
ptr head
7-9
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
key00
nil
key0
key
prev
next
nil
Implementierung
Item
key key
ptr prev
ptr next
ptr head
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
Item
key key
ptr prev
ptr next
ptr head
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
ptr Insert(key k )
x = new Item()
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
Implementierung
head = nil
next
nil
Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
ptr Insert(key k )
x = new Item()
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
head = nil Item(key k , ptr p ) Item
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
ptr Insert(key k )
x = new Item()
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
ptr Insert(key k )
x = new Item()
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-1
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
Aufgabe:
Implementieren Sie
Delete(ptr x )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
key00
nil
key0
key
prev
next
nil
x
Abs. Datentyp
List()
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
Aufgabe:
Implementieren Sie
Delete(ptr x )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
key00
nil
key0
key
prev
next
nil
x
Abs. Datentyp
List()
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
Aufgabe:
Implementieren Sie
Delete(ptr x )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
ptr Insert(key k )
Aufgabe:
Implementieren Sie
Delete(ptr x )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
ptr Search(key k )
Hausaufgabe:
Benutzen Sie
Stopper!
ptr Insert(key k )
Aufgabe:
Implementieren Sie
Delete(ptr x )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
Laufzeiten?
ptr Search(key k )
ptr Insert(key k )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
Laufzeiten?
ptr Search(key k )
ptr Insert(key k )
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
O (1)
Laufzeiten?
ptr Search(key k )
ptr Insert(key k )
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-2
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
O (1)
Laufzeiten?
ptr Search(key k )
O (n )
ptr Insert(key k )
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-3
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
O (1)
Laufzeiten?
ptr Search(key k )
O (n )
ptr Insert(key k )
O (1)
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-3
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
O (1)
Laufzeiten?
ptr Search(key k )
O (n )
ptr Insert(key k )
O (1)
O (1)
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
7-3
III. Liste
head
(doppelt verkettet)
Abs. Datentyp
List()
O (1)
Laufzeiten?
ptr Search(key k )
O (n )
ptr Insert(key k )
O (1)
O (1)
Delete(ptr x )
key00
nil
key0
key
prev
next
nil
x
Implementierung
head = nil Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
ptr head
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
x = new Item() k , head )
x .key = k ; x .prev = nil ; x .next = head
if head 6= nil then head .prev = x
head = x ; return x
8-1
Von Pseudocode zu Javacode: (1) Item
Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
8-2
Von Pseudocode zu Javacode: (1) Item
Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
8-3
Von Pseudocode zu Javacode: (1) Item
public class Item {
private Object key;
private Item prev;
private Item next;
}
Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
8-4
Von Pseudocode zu Javacode: (1) Item
public class Item {
private Object key;
private Item prev;
private Item next;
Item(key k , ptr p ) Item
public Item(Object k, Item p) {
key = k;
next = p;
prev = null;
}
}
key = k
next = p
prev = nil
key key
ptr prev
ptr next
8-5
Von Pseudocode zu Javacode: (1) Item
public class Item {
private Object key;
private Item prev;
private Item next;
Item(key k , ptr p ) Item
key = k
next = p
prev = nil
public Item(Object k, Item p) {
key = k;
next = p;
prev = null;
}
}
public void setPrev(Item p)
public void setNext(Item p)
{ prev = p; }
{ next = p; }
public Item getPrev()
public Item getNext()
{ return prev; }
{ return next; }
public Object getKey()
{ return key; }
key key
ptr prev
ptr next
8-6
Von Pseudocode zu Javacode: (1) Item
public class Item {
private Object key;
private Item prev;
private Item next;
Item(key k , ptr p ) Item
key = k
next = p
prev = nil
key key
ptr prev
ptr next
public Item(Object k, Item p) {
key = k;
next = p;
prev = null;
}
{ prev = p; }
{ next = p; }
public Item getPrev()
public Item getNext()
{ return prev; } getter
{ return next; } 
 Methoden
public Object getKey()
}




 setter-
public void setPrev(Item p)
public void setNext(Item p)
und
{ return key; }

9-1
Von Pseudocode zu Javacode: (2) List
ptr head
List()
head = nil
ptr Insert(key k )
x = new Item(k , head )
if head 6= nil then
head .prev = x
head = x
return x
9-2
Von Pseudocode zu Javacode: (2) List
public class List {
private Item head;
ptr head
List()
head = nil
ptr Insert(key k )
x = new Item(k , head )
if head 6= nil then
head .prev = x
head = x
return x
9-3
Von Pseudocode zu Javacode: (2) List
public class List {
private Item head;
public List() {
head = null;
}
ptr head
List()
head = nil
ptr Insert(key k )
x = new Item(k , head )
if head 6= nil then
head .prev = x
head = x
return x
9-4
Von Pseudocode zu Javacode: (2) List
public class List {
ptr head
private Item head;
public List() {
List()
head = null;
head = nil
}
public Item insert(Object k) {
Item x = new Item(k, head);
if (head != null) {
ptr Insert(key k )
head.setPrev(x);
x = new Item(k , head )
}
if head 6= nil then
head = x;
head .prev = x
return x;
head = x
}
return x
9-5
Von Pseudocode zu Javacode: (2) List
public class List {
ptr head
private Item head;
public List() {
List()
head = null;
head = nil
}
public Item insert(Object k) {
Item x = new Item(k, head);
if (head != null) {
ptr Insert(key k )
head.setPrev(x);
x = new Item(k , head )
}
if head 6= nil then
head = x;
head .prev = x
return x;
head = x
}
return x
public Item getHead() { return head; }
10 -
Von Pseudocode zu Javacode: (2) List
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
10 -
Von Pseudocode zu Javacode: (2) List
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
10 -
Von Pseudocode zu Javacode: (2) List
ptr Search(key k )
x = head
while x 6= nil and x .key 6= k do
x = x .next
return x
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
x = x.getNext();
}
return x;
}
11 -
Von Pseudocode zu Javacode: (2) List
Delete(ptr x )
if x .prev 6= nil then x .prev .next = x .next
else head = x .next
if x .next 6= nil then x .next.prev = x .prev
11 -
Von Pseudocode zu Javacode: (2) List
Delete(ptr x )
if x .prev 6= nil then x .prev .next = x .next
else head = x .next
if x .next 6= nil then x .next.prev = x .prev
11 -
Von Pseudocode zu Javacode: (2) List
Delete(ptr x )
if x .prev 6= nil then x .prev .next = x .next
else head = x .next
if x .next 6= nil then x .next.prev = x .prev
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
} Was wird hier ausgegeben?
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
}
}
12 -
Javacode: (3) Main
public class Listentest {
public static void main(String[] args) {
List myList = new List();
myList.insert(new Integer(10));
myList.insert(new Integer(16));
System.out.println("Die Liste enthaelt:");
for (Item it = myList.getHead(); it != null;
it = it.getNext()) {
System.out.println((Integer) it.getKey());
}
Item it = myList.search(new Integer(16));
myList.delete(it);
Die Liste enthaelt:
}
}
16
10
Fehler!
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
x = x.getNext();
}
return x;
}
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
x = x.getNext();
}
return x;
}
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
gleiche Zahlen, aber verschiedene Objekte!
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
!k.equals(x.getKey())
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
gleiche Zahlen, aber verschiedene Objekte!
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
!k.equals(x.getKey())
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
gleiche Zahlen, aber verschiedene Objekte!
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
X
13 -
Warum “Fehler!”?
Item.java
public Item search(Object k) {
Item x = head;
!k.equals(x.getKey())
while (x != null && x.getKey() != k) {
Listentest.java
x = x.getNext();
}
myList.insert(new Integer(16));
return x;
...
gleiche Zahlen, aber verschiedene Objekte!
}
Item it = myList.search(new Integer(16));
myList.delete(it);
List.java
public void delete(Item x) {
if (x == null) System.out.println("Fehler!");
Item prev = x.getPrev();
Item next = x.getNext();
if (prev != null) prev.setNext(next);
else head = next;
if (next != null) next.setPrev(prev);
}
[
X
Unschön: Klasse Item muss public sein, so dass Anwender
und Bibliotheksklasse List darüber kommunizieren können.
]