B2. Arrays & Verkettete Listen

(1)

Algorithmen und Datenstrukturen

B2. Arrays & Verkettete Listen

Marcel L¨ uthi and Gabriele R¨ oger

Universit¨ at Basel

20. M¨ arz 2019

M. Lüthi, G. Röger (Universität Basel) Algorithmen und Datenstrukturen 20. März 2019 1 / 33

Algorithmen und Datenstrukturen

20. M¨ arz 2019 — B2. Arrays & Verkettete Listen

B2.1 Arrays

B2.2 Verkettete Listen

B2. Arrays & Verkettete Listen Arrays

B2.1 Arrays

Die Datenstruktur Array (Feld)

I Eine der grundlegenden Datenstrukturen, die sich in jeder Programmiersprache findet.

I Beschreibt eine Kollektion von fixer Gr¨ osse.

In Java:

B y t e [] ia = new B y t e [ 1 0 0 ] ;

S t r i n g [] sa = new S t r i n g [ 1 0 0 ] ;

(2)

Die Datenstruktur Array (Feld)

Array

Sequenz von Elementen die in gleichm¨ assigen Abst¨ anden im Speicher angeordent sind.

Laufzeit grundlegender Operationen

I Was ist die Laufzeitkomplexit¨ at von folgenden Operationen (als Funktion der Arraygr¨ osse n)

I get(i) Element an beliebiger Stelle i lesen?

I set(i) - Element an beliebiger Stelle i schreiben?

I length() - L¨ ange von Array bestimmen?

I find(x) - Element x finden und Index zur¨ uckliefern?

I Was ist die Speicherkomplexit¨ at?

Beobachtung

Komplexit¨ at direkte Konsequenz aus der Datenrepr¨ asentation

Dynamische Arrays

Fixe Gr¨ osse ist f¨ ur viele Anwendungen einschr¨ ankend I Brauchen Arrays, die dynamisch wachsen k¨ onnen.

I Laufzeit Eigenschaften bestehender Methoden sollen gleich bleiben.

Zus¨ atzliche Funktionen

I append(x) (manchmal push) - Element x ans Ende anf¨ ugen I insert(i, x) - Element x an Stelle i einf¨ ugen

I pop() - letztes Element entfernen

I remove(i) - Element an position i l¨ oschen Was ist die Laufzeitkomplexit¨ at dieser Funktionen?

Empirische Laufzeitanalyse, Python Arrays

IPython Notebook: Arrays-und-linked-lists.ipynb

(3)

Arrays vergr¨ ossern / verkleinern : Naive Methode

I append (und insert) m¨ ussen Array vergr¨ ossern.

I pop muss Array verkleinern

I Naive Methode: Jeweils um 1 gr¨ osses/kleineres Array anlegen I Element in neues Array kopieren

Arrays vergr¨ ossern : Schlauere Methode

I append (und insert) m¨ ussen Array vergr¨ ossern.

I Gr¨ osseres Array (von 2n Elementen) anlegen.

I Array muss nur bei jeden n-ten Aufruf von append kopiert werden.

Arrays verkleinern : Schlauere Methode

I pop muss Array verkleinern

I Kleineres Array anlegen nur wenn Array zu n/4 gef¨ ullt.

I In neues Array der Gr¨ osse n/2 kopieren.

I Array muss nur bei jeden n/4-ten Aufruf von pop kopiert werden.

Implementation: Arrays vergr¨ ossern / verkleinern (1)

I Implementation der append und pop Methode.

c l a s s A r r a y :

_ d a t a = [ N o n e ] # l i s t s i m u l a t e s b l o c k of m e m o r y _ l a s t I d x = 0

def a p p e n d ( self , e l e m ):

if len ( s e l f . _ d a t a ) == s e l f . _ l a s t I d x : s e l f . _ r e s i z e ( len ( s e l f . _ d a t a ) * 2) s e l f . _ d a t a [ s e l f . _ l a s t I d x ] = e l e m s e l f . _ l a s t I d x += 1

def pop ( self , e l e m ):

s e l f . _ l a s t I d x -= 1

i t e m = s e l f . _ d a t a [ s e l f . _ l a s t I d x ];

if s e l f . _ l a s t I d x > 0

and s e l f . _ l a s t I d x == len( s e l f . _ d a t a ) / 4:

s e l f . _ r e s i z e ( int (len ( s e l f . _ d a t a ) / 2 ) ) ;

r e t u r n i t e m ;

(4)

Implementation: Arrays vergr¨ ossern /verkleinern (2)

c l a s s A r r a y :

_ d a t a = [ N o n e ] # l i s t s i m u l a t e s b l o c k of m e m o r y _ l a s t I d x = 0

def a p p e n d ( self , e l e m ):

...

def pop ( self , e l e m ):

...

def _ r e s i z e ( self , n u m E l e m e n t s ):

n e w A r r a y = [ N o n e ] * n u m E l e m e n t s for i in r a n g e (0 , s e l f . _ l a s t I d x ):

n e w A r r a y [ i ] = s e l f . _ d a t a [ i ] s e l f . _ d a t a = n e w A r r a y

