IMPLEMENTIERUNG - ARRAY, OPERATIONEN FÜR LISTT 1

Informatik 1, Listen
WS 2004
IMPLEMENTIERUNG - ARRAY,
OPERATIONEN FÜR LISTT1
Informatik 1, Listen
WS 2004
OPERATIONEN FÜR ITERATORT2
private class ArrayListIteratorT implements IteratorT
protected int current = NIL;
Operationen
(1)
void clear()
(6)
size := 0
(2)
(8)
(9)
(10)
falls genügend freier Platz (n+m ≤ maxSize)
D
Umspeichern der Elemente der
anzuhängenden Liste
0(1)
boolean hasPrev()
return (current ≠ NIL AND current ≠ 0)
0(1)
0(n)
(11)
void prev()
falls current ≠ NIL:
current --
(12)
(13)
O(1)
setToIndex(int i)
setze current auf i
1. skizziert, nicht ausprogrammiert
0(1)
Iterator copy()
erzeuge einen neuen gleichwertigen Iterator
[email protected]
0(1)
void next()
falls noch nicht Listenende erreicht:
current ++
sonst: current := NIL
void connect(ListT l)
0(1)
boolean hasMore()
return (current ≠ NIL)
0(1)
0(1)
void last()
falls die Liste nicht leer:
current := size - 1
0(1)
void append(ElemT e)
if ( size < maxSize )
then
contents [size] := e;
size ++
endif
(5)
(7)
int length()
return (size)
(4)
0(1)
void first()
falls die Liste nicht leer:
current := 0
boolean isEmpty()
return (size = 0)
(3)
0(1)
O(1)
2. lokale Klasse innerhalb ArrayListT
2.1 - 1 / 8
[email protected]
2.1 - 2 / 8
Informatik 1, Listen
WS 2004
ITERATOR-GESTEUERTE
LISTENOPERATIONEN
Informatik 1, Listen
WS 2004
HAUPTNACHTEILE
• Einfügen und Löschen sind relativ teuer (hier O(n));
(14)
return ( new ArrayListIteratorT() )
(15)
in Java kann jedoch bei Bedarf dynamisch ein größeres Array
allokiert werden;
->
das ist dann jedoch sehr aufwendig !
$
VERKETTET GESPEICHERTE
LISTEN
0(1)
void delete (IteratorT it)
die Array-Elemente rechts vom gelöschten Element
(aval(it)+1, ... , an)
um eine Position nach links rücken;
size --
(19)
0(n)
• gesamte Speicherbereich fest reserviert
(d. h. kein dynamisches Wachsen/Schrumpfen);
ElemT retrieve (IteratorT it)
falls Iterator definiert, direkter Zugriff möglich:
return ( contents [it.current] )
(18)
0(n)
void locate (IteratorT it, ElemT e)
sequentielle Suche nach e ab der Iterator-Position
(17)
0(1)
void insert (IteratorT it, ElemT e)
falls noch Platz:
size ++;
aval(it), ... , an um eine Position nach rechts;
e in Lücke ablegen
(16)
• maximale Listengröße (relativ) fest eingestellt;
IteratorT getIterator()
0(n)
void replace (IteratorT it, ElemT e)
falls Iterator definiert:
contents [it.current] := e
0(1)
Anmerkung:
• Die direkte Implementierung von replace ist effektiver (0(1))
als die indirekte Implementierung über delete und insert (0(n)).
• allg. Suche benötigt O(n);
für sortierte Folgen gibt es effektivere Verfahren mit O(log n);
[email protected]
2.1 - 3 / 8
[email protected]
2.1 - 4 / 8
Informatik 1, Listen
WS 2004
IMPLEMENTIERUNG - POINTERLIST1T,
OPERATIONEN FÜR ITERATORT
Informatik 1, Listen
POINTERLIST1T,
HAUPTNACHTEILE
private class PointerList1IteratorT implements IteratorT
protected NodeT current = NULL;
• i. allg. müssen viele Spezialfälle unterschieden werden
->
leere Liste, Listenende;
(6)
• bei Operationen, die sich auf das Listenende beziehen
(append, connect, last)
muß man sich zunächst bis zum Listenende durchhangeln;
->
O(n)
void first()
current := anchor;
(7)
0(1)
void last()
Listenende suchen
(8)
WS 2004
0(n)
Bei den folgenden Implementierungen entfallen diese Schwierigkeiten
teilweise
boolean hasMore()
current ≠ NULL
0(1)
• eine dummy-Klammerung reduziert die Spezialfälle
• Zeiger zum Listenende reduziert die Komplexität
(9)
void next()
if ( current.next ≠ NULL )
then current = current.next
else current := NULL
endif
(10)
0(1)
-> current := current.next
boolean hasPrev()
es gibt einen Vorgänger, falls current
nicht auf das 1. Listenelement (wie der Anker) zeigt:
(current ≠ anchor AND current ≠ NULL)
(11)
0(n)
Iterator copy()
erzeuge einen neuen gleichwertigen Iterator
(13)
POINTERLIST3T
POINTERLIST4T
void prev()
aufwendig; mit einem Hilfszeiger p:
1. suche nach p.next = current;
2. current := p
(12)
0(1)
$
POINTERLIST2T
O(1)
setToIndex(int i)
i-te Listenelement durch abzählen suchen
[email protected]
O(n)
2.1 - 5 / 8
[email protected]
2.1 - 6 / 8
Informatik 1, Listen
WS 2004
Informatik 1, Listen
WS 2004
IMPLEMENTIERUNG - POINTERLIST2T
IMPLEMENTIERUNG - POINTERLIST3T
• Liste mit Start- und Stop-Dummy-Element
• Liste mit Start- und Stopp-Dummy-Element;
• Position p
->
Zeiger auf Knoten ap
• Position p
->
Zeiger auf Knoten, dessen next-Komponente
einen Zeiger auf den Knoten mit dem Element ap enthält
Stop
Start
Position p
Stop
Start
Position p
?
a1
...
ap
...
an
?
?
[email protected]
2.1 - 7 / 8
a1
...
[email protected]
ap-1
ap
...
an
?
2.1 - 8 / 8