Theoretische Analyse der append Operation

Die append Operation hat (amortisierte) Laufzeit O(1)

Quelle: Abbildung 1.28 - Algorithms, Sedgewick & Wayne

I Amortisierte Analyse: Mittlere Laufzeit pro Operation wird

¨ uber Seqenz von N Operationen (im worst case) ermittelt.

Amortisierte Analyse

IPython Notebook: Arrays-und-linked-lists.ipynb

Analyse der append Operation: Beweisskizze

Annahmen:

I N ist Zweierpotenz.

I Wir starten mit Array der Gr¨ osse 1

Betrachte N aufeinanderfolgende Aufrufe von append. Wir haben folgende Anzahl Arrayzugriffe

N + 4 + 8 + 16 + . . . + N + 2N Wir nutzen, dass P n

i=0 2 ⁱ = 2 ⁿ⁺¹ − 1

N + 4 + 8 + 16 + . . . + N + 2N ≤ 3N + P log

₂

N i=0 2 ⁱ = 3N + 2 ^(log

²

^N)+1 − 1 = 3N + 2 · 2 ^log

²

^N − 1 ≤ 5N

Beobachtung: Kosten pro Aufruf von append sind konstant

(< 5N Operationen f¨ ur N Aufrufe)

(5)

B2.2 Verkettete Listen

Informatiker des Tages

Herbert Simon ( ¨ Okonom)

I Nobelpreistr¨ ager und

Gewinner des Turing Awards I Pionier in k¨ unstlicher

Intelligenz

I ” Erfinder “der verketteten Liste (im Rahmen der IPL Sprache).

Newell, Allen, and Fred M.

Tonge. An introduction to information processing language V. Communications of the ACM (1960).

B2. Arrays & Verkettete Listen Verkettete Listen

Motivation

I Arrays sind nicht flexibel genug

I Brauchen immer grossen, kontinuierlichen Block an Speicher I Einf¨ ugen von Elementen an beliebiger Position ist teuer L¨ osung muss uns erlauben Elemente im Speicher zu verteilen.

Frage?

I Wie kann man Elemente ordnen die verteilt im Speicher sind?

(6)

Frage?

I Wie kann man Elemente ordnen die verteilt im Speicher sind?

Verkettete Listen

I Wichtige, flexible Datenstruktur

I Jeder Knoten speichert sein Datum, sowie eine Referenz (Zeiger) auf Nachfolger

I Ende muss speziell gekennzeichnet werden (h¨ aufig null/None).

I ... oder wir brauchen Referenz auf letztes Element

Quiz: Komplexit¨ at Array / Verkettete Liste

Operation Array Verkettete Liste

Zugriff auf beliebiges Element O(1) O(n) Einf¨ ugen, L¨ oschen am Anfang O(n) O(1) Einf¨ ugen am Ende O(1) (ammortisiert) O(1) L¨ oschen am Ende O(1) (ammortisiert) O(n) Einf¨ ugen, L¨ oschen in Mitte O(n) O(n)

Verschwendeter Speicher O(1) O(n)

Take-home Message

I Verschiedene Datenstrukturen machen verschiedene Trade-offs

Einf¨ ugen am Anfang

(7)

Einf¨ ugen am Ende

Weitere Operationen

Einfach:

I Vom Anfang entfernen I Traversieren

Schwierig:

I Vom Ende entfernen I An beliebiger Position

einf¨ ugen

I An beliebiger Position entfernen

I Element an beliebiger Position lesen/schreiben Einfach/Schwierig bezieht sich auf Aufwand und nicht

Implementation.

Doppelt verkettete Liste

I Referenz nicht nur auf Nachfolger, sondern auch vorhergehendes Element

I Macht Entfernen vom Ende g¨ unstig.

Implementation in Python

IPython Notebook: Arrays-und-linked-lists.ipynb

(8)

Rekursive Definition

Eine Liste L ist I die leere Liste

I oder ein Element H (Head) gefolgt von einer Liste: H , L

Verkettete Listen: Datenstruktur (rekursiv)

c l a s s L i s t [ I t e m ]:

h e a d : I t e m t a i l : L i s t [ I t e m ]

L i s t ( h e a d : Item , t a i l : L i s t [ I t e m ]) # K o n s t r u k t o r e m p t y L i s t = L i s t ( None , N o n e )

Verkettete Listen: Datenstruktur (rekursiv)

c l a s s L i s t [ I t e m ]:

h e a d : I t e m t a i l : L i s t [ I t e m ]

L i s t ( h e a d : Item , t a i l : L i s t [ I t e m ]) # K o n s t r u k t o r e m p t y L i s t = L i s t ( None , N o n e )

Vergleiche:

c l a s s N o d e [ I t e m ]:

i t e m : I t e m n e x t : N o d e

N o d e ( h e a d : Item , t a i l : N o d e [ I t e m ]) # K o n s t r u k t o r

Verkettete Listen (rekursiv)

I Nat¨ urliche, rekursive Implementation vieler Operationen I Implementation folgt Datenstruktur