Algorithmen Und Datenstrukturen SS07

1
Inhaltsberblick
0. Einfhrung
Programmstrukturen
Vorlesung
1. Algorithmen
Paradigmen, Analyse
Algorithmen und Datenstrukturen (PI.ADS.AD.VO)

3 Stunden / 4 ECTS Punkte
2. Datenstrukturen
Allgemeiner berblick
3. Listen
Lineare Speicherstrukturen, Stack, Queue
Ao. Univ.-Prof. Dipl.-Ing. Dr. Erich Schikuta

Institut fr Knowledge and Business Engineering Fakultt fr Informatik, Universitt Wien SS 2007
VO Algorithmen und Datenstrukturen E. Schikuta
4. Bume
Suchstrukturen
5. Vektoren
Sortieren, Hashing
6. Graphen
Traversierungs- und Optimierungsalgorithmen
Literatur
R. Sedgewick, Algorithmen in C++ (Teil 1-4), Addison Wesley, 3. berarbeitete Auflage, 2002 Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest, Introduction to Algorithms, published by MIT Press and McGraw-Hill. (First published in 1990.) Jim Gray, Vortrag: Parallel Database Systems Analyzing LOTS of Data, Microsoft Research, 1997 E. Schikuta, Folien zur Vorlesung, Algorithmen und Datenstrukturen 1, SS 2006
Danksagung Fr Mitarbeit und Durchsicht der Folien geht mein besonderer Dank an Helmut Wanek, Clemens Bruckmann und Martin Polaschek Mein weiterer Dank geht an zahlreiche Studierende der letzten Jahre, die im Rahmen ihrer bungen die Basis fr einige der dynamischen Beispiele der VO lieferten.
VO Algorithmen und Datenstrukturen
E. Schikuta
E. Schikuta
0.1 Was ist Informatik ?
Kapitel 0:
Die Wissenschaft der Informatik umfasst alle Modelle (Methoden, Verfahren, Konzepte, etc.), die dazu dienen eine gegebene Eingabe in eine beliebige Ausgabe zu verwandeln
Einfhrung
Input
Informatik
Output
E. Schikuta
E. Schikuta
Modelle der Informatik
Beispiele fr Modelle Kochrezept als Folge von Anweisungen
Modelle der
Input
Computerprogramm Spielregeln
Bedienungsanleitung Informatik Kochrezept
Output ...
Informatik
Amerikanischer Wildreis 1 Tasse ergibt 3 Portionen Reis grndlich waschen 1 Tasse Reis in 3 Tassen kochendes Wasser geben kurz aufkochen lassen bei schwacher Hitze 25 min bedeckt dnsten Reis abdecken, salzen, mit Gabel auflockern restliche Flssigkeit verdampfen
Beschreibung von Ursache-WirkungsZusammenhngen

Weies Licht erhlt man, wenn man rotes, grnes und blaues Licht mischt
VO Algorithmen und Datenstrukturen E. Schikuta VO Algorithmen und Datenstrukturen E. Schikuta
10
0.2 Algorithmus Unter Algorithmus versteht man die schrittweise Vorschrift zur Berechnung gesuchter aus gegebenen Gren, in der jeder Schritt aus einer Anzahl eindeutig ausfhrbarer Operationen und einer Angabe ber den nchsten Schritt besteht. Ursprung
Algorithmus Berechnungsvorschrift Ben Musa Al-Chwarizmi (usbekischer Mathematiker um 825), erstes Buch ber Algebra arithmos ... griechisches Wort fr Zahl
Algorithmus - Eigenschaften (1)

Eingangswerte/Ausgabewerte
EW sind vor, AW nach der Ausfhrung bekannt
Eindeutigkeit
Jeder Schritt der Ausfhrung mu eindeutig sein, keine Mehrdeutigkeiten mglich
Endlichkeit
Statisch: mit endlich vielen Zeichen formulierbar Dynamisch: in endlich vielen Schritten beendbar
Vollstndigkeit
sollte vollstndig sein, sollte alle mglichen Flle behandeln
Korrektheit
sollte das gewnschte Ergebnis liefern
Granularitt der Operationen

Spezifikationsgenauigkeit der einzelnen Beschreibungselemente
11
12
Paradigmen und Darstellung

Paradigma
... Das, was den Mitgliedern einer wissenschaftlichen Gemeinschaft gemeinsam ist ... eine Konstellation von Meinungen, Wertungen und Methoden... (Thomas Kuhn 1976)
Das logikbasierte Paradigma

ein Programm besteht aus Regeln und Fakten
Wenn es regnet, nehme ich den Schirm. Wenn ich zerstreut bin, vergesse ich den Schirm unterwegs. Wenn ich zerstreut bin, gre ich Bekannte nicht. Wenn ich nicht zerstreut bin, gre ich Bekannte. Regeln Wenn es regnet und ich meinen Schirm unterwegs vergesse, werde ich nass. Wenn es schwl ist, bin ich zerstreut. Es ist schwl. Fakten Es regnet. Anfrage: werde ich nass? Antwort: ja. Ableitbare Fakten: Ich nehme den Schirm. Ich bin zerstreut. Ich vergesse den Schirm unterwegs. Ich werde nass. Ich gre Bekannte nicht.
Algorithmen knnen auf ganz unterschiedliche Art konzipiert werden (Paradigmen): prozedural versus funktional versus logik-basiert orthogonal dazu objektorientiert (OO) auf eine bestimmte Art konzipierte Algorithmen knnen auf ganz unterschiedliche Art ausgedrckt werden (Darstellung): natrlichsprachlich, in einer Programmiersprache,
ein Problem: Widersprche zwischen den Regeln

Beispiel (nicht ganz ernst zu nehmen, aber illustrativ): Meta-Regel
Regel 1: Der Chef hat recht. Regel 2: Stimmt dies ausnahmsweise nicht, so findet Regel 1 Anwendung.
E. Schikuta
E. Schikuta
13
14
Das funktionale Paradigma

Beispiel: Csar-Verschlsselung Nimm jeweils den im Alphabet drittfolgenden Buchstaben
CAESAR FDHVDU
Das prozedurale Paradigma

imperatives Paradigma Pfadfinder-Gelndespiel:
Geh zur alten Hhle Merk dir, wieviele Fichten davor stehen Geh den Weg weiter bis zur Gabelung Zhle die Fichten, die du hier siehst, dazu Wenn du insgesamt fnf Fichten gezhlt hast, geh den linken Weg weiter; wenn sieben, dann den rechten
jedes Vorkommen von 'A' kann durch 'D' ersetzt werden
Das Programm ist nur aus Funktionen (Abbildungen) im mathematischen Sinn aufgebaut. Jedes Vorkommen eines Funktionsaufrufes kann durch das Funktionsergebnis ersetzt werden. Funktionen haben keine Seiteneffekte; es gibt keine Variablen. n=0 1 Beispiel: Fakulttsfunktion n! = n > 0 n (n 1)!
3! 3(3-1)! 32! 32(2-1)! 321! 321(1-1)! 3210! 3211 6 hier: kann ersetzt werden durch
Der Lsungsweg ist durch eine Folge von Anweisungen vorgegeben Anweisungen knnen Werte in Variablen zwischenspeichern, lesen und verndern
E. Schikuta
15
16
0.3 Algorithmendarstellung Wie man einen Algorithmus darstellen kann, hngt vom gewhlten Paradigma ab! Fr das prozedurale Paradigma bieten sich insbesondere an: Graphisch
Ablaufdiagramme Struktogramme
Ablaufdiagramm = Flussdiagramm
Anweisungen stehen in Knoten Kontrollfluss: gerichtete Kanten Start summe = 0
Darstellung graphisch
Struktogramm
Anweisungen stehen in Blcken Kontrollfluss: Form, Struktur der Blcke
summe = 0
n>0? summe = summe + n JA drucke summe n=n1 Ende NEIN
n>0 summe = summe + n n=n1 drucke summe
Pseudocode
Knstliche Programmiersprachenderivate Stilisierte Prosa
Programmiersprachen
Pro: leicht erfassbar, Standardnotation, auch dem Anwender verstndlich (Diskussionsbasis) Con: groe Programme unberschaubar, schwierig direkt in Programmiersprache umsetzbar, schwer
editierbar, automatische Codegenerierung eher beschrnkt (meist nur Prozedurkpfe)
17
18
Darstellung Pseudocode
Programmiersprachenderivate
Anlehnung an eine Programmiersprache (z. B. Pascal, MODULA-2); Ziel, eine der natrlichen Sprache mglichst nahe Kunstsprache zu schaffen (standardisierte Darstellung!) begin comment Das ist ALGOL; integer n,i,summe; read(n); summe := 0; for i := n step -1 until 1 do summe := summe + i; print(summe) end
Darstellung Programmiersprache
Kenneth E. Iverson, 1979
Notation as a Tool of Thought Inventor of APL
Stilisierte Prosa
Beschreibung der schrittweisen Ausfhrung
Schritt 1:Initialisiere. Setze summe auf 0. Schritt 2:Abarbeitung der Schleife. Solange n grer als 0, addiere n zu summe, ziehe 1 von n ab. Schritt 3:Ausgabe. Drucke summe.
int summe = 0; while(n > 0) { summe += n; n--; } cout << summe;
Pro: Programmiersprache sehr hnlich, direkte Umsetzung einfach Con: hnliche Komplexitt wie Programmiersprache, fr den Anwender oft schwer verstndlich
Pro: (fast) direkt ausfhrbar Con: komplex, fr Entwurf nur sehr beschrnkt einsetzbar
E. Schikuta VO Algorithmen und Datenstrukturen E. Schikuta
19
20
Programmiersprachen-Paradigmen
Damit ein Computer ein Problem lsen kann, mssen wir ihm den Algorithmus in Form eines Programms, das in einer Programmiersprache geschrieben ist, prsentieren
Generation erste zweite dritte
Programmiersprachen-Gruppen
Typ der Programmiersprache Maschinensprachen Maschinenorientierte Sprachen (Assembler) Problemorientierte Sprachen Datenbanksprachen Sprachen der KI Objektorientierte Sprachen Hybride Sprachen Vertreter Binr- und Hexadezimal-Programmierung OS/370 Assembler, 2650 Assembler, 8080 Assembler FORTRAN, COBOL, Pascal, MODULA-2, C SQL, Natural-2 Lisp, PROLOG Smalltalk C++
Klassifikation von Programmiersprachen:
ProgrammiersprachenParadigmen
vierte fnfte ? ?
prozedural versus funktional versus logik-basiert sequentiell versus parallel typisiert versus untypisiert (flieender bergang) orthogonal dazu: objektorientiert
prozedural versus funktional versus logik-basiert sequentiell versus parallel typisiert versus untypisiert (flieender bergang) orthogonal dazu: objektorientiert
E. Schikuta
E. Schikuta
21
22
0.4 Programmstrukturen Elemente einer prozeduralen Programmiersprache

Die Wertzuweisung ist eine Anweisung Die Sequenz von Anweisungen ist eine Anweisung Die Entscheidung ist eine Anweisung Die Iteration ist eine Anweisung
Aktion 1
Sequenz, Zuweisung
j 1 j j + 1
Aktion 2
Satz (Bhm / Jacopini 1966):

Jedes durch einen Computer ausfhrbare Programm (berechenbare Funktion) kann durch eine Kombination dieser 4 Elemente berechnet werden
Aktion 1
j = 1; j = j + 1;
oder Aktion 2
j = 1; j++;
E. Schikuta
E. Schikuta
23
24
Verzweigung
Aktionsblock wird solange wiederholt, wie die Bedingung (Eintrittsbedingung) gilt
nein while (Bedingung true) ja Aktion
while - Schleife
ja ja nein
j > n
nein
nein
while j < n
ja
j 0
j i
j j + 1
JA
Bedingung erfllt ?
NEIN
Teil 1
Teil 2
if (j > n) j = 0; else j = i;
Eintrittsbedingung Anweisung(en), Schleifenblock
while (j < n) j = j + 1;
E. Schikuta
E. Schikuta
25
26
Iteration oder Schleife

Anweisung wird abhngig von einer Bedingung wiederholt ausgefhrt
Verschiedene Schleifenformen in Gebrauch Beispiel: while-Form
Anweisung wird solange wiederholt, wie die Bedingung erfllt ist (Eintrittsbedingung) NEIN
Funktion / Prozedur (1) Abgeschlossene algorithmische Einheiten bestehen aus Sequenzen, Verzweigungen, Schleifen und Funktions-/Prozeduraufrufen Funktion
Eingangswerte, genau ein Ausgangswert
Bedingung erfllt? JA
Prozedur
nur Eingangswerte
Eintrittsbedingung Anweisung
Anweisung
beide knnen ber Parameterliste Werte zurckliefern
E. Schikuta
E. Schikuta
27
28
Funktion/Prozedur (2)
0.5 Rekursion Ein Objekt heit rekursiv, wenn es durch sich selbst definiert ist, oder sich selbst (teilweise) enthlt. Beispiele:
Fernseher Mathematik
(Definition der Fakultt)
Funktion
int sum(int n) { int summe = 0; while(n > 0) { summe += n; n--; } return summe; }
Prozedur
void sum(int n) { int summe = 0; while(n > 0) { summe += n; n--; } printf(%d\n, summe); }
n = 0 n! = n > 0
1 n ( n 1) !
E. Schikuta
E. Schikuta
29
30
Rekursive Programmteile Eine Prozedur/Funktion heit rekursiv, wenn sie sich in der Folge ihrer Abarbeitung selbst referenziert. Eine Prozedur/Funktion P heit direkt rekursiv, wenn sie sich explizit selbst aufruft. Hingegen ist P indirekt rekursiv, wenn sie den Aufruf einer anderen Prozedur/Funktion enthlt, die ihrerseits wieder P (direkt oder indirekt) aufruft. Berechnung der Fakultt
// Berechnung von n! fr n>=0 int fakultaet(int n) { if(n == 0) rekursiver return(1); Aufruf else return(n * fakultaet(n-1)); }
Direkte Rekursion
Berechnung der Fibonacci Zahlen

// Berechnung der Fibonacci Zahlen int fibonacci(int n) { if(n <= 1) return 1; return fibonacci(n-1) + fibonacci(n-2); }
E. Schikuta
31
32
Direkte Rekursion, Beispiel Berechnung von 3!

Aufruf: fkt(3) 6
int fkt(int n) { if(n == 0) return(1); else return(n*fkt(n-1)); }
Indirekte Rekursion Definition eines Ausdrucks (expression) in MODULA-2

(Ausschnitt)
Expr ::= SimpleExpr [RelOp SimpleExpr]

fkt(3) fkt(2) fkt(1) fkt(0)
SimpleExpr ::= [SignOp] Term [AddOp Term]

n==0 3*fkt(2) 2*fkt(1) 1*fkt(0)
Term ::= Factor {MulOp Factor}

return(1)
return (3*2) 3*2*1*1
return (2*1) 2*1*1
return (1*1)
Factor ::= ( Expr ) | NOT Factor | Value
E. Schikuta
E. Schikuta
33
34
indirekte Rekursion, Beispiel Ableitung des Ausdrucks: 3 * ( 4 + 5 )

Expr SimpleExpr Term Factor Value 3 Term Value 4
Charakteristik rek. Lsungsanstze Eigenschaften

Ziel ist die schrittweise Entwicklung der Lsung ausgehend von einem bzw. zurckfhrend auf einen Fixpunkt (eine Ausgangslsung) Vorteile
knapper und prgnanter Lsungsweg oft Ansatz direkt aus der Problemdefinition ableitbar Programm einfacher lesbar
Expr ::= SimpleExpr [RelOp SimpleExpr] SimpleExpr ::= [SignOp] Term [AddOp Term] Term ::= Factor {MulOp Factor} Factor ::= ( Expr ) | NOT Factor | Value
MulOp * (
Factor Expr SimpleExpr + Term Value 5

E. Schikuta
Nachteile
Programme knnen fehlerhafter sein logische Fehler schwerer zu finden mgliche Verlangsamung der Programme Programm schwerer lesbar (vergl. Vorteile!)
35
36
Rekursiver Ansatz Drei Kriterien

Verringern des Problemgrades
Ein Problem der Gre n wird in eine endliche Anzahl von Problemen zerlegt, deren Gre kleiner n ist. Abbruchkriterium if(n == 0) return(1); else return(n*fakultaet(n-1)); Konstruktion des Endergebnisses Zerlegung der Problemgre
Kriterien
Abbruchkriterium
Spezifikation einer zu erreichenden Programmsituation, bei der das Programm die rekursiven Aufrufe beendet.
Konstruktion des Endergebnisses

Das Endergebnis sukkzessiv (meist beim rekursiven Aufstieg) aus den Teilergebnissen zusammensetzen.
E. Schikuta
E. Schikuta
37
38
Was nehmen wir mit? Algorithmus Darstellung Programmstrukturen Rekursion
Kapitel 1:
Algorithmen
E. Schikuta
E. Schikuta
39
40
1.1 Motivation Algorithmen

Verfahrensvorschriften, Anweisungsfolgen, Vorgangsmodellierungen, beschriebene Lsungswege
Algorithmen zu Problemstellungen finden! Aufgabe: Summe der ganzen Zahlen bis n

Straight-forward solution: Aufsummieren der einzelnen n Werte zwischen 1 und n
summe i
i 1
Ziele
Algorithmen zu Problemstellungen finden!
Lsungsanstze finden, konstruieren
Realisierung (C/C++ Programm)

int sum(int n) { int i, summe = 0; for(i=1; i<=n; i++) summe += i; return summe; }
2. Gute Algorithmen finden!

bessere Algorithmen schneller, vollstndiger, korrekter, ... leistungsfhigere Datenstrukturen kompakter, effizienter, flexibler, ... Generell: Ersparnis an Rechenzeit und/oder Speicherplatz
Vergleiche mit anderem Programmieransatz, z.B. for- statt while-Schleife! alternativer Programmierstil (Warum?)
41
42
Alternative Realisierung (1) Zwei Alternativen 1. Alternativer Programmierstil

Problemlsungsansatz beibehalten, aber programmiertechnische Umsetzung berarbeiten
Alternative Realisierung (2) 2. Alternativer Lsungsweg

Wahl eines anderen Problemlsungsweges, z.B. Gausche Summenformel
Beispiel:
Schleifenform (siehe oben) Rekursion statt Iteration
Achtung! Was ist bei einem Aufruf n<0 zu beachten?
i =
i =1
n (n + 1) 2
int sum(int n) { if(n == 0) return 0; if(n == 1) return 1; else return n+sum(n-1); }

Umsetzung
int sum(int n) { return (n*(n+1))/2; }
E. Schikuta
43
44
Gute Algorithmen finden!

Vergleich der Laufzeiten
Summenberechnung, 100000 Wiederholungen, CPU: 200 MHz Pentium
100
Was ist gut? Oder vielleicht besser? Problem: Laufzeitenvergleich fhrt nur zu punktueller Qualittsbestimmung
Laufzeit, Speicherplatzverbrauch Abhngig von
Computer Betriebssystem Compiler, ...
10
Gau
1
for, while for, while (Opt.) Rekursion
0,1
Ziel: Methodik fr generellen Qualittsvergleich zwischen Algorithmen

Unabhngig von ueren Einflssen
0,01 100 1000 10000
E. Schikuta
E. Schikuta
45
46
1.2 Algorithmen-Paradigmen Generelle Techniken zur Lsung groer Klassen von Problemstellungen Greedy algorithms
gefriger, gieriger Ansatz, Wahl des lokalen Optimums
1.2.1 Greedy (1) In jedem Schritt des Algorithmus wird die Mglichkeit gewhlt, die unmittelbar (lokal) den optimalen (kleinsten bzw. grten) Wert bezglich der Zielfunktion liefert. Dabei wird die globale Sicht auf das Endziel vernachlssigt. Vorteil:
Effizienter Problemlsungsweg, oft sehr schnell, kann in vielen Fllen relativ gute Lsung finden
Divide-and-conquer algorithms
schrittweise Zerlegen des Problems der Gre n in kleiner Teilprobleme
Dynamic programming
dynamischer sukkzessiver Aufbau der Lsung aus schon berechneten Teillsungen
Nachteil:
Findet oft keine optimale Lsung
E. Schikuta
E. Schikuta
47
48
Greedy (2) Beispiel: Mnzwechselmaschine

Wechsle den Betrag von 18.- in eine mglichst kleine Anzahl von Mnzen der Gre 10.-, 5.- und 1.- greedy Ansatz:
whle grte Mnze kleiner als Betrag d.h.: gib die Mnze aus subtrahiere ihren Wert vom Betrag wiederhole solange bis Differenz gleich 0
18.8.3.2.1.- 10.- = - 5.- = - 1.- = - 1.- = - 1.- = 8.3.2.1.0
Greedy (3) DOCH

Problem bei kleiner nderung der Problemstellung: 5.- 6.Mnzwerte 10.-, 6.- , 1.greedy Ansatz liefert 18.- - 10.- = 8.- - 6.- = 2.- - 1.- = 1.- - 1.- = optimal wre aber 3 x 6.18.- - 6.- = 12.12.- - 6.- = 6.6.- - 6.- = 0 3 Mnzen
8.2.1.0
Lsung fr diese Problemstellung nicht nur gut sondern sogar optimal!

4 Mnzen
E. Schikuta
49
50
1.2.2 Divide-and-conquer (1) Ausgehend von einer generellen Abstraktion wird das Problem iterativ verfeinert, bis Lsungen fr vereinfachte Teilprobleme gefunden wurden, aus welchen eine Gesamtlsung konstruiert werden kann. Verschiedene Anstze Problem size division
Divide-and-conquer (2)
Zerlegung eines Problems der Gre n in eine endliche Anzahl von Teilproblemen kleiner n
Step division
Aufteilen einer Aufgabe in eine Sequenz (Folge) von individuellen Teilaufgaben
Case division
Diese Vorgangsweise wird auch oft mit stepwise refinement oder top-down approach bezeichnet Identifikation von Spezialfllen zu einem generellen Problem ab einer gewissen Abstraktionsstufe
51
52
Problem size division Durch Zerlegung Verringerung der Problemgre, d.h. P(n) k*P(m),
wobei k, m < n
Step division Idee: Straenkehrer-Philisophie: Atemzug - Besenstrich - Schritt Beispiel

Gehaltserhhung
Bestimme Mitarbeiter Finde eindeutige Identifikation Suche im Datenbestand Stelle aktuelles Gehalt fest ndere auf neues Gehalt Speichere Information Vermerke nderungsvorgang
Binre Suche
Suche eine Zahl x in der (aufsteigend) sortierten Folge z1,z2,..,zn (allgemein: zl,zl+1,..,zr mit l=1, r=n) und ermittle ihre Position i Zerlegung: k = 1 und m n/2 Trivial: finde mittleren Index m = (l+r)2 Falls zm=x Ergebnis m, sonst Falls x<zm suche x im Bereich zl,z2,..,zm-1 sonst suche x im Bereich zm+1,zm+2,..,zr
Suche Zahl 7
1 3 4 6 7 8 10 7 8 10 7
Speichere Information Lsche alte Datensatz Fge neuen Datensatz ein
E. Schikuta
E. Schikuta
53
54
Case division Ansatz: Identifikation von Fallunterscheidungen im Problemdatenbereich Beispiel

Berechnung der Lsungen zu einer quadratischen Gleichung
1.2.3 Dynamic Programming (1) Problem

Oft ist eine Teilung des Originalproblems in eine kleine Anzahl von Teilproblemen nicht mglich, sondern fhrt zu einem exponentiellen Algorithmus.
Man wei aber, es gibt aber nur eine polynomiale Zahl von Teilproblemen.
az + bz + c = 0
2
z1, 2 = (
1 2 b ) q ,q = b 2 4ac 2a 2a
Idee
nicht Start von Problemgre n und Aufteilung bis Gre 1, SONDERN
if q > 0, 2 reelle Wurzeln q = 0, reelle Doppellsu ng q < 0, Paar komplexer Wurzeln

Start mit Lsung fr Problemgre 1, Kombination der berechneten Teillsungen bis eine Lsung fr Problemgre n erreicht wurde.
55
56
Dynamic Programming (2)

Beispiel: Berechnung der Fibonacci Zahlen
int fib(int n) { if(n <= 1) return 1; return fib(n-1) + fib(n-2) } fib(4) fib(3) fib(2) fib(1) 1 fib(1) fib(0) 1 1 fib(1) 1 fib(2) fib(0) 1 fib(2) 2x berechnet fib(1) 3x berechnet fib(0) 2x berechnet
fib ( 0 ) 1
Dynamic Programming (3) Lsungsweg

Beginn mit Berechnung fr fib(0), Anlegen einer Tabelle aller berechneten Werte und Konstruktion der neuen Werte aus den berechneten Tabelleneintrgen.
Berechnungsrichtung
fib ( 1 ) 1 fib ( 2 ) 2 fib ( n ) fib ( n - 2 ) + fib ( n - 1 )
Beachte
Werte werden aus der Tabelle entnommen
Problem: Wiederholte Lsung eines Teilproblems

Verbesserung der Laufzeit ABER zustzlicher Speicherplatzbedarf

57
58
1.3 Analyse u. Bewertung von Algorithmen Ziel ist objektive Bewertung von Algorithmen Kriterien:
Effektivitt
Ist das Problem lsbar, ist der Ansatz umsetzbar in ein Programm? CW-Wert
Analogie: Auto Spezifische Kriterien

Auswahl
Sitzpltze Hubraum Leistung
Korrektheit
Macht der Algorithmus was er soll?
Termination
Hlt der Algorithmus an, besitzt er eine endliche Ausfhrungszeit? Hchstgeschwindigkeit Beschleunigung
Komplexitt
Wie strukturiert ist der Algorithmus Strukturkomplexitt? Wie schnell ist der Algorithmus Laufzeitkompexitt?
Statistische Kennzahlen Beurteilungsmglichkeit, Klassifikationsmglichkeit Sportwagen, Lastwagen, Familienlimousine, ...
E. Schikuta
E. Schikuta
59
60
Bewertung von Programmen Beipiel Sortierprogramm

Effektivitt
void selection(Element v[], int n) { int i, j, min; for(i = 0; i < n; i++) { min = i; for(j = i+1; j < n; j++) if(v[j] < v[min]) min = j; swap(v[min], v[i]); } }
1.3.1 Effektivitt Prinzip
Korrektheit
Algorithmus kann als lauffhiges Computerprogramm formuliert werden. effective it does work
Problem
Formulierung Transformation der Problembeschreibung in einen exekutierbaren Algorithmus
Ich will, brauche, mu haben ... So geht das!
Laufzeit
Struktur
Termination
Klassfikation schnell, korrekt, wartbar, problemberdeckend, endlich,

VO Algorithmen und Datenstrukturen E. Schikuta VO Algorithmen und Datenstrukturen
E. Schikuta
61
62
1.3.2 Korrektheit Produziert der Algorithmus das gewnschte Ergebnis? Zwei Vorgangsweisen mglich
Testen Formales Testen
Formales Testen Mathematisch orientierte Verifikationstechniken erlauben es, die Korrektheit von Programmstcken in Abhngigkeit von Bedingungen an die Eingabedaten (Prmissen) zu beweisen
McCarthy, Naur, Floyd, Hoare, Knuth, Dijkstra, etc.
Testen
Vollstndiges Austesten meist nicht mglich Statistischer Ansatz meist verfolgt, z.B. Pfadberdeckung (Strukturelle Komplexitt) Bestenfalls Falsifizierung erreichbar
Es knnen nur Fehler gefunden werden, aber es kann keine Korrektheit bewiesen werden
zwingt den Entwickler Entwurfsentscheidungen noch einmal nachzuvollziehen und hilft beim Auffinden logischer Fehler Algorithmus muss verstanden werden je grer ein Programmsystem, umso schwieriger die Verifikation (in der Praxis kaum von Bedeutung)
Beweisansatz abhngig vom Problem

63
64
Mathematischer Beweis Vollstndige Induktion

Beispiel: Gausche Summenformel
Verifikation Programm-Verifikation
verschiedene Anstze
Rckwrtsbeweis:
Ind. Anfang fr n = 1 1*2/2 = 1 Ind. Voraussetzung (1+2++n-1) = (n-1)*n/2 Ind. Schluss (1+2++n-1)+n = (n-1)n/2 +n = = ((n-1)n +2n)/2 = (n2-n+2n)/2 = = n(n+1)/2
i =
i =1
n ( n + 1) 2
Strukturierter Ansatz, beruht auf Prdikatentransformation berprfung, ob die Voraussetzungen (weakest preconditions, wp) an die Eingabedaten garantieren, dass das Programm in einem Zustand terminiert, der das gewnschte Programmziel erfllt. Man bezeichnet diese Programmziel, welches die Aufgabe des Programms beschreibt, als Korrektheitsbedingung
Hierzu darf das Programm nur aus einfachen Zuweisungen, Vergleichen, while-Form Schleifen und Anweisungsfolgen bestehen. Alle anderen Konstrukte mssen bersetzt werden.
E. Schikuta
E. Schikuta
65
66
Verifikation - Beispiel
Beispiel
int sum(int n) { int s = 0; i = 1; while(i <= n) { s = s + i; i = i + 1; } return s; }
1.3.3 Termination (1) Frage: Hlt der Algorithmus an, d.h. besitzt er eine endliche Ausfhrungszeit? Falls nicht klar, oft folgende Technik einsetzbar: Man finde eine Gre oder eine Eigenschaft des Algorithmus der die folgenden 3 Charakteristiken erfllt:
Eine 1-1 Abbildung dieser Gre auf die ganzen Zahlen kann aufgestellt werden. Diese Gre ist positiv. Die Gre nimmt whrend der Ausfhrung des Algorithmus kontinuierlich ab (dekrementiert).
Rckwrtsbeweis
Korrektheitsbedingung : s = i
i =1 n
(I) Schleifeninvariante SI SI: ( s = j ) (i n + 1)

j =1 i 1
(1) SI Bed KB s = ( j ) (i n + 1) (i > n) s = ( j ) (i = n + 1) s = j KB

j =1 j =1 j =1 i 1 i 1 n
(2) SI Bed wp ( Schleifenblock | SI ) wp ( s = s + i | wp (i = i + 1 | ( s = j ) (i n + 1))) wp ( s = s + i | ( s = j )

j =1 j =1 i 1 i
(i n + 1)) ( s + i = j ) (i n + 1) ( s = j ) (i n + 1) SI
j =1 j =1
i 1
(II) Rest des Programms wp ( s = 0 | wp (i = 1 | SI )) wp ( s = 0 | ( s = j ) (1 n + 1))

j =1 11
(0 = j ) ( 0 n )
j =1
n0
E. Schikuta
67
68
Termination (2) Idee: Die gefundene Gre besitzt bei Algorithmusbeginn einen vorgegebenen positiven Startwert, der sich kontinuierlich verringert. Da die Gre nie negativ werden kann, folgt, dass der Algorithmus terminieren muss, bevor die Gre kleiner 0 ist.
Gre n
1.3.4 Strukturelle Komplexitt

Bewertende Aussage ber den strukturellen Aufbau des Programms und der Programmteile untereinander, d.h. interne Attribute Bewertung des Programmierstils
Allgemein angenommen, dass Programmierstil mit den zu erwartenden Softwarewartungskosten korreliert.
Aussagen ber die Qualitt eines Softwareproduktes (externe Attribute)

Fehleranflligkeit Wartungsaufwand Kosten
Annahme: interne Attribute sind mit externen Attributen korreliert!
Beispiel:
int sum(int n) { if(n <= 0) return 0; if(n == 1) return 1; Dekrement else return n+sum(n-1); }
E. Schikuta
Termination bevor n < 0
These
komplexes Programm hohe Kosten klares Programm geringere Kosten
69
70
Grundsatz
Softwaremetriken Ziel Metriken (Mazahlen) zu finden, die den Aufbau, Struktur, Stil eines Moduls (Programmstcks) bewerten und vergleichen lassen. Anforderungen
Gltigkeit
Misst tatschlich was es vorgibt zu messen
When you can measure what you are speaking about and express in numbers you know something about it, but when you cannot measure it, when you cannot express it in numbers, your knowledge is of a meager and unsatisfactory kind. Lord Kelvin
Einfachheit
Resultate sind einfach verstndlich und interpretierbar
Sensitivitt
Reagiert ausreichend auf unterschiedliche Ausprgungen
Robustheit
Reagiert nicht auf im Zusammenhang uninteressante Eigenschaften
71
72
Messung der strukturellen Komplexitt Intra-modulare Komplexitt

Beschreibt die Komplexitt eines einzelnen SW Moduls Modul Komplexitt (intern)
LOC, Line-of-codes (simpel) NCSS, non commenting source statements McCabe (zyklomatische Komplexitt),
Zusammenhang Kupplung und Kohsion Kupplung

Misst Komplexitt der Beziehungen zwischen Moduln
Kohsion
Misst Informationsfluss von und nach Auen abhngig von der Modulgre
Kohsion (extern)
Henry-Kafura Metrik (Informationsfluss),
Meist Beziehung zwischen Kupplung und Kohsion
Inter-modulare Komplexitt
Beschreibt Komplexitt zwischen Moduln Kupplung
Fenton und Melton,
Starke Kupplung Schwache Kohsion

Schwache Kupplung Starke Kohsion

E. Schikuta
73
74
1.3.4.1 Intra-modulare Komplexitt Metrik von McCabe
Programmbeispiel
0: private sub foo (a as integer) 1: while a < limit do 2: process_1 a 3: if bar(a) then 4: process_2 a 5: elseif mumble(a) then 6: process_3 a 7: else 8: process_4 a 9: end if 10: end while Basis Menge 11: end sub Pfad 1: 1
1
Die Metrik von McCabe ist ein Ma zur Beurteilung der Modul Komplexitt
Basiert auf der zyklomatischen Komplexitt V: liefert die Anzahl der unabhngigen Pfade in einem Programmgraph
Bei einem unabhngigen Pfad wird mindestens eine 'neue' Kante im Programmablaufplan beschritten.
3 5 Region2 6 Region3 Region1 9 7 4
Erfahrungswerte fr die zyklomatische Komplexitt V(G) Einschtzung im Normalfall <5 5-10 > 10 > 20 einfach normal komplex, sollte restrukturiert werden schwer verstndlich, wahrscheinlich fehlerhaft
E. Schikuta
10
Region4 Details Kanten = 11 Knoten = 9 Bedingungsknoten = 3

E. Schikuta
11
Pfad 2: 1,3,4,10,1,11 Pfad 3: 1,3,5,6,9,10,1,11 Pfad 4: 1,3,5,7,9,10,1,11
75
76
Zyklomatische Komplexitt Mehrere Berechnungsmglichkeiten

1. Die Anzahl der Regionen im Programmgraph G 2. V(G) = E - N + 2 (E = Anz. d. Kanten, N = Anz. d. Knoten) 3. V(G) = P + 1 (P = Anzahl der binren Bedingungsknoten)
1.3.4.2 Intra-modulare Komplexitt Henry-Kafura Metrik
Ma zur Bestimmung der Kohsion

Beschreibt die funktionale Strke des Moduls; zu welchem Grad die Modulkomponenten dieselbe Aufgabe erfllen
Metrik von Sallie Henry and Dennis Kafura

Basiert auf Zusammenhang zwischen Modulkomplexitt und Verbindungskomplexitt zwischen Moduln
Zyklomatische Komplexitt des Beispiels

1. Regionen = 4 2. V(G) = 11 - 9 + 2 = 4 3. V(G) = 3 + 1 = 4 In unserem Beispiel ist die magische Zahl 4, d.h. einfaches Programm (Metrik McCabe < 5)
Ma fr Modulkomplexitt
LOC NCSS McCabe
E. Schikuta
E. Schikuta
77
78
Verbindungskomplexitt
Quantifizierung des lesenden und verndernden Zugriffs des Moduls auf die Umgebung FANIN Zhlt die Datenflsse zwischen Moduln
FAN-INm: Anzahl der Module die m verwenden Modul genauer: Anzahl der Datenflsse, die im Modul m terminieren + Anzahl der Datenstrukturen, aus FANdenen der Modul m Daten ausliest OUT FAN-OUTm: Anzahl der Module die m verwendet genauer: Anzahl der Datenflsse, die vom Modul m ausgehen + Anzahl der Datenstrukturen, die der Modul m verndert
Anwendung Von Henry und Kafura auf Unix Code angewendet

Annahme: Zusammenhang zwischen Komplexitt und nderungshufigkeit (Fehlerkorrektur) einer Prozedur 165 Prozeduren untersucht, Patch-Information aus Newsgroups Annahme besttigt: nderungen nehmen mit Komplexittsklasse zu
Probleme HK
Abh. vom Datenfluss, bei einem FAN = 0, gesamt 0 auch bei hoher Modulkomplexitt Wiederverwendbarkeit wird durch hohen FAN Wert bestraft
Henry-Kafura Formel
Cim * (FAN-INm * FAN-OUTm)2
Cim Modulkomplexitt (z.B. LOC, McCabe, )
E. Schikuta
E. Schikuta
79
80
1.3.4.3 Inter-modulare Komplexitt Fenton und Melton Metrik Ma zur Bestimmung der Kupplung Kupplung misst die Unabhngigkeit zwischen Moduln
Globale Kupplung eines Programms wird abgeleitet aus den Kupplungswerten zwischen allen mglichen Modulpaaren
Berechnung der Kupplung Fenton-Ma fr die Kupplung zwischen 2 Moduln

c(x,y) = i + n/(n+1)
i ist der schlechteste Kupplungstyp zwischen Modul x und y n ist die Anzahl der Kupplungen vom Typ i
Kupplungstypen
Binre Relationen definiert auf Paaren von Moduln x, y
Nach dem Grad der Unerwnschtheit geordnet
0. No coupling: keine Kommunikation zwischen x und y 1. Data coupling: Kommunikation ber Parameter (Daten) 2. Stamp coupling: akzeptieren selben Record-Typ als Parameter 3. Control coupling: Kommunikation ber Parameter (Kontrolle) 4. Common coupling: Zugriff auf selbe globale Datenstruktur 5. Content coupling: x greift direkt auf interne Struktur von y zu (ndert Daten, Anweisungen)
Ma C(S) fr die globale Kupplung eines Systems S bestehend aus n Moduln D 1, , Dn

C(S) = Median der Menge der Kupplungswerte aller Modulpaare
E. Schikuta
E. Schikuta
81
82
1.3.5 Laufzeitkomplexitt Aussagen ber das Laufzeitverhalten von Algorithmen in Abhngigkeit von der Problemgre Ziel
Algorithmen zu vergleichen
int sum(int n) int s = 0; int i = 1; while(i <= n) { s = s + i; i = i + 1;} return s; }
Summe-Beispiel: simpler Ansatz

Zeit in msec T1 0.1 T2 0.1 T3 0.3 T4 0.1 T5 0.1 T6 0.1
Gemessene Zeiten im Programm
1000,0
Ansatz
Messen der Ausfhrungszeit der einzelnen Anweisungen Bestimmen, wie oft jede Anweisung beim Programmablauf ausgefhrt wird Summe berechnen
100,0
10,0 Laufzeit 1,0 100 1000
Berechnung der Laufzeit

fsum(n) =T1+T2+n*(T3+T4+T5)+T3+T6 10 fsum(10) = 0.1+0.1+10*(0.3+0.1+0.1)+0.3+0.1 = 5.6 fsum(100) = 0.1+0.1+100*(0.3+0.1+0.1)+0.3+0.1 = 50.6 fsum(1000) = 0.1+0.1+1000*(0.3+0.1+0.1)+0.3+0.1 = 500.6 fsum(n) = 0.6 + n*(0.5)
Problem
Ausfhrungszeiten abhngig von Maschinen- bzw. Systemarchitektur, bersetzungsqualitt des Compilers, etc.
E. Schikuta
83
84
Probleme des simplen Ansatzes Entspricht einem Ansatz des Ausprobierens Nur punktuell mglich
bestimmte Problemgre, Datenverteilung
Ordnungsnotation Grundprinzip
Die exakten Werte der Ausfhrungszeiten sind uninteressant!
Sonderflle problematisch Systemabhngig

Hardware, Prozessor, ... Betriebssysteme, Compiler, Bibliotheken, ...
Ordnungsnotation
Man mchte Aussagen treffen (siehe Ziel), dass Algorithmus A grob gesehen gleich schnell wie Algorithmus B ist.
Durch Beschreiben der Laufzeiten von A und B ber Funktionen f(n) und g(n) wird diese Fragestellung auf Vergleich dieser Funktionen zurckgefhrt.
Lastabhngig Frage schwer zu beantworten, ob graduelle oder grundstzliche Verbesserung erreichbar

Man betrachtet das asymptotische Wachstum der Ausfhrungszeiten der Algorithmen bei wachsender Problemgre n.
85
86
Big - O / / - Notation
Big-O-Notation: Eine Funktion f(n) heit von der Ordnung O(g(n)), wenn zwei Konstanten c0 und n0 existieren, sodass f(n) c0g(n) fr alle n > n0.
liefert eine Obergrenze fr die Wachstumsrate von Funktionen fO(g), wenn f hchstens so schnell wie g wchst.
z.B.: 17n2 O(n2), 17n2 O(2n)
Summen-Beispiel
Laufzeitschtzung: fsum(n) =T1+T2+n*(T3+T4+T5)+T3+T6
Messung: T1=0.1, T2=0.1, T3=0.3, T4=0.1, T5=0.1, T6=0.1 reale Werte, in der Implementierung gemessen
ergibt fsum(n) =0.6+n*(0.5) g(n)=n Untergrenze: 0.1*g(n) Obergrenze: h(n)=1*g(n)

1000
Big--Notation: Eine Funktion f(n) heit von der Ordnung (g(n)), wenn zwei Konstanten c0 und n0 existieren, sodass f(n) c0g(n) fr alle n > n0.
liefert eine Untergrenze fr die Wachstumsrate von Funktionen fO(g), wenn f mindestens so schnell wie g wchst.
z.B.: 17n2 (n2), 2n (n2), n37 (n2)
eine von vielen mglichen Grenzen
n 0.6 0.1 . n 0.5 . n 500
200
400 n
600
800
1000
- Notation: Das Laufzeitverhalten ist (n) falls gilt: f(n)=O(n) und f(n)=(n) (beschreibt das Laufzeitverhalten exakt)
daraus folgt bezglich der Ordnung des Algorithmus fsum(n) O(n) und weiters fsum(n) (n), d.h. fsum(n) (n).
Die daraus fr unser Beispiel ableitbare Aussage lautet, dass die Laufzeit des Algorithmus direkt proportional zur Problemgre n ist
87
88
Laufzeitvergleich (1)
Laufzeitenvergleich
Annahme vorgegebene Problemgre und unterschiedliches Laufzeitverhalten
Ordnung log n n n n log n n n n2 n3 2n Laufzeit 1.2 x sec 3.2 x 10 -4 sec 0.1 sec 1.2 sec 31.6 sec 2.8 h 31.7 a ber 1 Jahrhundert 10 -5
100
n n . log ( n ) n n 2 3 400 600 1000
Laufzeitvergleich (2)
Beschreibung des Laufzeitverhaltens
durch obere O(n) und untere Schranke (n) z.B.: T(n) = 1.5n2 + 5n - 200 O(n2), da n2 T(n) 2n2
6 1 10
800
200
3 n
0 20 40 n 60 80 100
5 8 10
2 2. n 2 1.5. n 2 n n 5. n
5 6 10 200
80 n n log ( n ) 40
5 4 10
60
5 2 10
20
0
0 200 400 n 600 800 1000
200
400 n
600
800
1000
E. Schikuta
E. Schikuta
89
90
Analyseansatz Prinzipien der mathematischen Analyse

Definition der Problemgre n
Finden eines geeigneten Problemparameters der die Problem-gre beschreibt. Dieser charakterisiert die Belastung (= f(n))
Praktische Laufzeitanalyse Ignoriere konstante Faktoren

Konstante Werte werden auf den Faktor 1 reduziert, d.h.
T(n) = 13 * n O(n) T(n) = log2 (n) O(log(n)), da logx(n) = loga(n) / loga(x)
worst-case versus average-case

worst-case: Verhalten im schlechtesten Fall, maximal zu erwartender Aufwand average-case: Verhalten, Erwartungswert des Aufwandes
Merke nur hchste Potenz

Ignoriere alle anderen Potenzen auer der hchsten
T(n) = n2 - n + 1 O(n2)
Laufzeitanalyse ber O(n) und (n) oft schwierig zu bestimmen

Ignoriere konstante Faktoren Merke nur hchste Potenzen
Daher in Kombination:
T(n) = 13*n2 + 47*n 11*log2(n) + 50000 O(n2)
E. Schikuta
E. Schikuta
91
92
Beispiel: Laufzeitanalyse Bubblesort

void bubble(Element v[], int n) { int i, j; Problemgre n T1 for(i = n-1; i >= 1; i--) T2 for(j = 1; j <= i; j++) T3 if(v[j-1] > v[j]) T4 swap(v[j-1], v[j]); T5 } Rekurrenzgleichung Informeller Ansatz: Annahme finden T1 = ... T5 = T(n) = T1 + (n-1)*(T2 + (n-1)*(T3+T4 +T5)) =1 T(n) = 1+(n-1)*(1+(n-1)*(1+1+1)) = 3n2-5n-3 Ignoriere konstante Faktoren T(n) = n2-n-1 Merke hchste Potenz
Rekurrenzen
Einfache Rekursion Einige wichtige Rekurrenzen
int sum(int n) { if(n <= 0) return 0; T1 if(n == 1) return 1; T2 return n + sum(n-1); T3+T(n-1) } T(n) = T1+T2+T3+T(n-1) T(n) = T(n-1) + 1 T(n) = T(n-2) + 1 + 1 T(n) = 1 + + 1 + 1 n T(n) = O(n)
T(n) = T(n-1)+n T(n) = n*(n+1)/2 = O(n2) T(n) = T(n/2)+1 T(n) = ld n = O(log n) T(n) = T(n/2)+n T(n) = 2*n = O(n)
T(0)=T(1)=1
T(n) = 2*T(n/2)+n T(n) = n*ld n = O(n*log n) T(n) = 2*T(n/2)+1 T(n) = 2*n = O(n)
T(n) = O(n2) = (n2) = (n2)
worst-case = best-case = average case

E. Schikuta
E. Schikuta
93
94
Algorithmische Lcke
Eine algorithmische Lcke fr ein Problem existiert, falls fr die bekannten problemlsenden Algorithmen A gilt, dass ihr Aufwand grer als der ableitbare Lsungsaufwand fr das Problem P ist. Ziel:
O(A) dient zur Beschreibung des Algorithmus (P) dient zur Beschreibung des Problems
die algorithmische Lcke zu schlieen, d.h. (P) = O(A)
1.3.6 Laufzeitanalyse von rekursiven Programmen Die Laufzeitanalyse von rekursiven Programmen ist meist nicht-trivial
Bis jetzt nur taxativ gelst
Probleme
Palt Pneu
(P) O(A)
algorithmische Lcke
Algorithmen
Aneu Aalt
Laufzeitverhalten eines rekursiven Programms lsst sich durch eine Rekurrenz beschreiben Beispiel: Mergesort
if n = 1 (1) T ( n) = 2T ( n / 2) + ( n) if n > 1 wobei folgende Lsung angegeben wurde T ( n) = (n log n)
(n)
(n log n)
Geschlossene Lcke
Aufwand
O(n2)
O(n3)
Suchen in sortierter Sequenz, T(A) = log(n) Sortieren, T(A) = n*log(n)
Offene Lcke
Graphenisomorphie, T(Anaiv) aus O( |V|! )
95
96
Lsungsanstze Wir betrachten unterschiedliche Lsungsanstze Substitutionsmethode

Erraten einer asymptotischen Grenze und Beweis dieser Grenze durch Induktion
Master Theorem Kochrezept zur Bestimmung des Laufzeitverhaltens

Vereinfachte Form (generelle Version Cormen et al. pp. 62)
Iterationsmethode
Umwandlung der Rekurrenz in eine Summe und Anwendung von Techniken zur Grenzwertberechnung von Summen
Mastermethode
Liefert Grenzen fr Rekurrenzen der Form T(n) = aT(n/b) + f(n), wobei a 1, b > 1 und f(n) ist eine gegebene Funktion
Es seien a 1, b 1 und c 0 Konstante T(n) ist definiert durch aT(n/b) + (nc) wobei n/b entweder n/b oder n/b ist T(n) besitzt dann den folgenden asymptotischen Grenzwert
Fall 1: wenn c < logba dann T(n) = (nlog a) Fall 2: wenn c = logba dann T(n) = (nc log n) Fall 3: wenn c > logba dann T(n) = (nc)
b
E. Schikuta
97
98
Beispiel
Binres Suchen
int bs (int x, int z[], int l, int r) { if (l > r) // Schwelle, kein Element vorhanden return -1; // 0 verboten, da gltiger Indexwert! else { int m = (l + r) / 2; if (x == z[m]) // gefunden! return m; else if (x < z[m]) return bs(x, z, l, m-1); else // x > z[m] Fall 1: wenn c < logba dann T(n) = (nlogba) return bs(x, z, m+1, r); } Fall 2: wenn c = logba dann T(n) = (nc log n) } Fall 3: wenn c > logba dann T(n) = (nc)
Weitere Beispiele
Fall 1: wenn c < logba dann T(n) = (nlogba) Fall 2: wenn c = logba dann T(n) = (nc log n) Fall 3: wenn c > logba dann T(n) = (nc)
Beispiel: Mergesort
a = 2, b = 2, c = 1
T(n) = 2T(n/2) + n = 2T(n/2) + (n)
Fall 2, da c = logba 1 = log22, ergibt T(n) = (n log n)
Beispiel: T(n) = 4T(n/2) + n = 4T(n/2) + (n)

a = 4, b = 2, c = 1
Fall 1, da c < logba 1 < log24, ergibt T(n) = (nlog 4) = (n2)

2
Laufzeit: T(n) = T(n/2) + 1 = T(n/2) + (1)

Fall 2, da c = logba 0 = log21, ergibt T(n) = (log n)
Beispiel: T(n) = T(n/2) + n = T(n/2) + (n)

a = 1, b = 2, c = 1
a = 1, b = 2, c = 0
Fall 3, da c > logba 1 > log21, ergibt T(n) = (n1) = (n)

99
100
Was nehmen wir mit? Algorithmenparadigmen

Greedy, Divide and Conquer, Dynamic Programming
Analyse und Bewertung von Algorithmen

Effektivitt, Korrektheit, Termination
Kapitel 2: Datenstrukturen
Strukturkomplexitt
McCabe, Henry-Kafura, Fenton
Laufzeitkomplexitt
Ordnungsnotation, Algorithmische Lcke, Master Theorem
E. Schikuta
E. Schikuta
101
102
2.1 Situation
Jim Gray, 97
Magnetische Platten sind billiger als Papier Dateischrank:

cabinet (4 drawer) paper (24,000 sheets) space (2x3 @ 10$/ft2) total 250$ 250$ 180$ 700$
Datenstrukturen (Datenbanken) speichern ALLE Daten

The Old World: Millionen von Objekten 100-Byte Objekte
People
Name Address
The New World: Milliarden von Objekten Groe Objekte (1MB)
3 /sheet Platte:
disk (4 GB =) 500$ ASCII: 2 m pages
David Mike Won
NY People Berk
Name Address Papers Picture Voice
Austin
David NY Mike Berk
Won Austin
Paperless office Library of congress online All information online entertainment publishing business Information Network, Knowledge Navigator, Information at your fingertips
E. Schikuta VO Algorithmen und Datenstrukturen
(100x cheaper) 0.025 /sheet Image: 200 k pages (10x cheaper) .25 /sheet Conclusio: Speichere alles auf Platten
E. Schikuta
103
104
Moores Law XXX verdoppelt sich alle 18 Monate 60% Steigerung pro Jahr
Micro Prozessor Geschwindigkeit Chip Dichte Magnetische Platten Dichte Kommunikationsbandbreite 1GB 128MB WAN Bandbreite 1 chip memory size 8MB ( 2 MB to 32 MB) nhert sich LAN
1MB 128KB 8KB 1970 1980 1990 2000
Beispiele (1) Magellan Projekt

Satellit umkreiste die Venus, Radarabtastung zur Oberflchendarstellung Sandte 3 Terabyte Daten Rendering der Daten bentigt 13 Gigabyte / sec
Zur Zeit technisch nicht durchfhrbar!
Wettervorhersage
Zirkulationsmodelle der Atmosphre und der Ozeane
1000 Jahre Simulation, 150 km2 Auflsung, 0.2 simulierte Jahre / Maschinenstunde Ein Durchlauf auf Intel Touchstone Delta 57 Wochen
bits: 1K 4K 16 64K 256K 1M 4M 16M64 256M K M
40 MB Daten /Simulationsminute = 20 Terabytes

E. Schikuta
105
106
Beispiele (2)
CERNs Herausforderung: Datagrid Neuer Beschleuniger LHC mit 4 Detektoren
Large Hadron Collider, 14 TeV Ziele: Suche nach Higgs Boson und Graviton (et al.) Start 2007
Detector Online Readout multi-level trigger filter out background reduce data volume
26,7 km Umfang 100 Meter tief
40 M
leve l1-
Hz
Ziele
Weltweiter Zugriff auf die Daten
CERN und Regional Centers (Europa, Asien, Amerika) 2000 Benutzer
Riesige Datenvolumen Daten Semantik Performance und throughput
B/se data c) offli record ne a ing & naly sis

B/se spec c) 7 ial h leve 5 KH z (75 ardwa l2 5 K embedde GB/sec) re Hz dp leve (5 GB/ rocesso sec) l3rs 10 P (100 0 Hz Cs M
(40 T
E. Schikuta
107
108
Gigantische Datenmengen Charakteristische Gren (geschtzt)

1-6 (vielleicht 100 ?) Petabyte / Jahr
Zeitraum 15 bis 20 Jahre
Gre: Was ist ein Petabyte?

1 Petabyte = 2 hoch 50, i.e. (1,125,899,906,842,624) bytes 1015 bytes
1,000,000,000,000 business letters 100,000,000,000 book pages 50,000,000,000 FAX images 10,000,000,000 TV pictures (mpeg) 4,000,000 LandSat images 150,000 miles of bookshelf 15,000 miles of bookshelf 7,000 miles of bookshelf 10,000 days of video
10500 Knoten 2.1 Petabyte Platten Platz 340 Gigabyte IO Bandbreite Tapes ???
Library of Congress (in ASCII) enthlt 0.025 Petabyte Aktuelle und zuknftige Projekte generieren weit mehr Daten Auf uns warten Exa-, Zeta-, Yotta Byte !!!
109
110
Geschwindigkeit: Speicherzugriffszeiten
Wie weit sind die Daten entfernt ?
SternbildAndromdeda Andromeda Tape /Optical Robot
Pluto
2.2 Motivation Beispiel: 100 Telefonnummern zu verwalten Ein Haufen Zettel mit Namen und Nummern
Finden einer Telefonnummern durch sequentielle Suche bentigt im Durchschnitt 50 Zugriffe
10 9 Clock Ticks
2,000 Years
106 Disk
2 Years
Zettel nach dem Namen sortiert

Suche durch binres Aufteilen (in die Mitte, Schlsselvergleich und dann links oder rechts davon weitersuchen) Ungefhr ld 100 7 Zugriffe
100 10 2 1
Memory On Board Cache On Chip Cache Registers
Linz Sacramento
1.5 hr
This Campus 10 min This Room My Head 1 min

E. Schikuta
Rolodex
Zettel sortiert, in Ordnern und mit Namensindex Ziel mit einem (1!) Zugriff gewnschte Nummer
111
112
Ziele Information effizient zu verwalten! Was bedeutet effizient?

Quantitative Ziele
Zugriffszeit schnelles Einfgen, Verndern, Lschen, ... (d.i. Bearbeiten im weitesten Sinn) der Daten Speicherplatz kompaktes Speichern der Information
Datenstrukturen
Erfllung dieser Ziele fhrte zur Entwicklung von
Datenstrukturen
Datenstrukturen dienen zur Verwaltung groer Mengen hnlicher Objekte
Unterschiedliche Datenstrukturen dienen zur Verwaltung unterschiedlicher Objekte, die durch unterschiedliche Eigenschaften charakterisiert sind, daraus folgt:
Qualitative Ziele
Untersttzung spezifischer Zugriffsarten auf Eigenschaften bzw. Charakteristiken der Daten
Fr unterschiedliche Problemstellungen unterschiedliche Datenstrukturen!
E. Schikuta
E. Schikuta
113
114
Beispiel: Telefonbuchverwaltung
Suche in einem Telefonbuch mit 2000000 Eintrgen
Annahme: Zugriff auf einen Datensatz in 0,01 ms
2.3 berblick Alle bekannten Datenorganisationsformen bauen auf einigen wenigen einfachen Techniken auf Sequentielle Techniken
Listen Stack, Queue
Anstze (Zeit fr einen Zugriff)

Sequentielles Suchen (im Mittel 1000000 * 0,01 ms = 10 s) Baumstruktur (ungefhr ld 2000000 * 0,01 = 0,21 ms) Hashverwaltung (1 Zugriff = 0,01 ms)
Zugriffzeit im Verhltnis zur Dateigre

10000 1000
Baumstrukturen
Sequentiell Baumstruktur
100
Binrer Baum, B+-Baum, Priority Queue
10
Hashverfahren
Dictionary, Hash Tabelle, Kollisionsverfahren
Hashverfahren
0,1
0,01 1 10 100 1000 10000 100000 1000000
E. Schikuta
115
116
Liste Eine Liste (list) dient zur Verwaltung einer beliebig Anzahl von Elementen eines einheitlichen Typs.
Die Elemente werden in einer Sequenz angeordnet, die sich (meist) aus der Eintragereihenfolge ableiten lsst (ungeordnet). Der Aufwand des Zugriffes auf ein einzelnes Element ist abhngig von der Position in der Sequenz.
... Kopf Ende
Spezielle Listen Stack (Keller)

Elemente werden nach dem LIFO (last-in, first-out) Prinzip verwaltet
Anwendungen: Kellerautomaten, Speicherverwaltung, Evaluationsordnung
Queue (Schlange)
Elemente werden nach dem FIFO (first-in, first-out) Prinzip verwaltet
Anwendungen: Warteschlangen, Bufferverwaltung, Prozessmanagement, Stoffwechsel
Anwendungen
sequentielle Datenbestnde, groe Datenmengen, externe Speicherung
117
118
Baum Der Baum (tree) stellt eine Generalisierung der Liste auf eine 2-dimensionale Datenstruktur dar.
besteht aus Knoten und Kanten Exponentieller Zusammenhang zwischen Tiefe des Baumes und Anzahl der Knoten Anwendungen: allgemeine Schlsselverwaltung, Haupt- und Externspeichermanagement
Spezielle Bume Binrer Baum

Knoten haben max. 2 Nachfolger, Hauptspeicherverwaltung Binrer Suchbaum
geordneter binrer Baum, Werteverwaltung
Heap
ungeordneter binrer Baum, Warteschlangen
B+-Baum
balanzierter Mehrwegbaum, Externspeicherverwaltung, Datenbanksysteme
Trie
Prefix-Baum, Zeichenkettenverwaltung, Wrterbcher
119
120
Vektor Ein Vektor (vector, Feld) verwaltet eine fix vorgegebene Anzahl von Elementen eines einheitlichen Typs.
Zugriff auf ein Element ber einen ganzzahligen Index (die Position im Vektor) Aufwand des Zugriffes fr alle Elemente konstant
x0 x1 x2 xn-1 xn
Spezielle Vektoren Hash Tabelle

Der Index eines Elements wird aus dem Element selbst berechnet (ber eine Hashfunktion h(x)) Anwendungen: Verwaltung von Tabellen (Compilertables, Namenslisten, ), bedingt Externspeicher-Management
Dictionary
Der Index eines Elementes kann beliebigen Typ haben und wird mit dem Element gemeinsam gespeichert Anwendungen: Verwaltung komplexer (zusammengesetzter) Informationen, Zuordnungslisten
Anwendungen
Verwaltung fix vorgegebener Anreihungen, Strings, math. Konzepte
E. Schikuta
121
122
Vergleichskriterien Dynamik
Datenverwaltung
Einfgen, Lschen
Informeller Vergleich
Datenstruktur
Liste
Strken
dynamisch beliebige Datenmenge klares Modell geringer Speicherplatz dynamisch beliebige Datenmenge logarithmischer Aufwand der Operationen dynamisch direkter Elementzugriff konstanter Aufwand der Operationen
Schwchen
linearer Aufwand der Operationen simples Modell Balanzierungsalgorithmen aufwendigerer Speicherplatzverbrauch komplexes Modell oft fixe Datenmenge eingeschrnkte Operationen
Datenmenge
beliebige oder fixe Anzahl von Elementen
Aufwand
Laufzeit der Operationen Speicherplatzverbrauch
Baum
Modell
Operationenumfang
Vektor
E. Schikuta
E. Schikuta
123
124
Was nehmen wir mit? Datenorganisation

Effizienz Quantitt - Qualitt Kapitel 3:
Datenstrukturen
Typen Vergleichskriterien
Listen
E. Schikuta
E. Schikuta
125
126
3.1 Definition Listen Eine (lineare) Liste ist eine Datenstruktur zur Verwaltung einer beliebig groen Anzahl von Elementen eines einheitlichen Typs.
Der Zugriff auf die einzelnen Elemente einer (simplen) Liste ist nur vom Kopf (Head) aus mglich. Das Ende der Liste wird auch als Tail bezeichnet. Die Elemente werden in einer Sequenz angeordnet, die sich (meist) aus der Eintragereihenfolge ableiten lt (ungeordnet).
Abstraktion Datenstrukturen stellen eine Abstraktion eines Vorstellungsmodells dar

Begriff des abstrakten Datentyps ADT
Sagt nichts ber die physische Realisierung am Computer aus

Verschiedene Realisierungen denkbar! Realisierung oft abhngig von Problemstellung, Programmierumgebung, Zielsetzungen, ... Mgliches Vorstellungsmodell Liste Perlenschnur, Perlen werden an einem Ende aufgefdelt
... Kopf
Ende
127
128
Liste Definition:
Eine Liste L ist eine geordnete Menge von Elementen L = (x1, x2, , xn) Die Lnge einer Liste ist gegeben durch |L| = |(x1, x2, , xn)| = n Eine leere Liste hat die Lnge 0. Das i-te Element einer Liste L wird mit L[i] bezeichnet, daher gilt 1 i |L| Einfgen
Element am Kopf einfgen
Methoden auf Listen
Zugriff
Kopfelement bestimmen
Lschen
Kopfelement entfernen
andere Operationen denkbar siehe spter!
Erzeugen
Liste neu anlegen
Lngenbestimmung
Anzahl der Elemente bestimmen
Inklusionstest
Test, ob Element enthalten ist
E. Schikuta
E. Schikuta
129
130
Methode Einfgen Methode Add

Einfgen eines Elementes a am Kopf einer Liste L, d.h.
L = (x1, x2, , xn), x0 Add(L, x0) L = (x0, x1, , xn) Vorstellungsmodell Perlenschnur: Perle auffdeln x1 x2 ... xn
Methode Zugriff Methode FirstElement

Zugriff ber das Kopfelement (x1, das erste Listenelement) auf die Liste , d.h.
L = (x1, x2, , xn) FirstElement(L) x1
Fehler falls Liste leer
x0
x1
Vorstellungsmodell Perlenschnur: Perle betrachten und Eigenschaften feststellen xn
x2
...
x1
x0
x1
x2
...
xn
E. Schikuta
liefert den Wert des Elements, NICHT das Listenelement !

131
132
Methode Lschen Methode RemoveFirst

Lscht das Kopfelement (x1, das erste Listenelement) aus der Liste L, d.h.
L = (x1, x2, , xn), mit |L| = n RemoveFirst(L) L = (x2 , xn), mit |L| = n-1 x1 x2 x3 ... xn Vorstellungsmodell Perlenschnur: Perle abziehen
Methode Erzeugen Methode Constructor'

Erzeugt eine neue Liste, die leer ist, d.h. keine Elemente enthlt und daher die Lnge 0 hat,
Constructor() L, mit |L| = 0 Vorstellungsmodell Perlenschnur: Perlenschnur vorbereiten
x2
x3
...
xn
133
134
Methode Lngenbestimmung Methode Length

Bestimmt die Anzahl der Elemente der Liste L, d.h.
L = (x1, x2, , xn), mit |L| = n Length(L) n
Methode Inklusionstest Methode Member

berprft, ob ein gegebenes Element a in der Liste L enthalten ist, d.h.
L = (x1, x2, , xn) Member(L, a) [true, false] Vorstellungsmodell Perlenschnur: Perle mit spezifischer Eigenschaft suchen xn
x1
x2
...
xn Vorstellungsmodell Perlenschnur: Anzahl Perlen bestimmen
true i | 1 i |L| a = xi false sonst
n
liefert den ganzzahligen Wert n
x1
...
...
true
135
136
Klasse Listen Deklaration C++, Klasse

typedef ItemType; class List { public: List(); // Constructor void Add(itemType a); ItemType FirstElement(); void RemoveFirst(); int Length(); int Member(itemType a); }
3.2 Implementierung von Listen Speichertypen

Contiguous memory
zur Verwendung in der Klassen Def., besserer Ansatz mit C++ Templates
22200 22208 22216 22224 22232 22240 22248 22256 22264 22200 22208 22216 22224 22232 22240 22248 22256 22264
Scattered (Linked) memory
E. Schikuta
E. Schikuta
137
138
Memory Typen
Contiguous memory
Physisch zusammenhngender Speicherplatzbereich, uerst starr, da beim Anlegen die endgltige Gre fixiert wird. Verwaltung ber das System. Datenstrukturen auf der Basis von contiguous memory knnen nur eine begrenzte Anzahl von Elementen aufnehmen.
C++ Konstrukt: Feld Contiguous memory

Ein Feld bzw. Array ist einer Anreihung einer fixen Anzahl von Elementen des gleichen Typs.
Der Zugriff auf ein einzelnes Feldelement erfolgt ber eine Index (die relative Position im Feld). Der Index startet oBdA mit 0 und endet mit Anzahl-1. Vereinbarung
<ETyp> <Feldname>[<EZahl>] z.B.: double x[10]; int a[10000]; char name[25];
Scattered (Linked) memory

Physisch verteilter Speicherbereich, sehr flexibel, da die Ausdehnung dynamisch angepat werden kann. Verwaltung ber das Programm. Datenstrukturen knnen beliebig gro werden.
Zugriff
<Feldname>[index] z.B.: x[0] = 3.1415 * r * r; a[9999] = 0;
E. Schikuta
E. Schikuta
139
140
C++ Konstrukt: Dynamische Objekte Scattered memory

Dynamische Objekte
Objekte die zur Laufzeit des Programmes durch Programmanweisungen erzeugt und fr die Speicherplatz angelegt wird. Diese Objekte besitzen keinen Namen und werden ber sog. Zeiger (Pointer) verwaltet. z.B.:
double x = 3.14159; double* p = &x; // & liefert Adr. von x cout << *p; // * deref. Ptr., d.h. // druckt 3.14159
C++ Konstrukt: Dynamische Objekte

Erzeugung bzw. Zerstrung
new erzeugt ein neues Objekt delete zerstrt ein existierendes Objekt
double * p = new double; * p = 3.14159; 22208 p 22200 3.14159 22208 delete p; p 22200
Achtung:
p = 0 // erlaubt, // Initialisierung p = 4711 // verboten // Adressmanipulation
alter, undefinierter Wert
22208 3.14159 vom System freigegeben
Operatoren
x p 22192 22200
Zeiger bzw. Pointer

Eine Variable, die die Adresse eines Objekts (Adressoperator &) enthlt
3.14158 22192
& ... liefert die Adresse des Objekts * ... dereferenziert den Zeiger und liefert den Inhalt der ref. Objektes -> ... Zugriff auf eine Strukturkomponente ber einen Zeiger, d.h. x->y entspricht (*x).y
141
142
3.2.1 Liste - statisch - Struktur Statische Implementation - contiguous memory

Speichern der Elemente in einem Feld begrenzter Lnge
typedef int ItemType; class List { private: p ItemType list[8]; // Datenstruktur int p; // nchste freie Position } list 0 1 2 3 4 5 6 7 Lnge = 8
Liste - statisch Erzeugen - Zerstren - Einfgen Erzeugen,

List::List() {p = 0;}
Zerstren
List::~List() {p = 0;}
Einfgen
void List::Add(ItemType a) { if(p < 8) { list[p] = a; p++; } else cout << "Error-add\n"; }
E. Schikuta
E. Schikuta
143
144
Liste - statisch - Zugriff - Lschen
Liste - statisch Lnge - Inklusionstest Lnge,

int List::Length() { return p; }
Zugriff
ItemType List::FirstElement() { if(p > 0) return list[p-1]; else cout << "Error-first\n"; }
Inklusionstest
int List::Member(ItemType a) { int i = 0; while(i < p && list[i] != a) i++; if(i < p) return 1; else return 0; }
Lschen
void List::RemoveFirst() { if(p > 0) p--; else cout << "Error-remove\n"; }
E. Schikuta
145
146
3.2.2 Liste - dynamisch - Struktur (1) Dynamische Implementation - linked memory

Dynamisch erweiterbare Liste unbegrenzter Lnge
typedef int ItemType; class List { public: class Element { // Elementklasse ItemType value; Element* next; }; Adr. 0 kenzeichnet Element* head; // DS Kopf Ende der Liste Element } value next
Rekursive Datenstruktur Eine Datenstruktur heit rekursiv oder zirkulr, wenn sie sich in ihrer Definition selbst referenziert
Basismodell fr dynamisch erweiterbare Datenstrukturen
Liste class Element{ InfoType Info; Element* Next; } Baum class Node { KeyType Key; Node* LeftChild; Node* RightChild; }
head
E. Schikuta
147
148
Liste - dynamisch - Einfgen Einfgen

void List::Add(ItemType a) { Element* help; help = new Element; help->next = head; Typischerweise help->value = a; am Kopf der Liste head = help; }
Liste - dynamisch Erzeugen - Zerstren Erzeugen, Lschen

List::List() { head = 0;} List::~List() { Element* help; while(head != 0) { help = head; head = head->next; delete help; help } } head
Vor dem Einfgen head

0
Anfang 1. Durchlauf 2. Durchlauf

0
E. Schikuta
E. Schikuta
149
150
Liste - dynamisch - Zugriff Zugriff

ItemType List::FirstElement() { if(head != 0) return head->value; else cout << "Error-first\n"; }
Liste - dynamisch - Lschen Lschen

void List::RemoveFirst() { if(head != 0) { Element* help; help = head; head = head->next; delete help; } else cout << "Error-remove\n"; } Vor dem Lschen head
0
E. Schikuta
E. Schikuta
151
152
Liste - dynamisch - Lnge Lnge

int List::Length() { Element* help = head; int length = 0; while(help != 0) { length++; help = help->next; } return length; } help head
0
Liste - dynamisch - Inklusionstest Inklusionstest

int List::Member(ItemType a) { Element* help = head; while(help != 0 && help->value != a) help = help->next; if(help != 0) return 1; else return 0; } help head
Checkpoint Anfang, 1. Durchlauf 2. Durchlauf 3. Durchlauf length: 0 length: 1 length: 2 length: 3
?
E. Schikuta
153
154
Liste - Traversieren
Sequentielles Abarbeiten einer Liste, Besuchen aller Elemente
head 1. Initialisieren des Hilfszeigers
help = head;
help head
0
3.3 Stack
Der Stack (Kellerspeicher) ist ein Spezialfall der Liste, die die Elemente nach dem LIFO (last-in, first-out) Prinzip verwaltet
Idee des Stacks: Man kann nur auf das oberste, zuletzt daraufgelegte Element zugreifen (vergleiche Buchstapel, Holzsto, ...)Anwendungen: Kellerautomaten, Speicherverwaltung, HP-Taschenrechner (UPN), ...
help
2. Weitersetzen des Hilfszeigers (Position)

help = help -> next;
help head
0
Das Verhalten des Stacks lsst sich ber seine (recht einfachen) Operationen beschreiben
push: Element am Stack ablegen top: Auf oberstes Element des Stacks zugreifen pop: Element vom Stack entfernen isEmpty: Test auf leeren Stack ?
3. Abfrage auf Listenende (und Suchkriterium)

while ( help != 0 && ) { }
help head
0
155
156
Methoden auf Stacks Methode Push

Element wird auf dem Stack abgelegt (an oberster Position).
0 1
Stack als Liste Stack ist eine spezielle Liste, daher knnen die Stackoperationen durch Listenoperationen ausgedrckt werden.
Push(S,a) Top(S) Pop(S) Add(S,a) FirstElement(S) RemoveFirst(S)
Methode Top
Liefert den Inhalte des obersten Elementes des Stacks.
0
0
1 2
0
IsStackEmpty(S)
wenn Length(S) = 0 return true sonst false
Methode Pop
Oberstes Element des Stacks wird entfernt.
1
2
E. Schikuta
E. Schikuta
157
158
3.4 Queue
Die Queue (Warteschlange) ist ein Spezialfall der Liste, die die Elemente nach dem FIFO (first-in, first-out) Prinzip verwaltet
Idee: Die Elemente werden hintereinander angereiht, wobei nur am Ende der Liste Elemente angefgt und vom Anfang der Liste weggenommen werden knnen Anwendungen: Warteschlangen, Bufferverwaltung, Stoffwechsel, Prozessmanagement,
Methoden auf Queue Methode Enqueue

Element wird am Ende der Queue abgelegt (an letzter Position)
0 1
Einfache Operationen
Enqueue
Element am Ende der Queue ablegen
Methode Front
Liefert den Inhalte des ersten Elementes der Queue
2
1
2
Front
Erstes Element der Queue zugreifen
Dequeue
Erstes Element aus der Queue entfernen
Methode Dequeue
Erstes Element der Queue wird entfernt
1 2
IsQueueEmpty
Test auf leere Queue
E. Schikuta
159
160
Queue als Liste Queue ist ebenfalls eine spezielle Liste, daher sollten alle Queueoperationen auch durch Listenoperationen ausgedrckt werden knnen.
Enqueue(Q,a) Front(Q) Dequeue(Q) Add(S,a) ? Nicht trivial ! ?
Front(Q) Front(Q)
ItemType e; // Hilfselement List L; // Hilfsliste int n = Q.Length(); for (int i = 1; i <= n - 1; i++) { L.Add(Q.FirstElement()); Q.RemoveFirst(); } e = Q.FirstElement(); n = L.Length(); for (i = 1; i <= n; i++) { Q.Add(L.FirstElement()); L.RemoveFirst(); } return e;
Mglichkeit (umstndlich!)
Zugriff auf das erste Queueelement (letzte in der Liste) durch iteratives Entfernen aller Elemente und gleichzeitigen Aufbau einer gestrzten Hilfsliste. Danach Vorgang umkehren.
E. Schikuta
161
162
Dequeue Dequeue(Q)
List L; int l = Q.Length(); for (int i = 1; i <= n - 1; i++) { L.Add(Q.FirstElement()); Q.RemoveFirst(); } Q.RemoveFirst(); int n = L.Length(); for (i = 1; i <= n; i++) { Q.Add(L.FirstElement()); L.RemoveFirst(); }
Zugriff auf beliebiges Listenelement Besser: Einfhren einer neuen Listenoperation

Methode AccessElement
Zugriff auf ein beliebiges Listenelement ber die Position in der Liste, d.h. L = (x1, , xn), i AccessElement(L, i) xi Fehler falls Position nicht definiert
i
x1
x2
...
xn
xi
C++-Methode: ItemType AccessElement(position i);
E. Schikuta E. Schikuta VO Algorithmen und Datenstrukturen
163
164
Methode AccessElement
ItemType List::AccessElement(int pos) { Element* act = head; int actpos = 1; while(actpos < pos) { act = act->next; actpos++; } return act->value; }
Queue als Liste (2. Versuch) Neuerlicher Definitionsansatz mit zustzlicher Listenoperation etwas einfacher, aber ...
Enqueue(Q,a) Add(Q,a) Front(Q) AccessElement(Q,Length(Q)) Dequeue(Q) ? RemoveElement(Q, Length(Q))
Mglichkeit:
Analog zu positionsbezogener Zugriffsfunktion eine positionsbezogene Teilungsfunktion entwerfen, die eine Liste an einer vorgegebener Stelle in 2 Teillisten zerlegt.
E. Schikuta
E. Schikuta
165
166
Lschen eines beliebigen Listenelements Methode RemoveElement

Lschen eines beliebiges Listenelement ber die Position in der Liste, d.h.
L = (x1, , xi-1, xi, xi+1, , xn), i RemoveElement(L, i) L
Fehler falls Position nicht definiert
Erstes Element (1. Pos.) Spezialfall blicherweise 2 Hilfszeiger auf aktuelles und vorhergehendes Element
Methode RemoveElement
void List::RemoveElement(int pos) { Element* pred, * act; int actpos = 2; if(pos == 1) RemoveFirst(); erstes Element else { pred = head; act = head->next; while(act != 0 && actpos < pos) { pred = act; act = act->next; 2 Hilfszeiger actpos++; } if(act == 0) return; pred->next = act->next; delete act; } }
L = (x1, , xi-1, xi+1, , xn), i pred act
head
0 Position:
i-1
i+1
E. Schikuta
167
168
Methode AddElement
Analog auch AddElement mgl.: Einfgen an beliebiger Stelle
void List::AddElement(ItemType a, int pos) { Element* pred, * act; int actpos = 2; if(pos == 1) Add(a); erstes Element else { pred = head; act = head->next; while(act != 0 && actpos < pos) { pred = act; act = act->next; 2 Hilfszeiger actpos++; } pred->next = new Element; pred->next->value = a; pred->next->next = act; } }
Stack - Queue Klasse C++ Klassen Deklaration (Skizze)

Stack
class Stack { public: Stack(); bool Push(ItemType a); ItemType Top(); bool Pop(); bool IsStackEmpty(); }
Queue
class Queue { public: Queue(); bool Enqueue(ItemType a); ItemType Front(); bool Dequeue(); bool IsQueueEmpty(); }
E. Schikuta
169
170
Vergleich "unserer" Datenstrukturen Generelle Unterscheidung zwischen statischer und dynamischer Realisierung
statische R.: contigous memory, Felder dynamische R.: dynamic memory, dynamische Objekte
Konstruktor Destruktor Add FirstElement RemoveFirst Length Member
Aufwandsvergleich "unserer" Listen Implementationen

Liste Liste statisch dynamisch Speicherplatz O(n) O(1) O(1) O(1) O(1) O(1) O(1) O(n) O(n) O(1) O(n) O(1) O(1) O(1) O(n) O(n) AccessElement AddElement Liste Liste statisch dynamisch O(1) O(n) O(n) O(n) O(n) RemoveElement O(n)
Datenverwaltung
Einfgen und Lschen wird untersttzt
Datenmenge
statische R.: beschrnkt, abhngig von der Feldgre dynamische R.: unbeschrnkt
abhngig von der Gre des vorhandenen Speicherplatzes
eher simple Modelle

Achtung: Eigentlicher Aufwand O(n) in Add und RemoveFirst versteckt

171
172
Aufwandsvergleich "unserer" Stack - Queue Implementationen

Stack Stack statisch dynamisch Speicherplatz O(n) Konstruktor Destruktor Push Pop Top O(1) O(1) O(1) O(1) O(1) O(n) O(1) O(n) O(1) O(1) O(1) O(1) Speicherplatz Konstruktor Destruktor Enqueue Dequeue Front Queue Queue statisch dynamisch O(n) O(1) O(1) O(1) O(1) O(1) O(n) O(1) O(n) O(1) O(n) O(n) O(1)
3.5 Spezielle Listen Doubly Linked List

doppelt verkettet Liste
Circular List
Zirkulr verkettete Liste
Ordered List
Geordnete Liste
Double Ended List

Doppelkpfige Liste
IsStackEmpty O(1)
IsQueueEmpty O(1)
E. Schikuta
E. Schikuta
173
174
Doubly Linked List Doppelt verkettete Liste

x1 x2 x3 x4
Circular List Zirkulr verkettete Liste

Zeiger des letzten Element verweist wieder auf das erste Element Ring Buffer Vorsicht beim Eintragen und Lschen des ersten Elementes!
jedes Element besitzt 2 Zeiger, wobei der eine auf das vorhergehende und der andere auf das nachfolgende Element zeigt Basis-Operationen einfach
class Node { KeyType Key; Node* Pred; Node* Succ; }
x1 x2 Pred Key Succ x5 x3 x4

175
176
Ordered List Geordnete Liste

Elemente werden entsprechend ihres Wertes in die Liste an spezifischer Stelle eingetragen Meist der Gre nach geordnet Eintragen an spezifischer Stelle, die erst gefunden werden mu Traversieren
Double Ended List Liste mit 2 Kpfen

Jede Liste besitzt 2 Zeiger, die zum Kopf und zum Ende der Liste zeigen Vereinfacht das Einfgen am Kopf und am Ende der Liste
17
Tail Head
x1
x2
x3
x4
E. Schikuta
E. Schikuta
177
178
Was nehmen wir mit? Listen

Operationen Speicherung Contigous - Scattered memory Kapitel 4:
Stack Queue Vergleich Spezielle Listen

Doubly Linked List Circular List Ordered List Double Ended List
Bume
E. Schikuta
179
180
4.1 Definition Bume Ein Baum (tree) ist ein spezieller Graph, der eine hierarchische Struktur ber eine Menge von Objekten definiert
Intuitives Vorstellungsmodell - Nicht-lineare Datenstruktur Anwendungen
Reprsentieren Wissen, Darstellung von Strukturen, Abbildung von Zugriffspfaden, Analyse hierarchischer Zusammenhnge, ... Stammbaum
Cronus Zeus Poseidon Demeter Persephone
Beispiel Bume
Prozessorfamilien
8088 68000 68020 68030 68040
8080 8085 80186 8086 80286 80386 80486 Pentium
Spezialfall Liste
Gaea Phoebe Pluto Apollo Atlas Ocean Iapetus Prometheus
E. Schikuta
E. Schikuta
181
182
Definition Bume (1) Ein Baum besteht aus einer Menge von Knoten, die durch gerichtete Kanten verbunden sind
Ein Pfad oder Weg ist eine Liste sich unterscheidender Knoten, wobei aufeinander folgende Knoten durch eine Kante verbunden sind
Komponenten Die Wurzel ist der einzige Knoten mit nur wegfhrenden Kanten Knoten von denen keine Kanten wegfhren heien Blatt (leaf) Pfad/Weg von der Wurzel Wurzel zum Blatt Knoten, in die Kanten hinein- und von denen Knoten (interner) Kanten wegfhren, heien interne Knoten
Kante Blatt
Es gibt genau einen Pfad der 2 Knoten miteinander verbindet und jeder Knoten hat nur einen direkten Vorgnger; alle Vorgnger sind von ihm selbst verschieden (definierende Eigenschaft eines Baumes)
Ein Baum enthlt daher keine Kreise, d.i. ein Pfad bei dem der Startknoten gleich dem Endknoten ist
E. Schikuta
E. Schikuta
183
184
Gltige und ungltige Bume Gltige Bume
Definition Bume (1)

Jeder Knoten (mit Ausnahme der Wurzel) hat genau einen Knoten ber sich, den man als Elternknoten oder bergeordneten Knoten bezeichnet Die Knoten direkt unterhalb eines Knotens heien Kindknoten oder untergeordnete Knoten Transitive Eltern werden als Vorgnger bzw. transitive Kinder als Nachfolger bezeichnet Vorgnger Rumlich nebeneinanderElternknoten, bergeordneter Knoten liegende Knoten auf Adjazenter Knoten derselben Tiefe heien Nachbarknoten adjazent oder Nachbarn us
Fo k
Ungltige Bume
Kindknoten, untergeordneter Knoten Nachfolger
E. Schikuta
E. Schikuta
185
186
Rekursive Baum Definition

Ein einzelner Knoten ohne Kanten ist ein Baum Seien T1, , Tk (k > 0) Bume ohne gemeinsame Knoten. Die Wurzeln dieser Bume seien r1, , rk. Ein Baum T0 mit der Wurzel r0 besteht aus den Knoten und Kanten der Bume T 1, , Tk und neuen Kanten von r0 zu den Knoten r1, , rk Der Knoten r0 ist dann r r r ... die neue Wurzel T T und T1, , Tk sind T r Unterbume von T0
1 2 k k 1 2 0
Lnge, Hhe, Tiefe Die Lnge eines Weges zwischen 2 Knoten entspricht der Anzahl der Kanten auf dem Weg zwischen den beiden Knoten Die Hhe eines Knoten ist die Lnge des lngsten Weges von diesem Knoten zu den erreichbaren Blttern Die Tiefe eines Knoten ist die Lnge des Weges zur Wurzel Die Hhe eines Baumes entspricht der Hhe der Wurzel
r1 ri Wurzel des Baumes i Ti Unterbaum i T1
r2 ... T2
rk Tk
E. Schikuta
187
188
Lnge, Hhe, Tiefe grafisch
Beispiel Parse Tree

Parsierungsbume (parse trees) analysieren Anweisungen bzw. Programme einer Programmiersprache bezglich einer gegebenen Grammatik Eine Grammatik definiert Regeln, wie und aus welchen Elementen eine Programmiersprache aufgebaut ist
<stmt>
Tiefe (depth)
Beispiel: C++ (Ausschnitt)

Hhe (height)
<stmt> ::= <select-stmt> | <expr> <select-stmt> ::= if ( <expr> ) <stmt> else <stmt> <expr> ::= <relational-expr> | <assign-expr> | ident <relational-expr> ::= <expr> < <expr> <assign-expr> ::= ident = <expr>
Nonterminal Symbole (werden aufgelst) if, ident Terminalsymbole (nicht mehr aufgelst) ::=, | Grammatiksymbolik
E. Schikuta
E. Schikuta
189
190
Beispiel Parse Tree (2)

if (a < b) max = b else max = a <stmt> <select-stmt> if ( <expr> ) <stmt> <expr> <assign-expr> ident max = <expr> ident b
<stmt> ::= <select-stmt> | <expr> <select-stmt> ::= if ( <expr> ) <stmt> else <stmt> <expr> ::= <relational-expr> | <assign-expr> | ident <relational-expr> ::= <expr> < <expr> <assign-expr> ::= ident = <expr>
Spezielle Bume
Bume (trees)
else
<stmt> <expr>
ungeordnete Bume (unordered trees)
geordnete Bume (ordered trees)
<relational-expr> <expr> ident a < <expr>
<assign-expr> ident max = <expr> ident a
binre Bume (binary trees)
Mehrweg Bume (multiway trees)
ident b
Die Ordnung bezieht sich auf die Position der Knoten im Baum (Knoten A links von Knoten B) und nicht auf die Werte der Knotenelemente
E. Schikuta
191
192
4.2 Binre Bume Binre Bume sind geordnete Bume, in denen jeder Knoten maximal 2 Kinder hat und die Ordnung der Knoten mit links und rechts festgelegt ist
Binrer Baum mit 2 Kindern Binrer Baum mit rechtem Kind (right child) Binrer Baum mit linkem Kind (left child) Binrer Baum ohne Kind (Blatt)
Binre Bume - Eigenschaften Hufiger Einsatz in Algorithmen Effiziente Manipulationsalgorithmen

Zusammenhang zw. Anzahl der Elemente und der Hhe
Hhe 0 1 Knoten 1 Blatt
Hhe 1 3 Knoten 2 Bltter
Hhe 2 7 Knoten 4 Bltter
In jeder neuen Ebene wird im optimalen Fall die Anzahl der Bltter verdoppelt
Entartung mglich: Jeder Knoten hat genau ein Kind entspricht linearer Liste
193
194
Formen binrer Bume

Leerer binrer Baum
Binrer Baum ohne Knoten
Voller binrer Baum Full binary tree

Jeder Knoten im Baum hat keine oder genau 2 Kinder.
Mit anderen Worten, kein Knoten besitzt nur 1 Kind
Voller binrer Baum

Jeder Knoten hat keine oder 2 Kinder
Perfekter binrer Baum

Ein voller binrer Baum bei dem alle Bltter dieselbe Tiefe besitzen
Kompletter binrer Baum

Ein perfekter binrer Baum mit der Ausnahme, dass die Blattebene nicht vollstndig, dafr aber von links nach rechts, gefllt ist
Hhen-balanzierter binrer Baum

Fr jeden Knoten ist der Unterschied der Hhe des linken und rechten Kindes maximal 1
E. Schikuta
E. Schikuta
195
196
Perfekter binrer Baum Perfect binary tree

Ein voller binrer Baum (alle Knoten haben keine oder genau 2 Kinder) bei dem alle Bltter dieselbe Tiefe besitzen.
Eigenschaften des perfekten binren Baumes Eigenschaften

Frage: welche Hhe h muss ein perfekter binrer Baum haben um n Bltter zu besitzen
In jeder Ebene Verdoppelung, d.h. 2h = n h * log 2 = log n h = log2 n = ld n
Ein perfekter binrer Baum der Hhe h besitzt 2h+1-1 Knoten

davon sind 2h Bltter Beweis mit vollstndiger Induktion
Zusammenhang zwischen Knoten/Bltter und Hhe: O(n) Knoten/Bltter : O(log n) Hhe wichtigste
Eigenschaft von Bumen
197
198
Kompletter binrer Baum Complete binary tree

Ein kompletter binrer Baum ist ein perfekter binrer Baum mit der Ausnahme, dass die Blattebene nicht vollstndig, dafr aber von links nach rechts, gefllt ist
Hhen-balanzierter binrer Baum Height-balanced binary tree

Fr jeden Knoten ist der Unterschied der Hhe des linken und rechten Kindes maximal 1
Dies garantiert, dass lokal fr jedes Kind die Balanzierungseigenschaft relativ gut erfllt ist, global aber die gesamten Baumdifferenzen grer sein knnen einfachere Algorithmen
Eigenschaft
Ein kompletter binrer Baum mit n Knoten hat eine Hhe von maximal h = log2 n
199
200
Baum Traversierung Traversieren eines Baumes bezeichnet das systematische Besuchen aller seiner Knoten
Unterschiedliche Methoden unterscheiden sich in der Reihenfolge der besuchten Knoten Mgliche Reihenfolgen A, B, C B, A, C B, C, A
Expression Tree
Systematische Auswertung eines mathematischen Ausdrucks Ein mathematischer Ausdruck kann in Form eines Expression Trees angegeben werden
+
(20 / 5) + 3
/ 3
20
Bltter reprsentieren Operanden (Zahlenwerte), interne Knoten Operatoren Baumdarstellung erspart Klammernnotation
E. Schikuta
E. Schikuta
201
202
Traversierungsalgorithmus
Traversierungsalgorithmen bestehen prinzipiell aus 3 verschiedenen Schritten
Bearbeiten eines Knotens (process node) Rekursiv besuchen und bearbeiten des linken Kindes (visit left child) Rekursiv besuchen und bearbeiten des rechten Kindes (visit right child)
Preorder Traversierung
Algorithmus
preorder(node) { if(node != 0) { process(node) preorder(left child) preorder(right child) } }
Beispiel
20/5+3
+
A
3
Durch unterschiedliches Anordnen der 3 Schritte unterschiedliche Reihenfolgen 3 Bearbeitungsreihenfolgen interessant

Preorder Traversierung Postorder Traversierung Inorder Traversierung
B C
20
Besucht die Knoten im Baum in PrefixNotation-Reihenfolge

(Operator, Operand 1, Operand 2)
Faustregel
Knoten bearbeiten beim 1. Besuch
Anwendung
LISP, Assembler
Process-Reihenfolge: Notation-Reihenfolge:
ABCDE + / 20 5 3
E. Schikuta
E. Schikuta
203
204
Postorder Traversierung
Algorithmus
postorder(node) { if(node != 0) { postorder(left child) postorder(right child) process(node) } }
Inorder Traversierung
Algorithmus
Beispiel
20/5+3
+
A
3
Postfix-Notation-Reihenfolge
(Operand1, Operand2, Operator)
B C
20
inorder(node) { if(node != 0) { inorder(left child) process(node) inorder(right child) } }
Beispiel
20/5+3
+
A
3
B C
20
Infix-Notation-Reihenfolge
5
Faustregel
Knoten bearbeiten beim letzten Besuch
(Operand1, Operator, Operand2)
Faustregel
Process-Reihenfolge: Notation-Reihenfolge: CDBEA 20 5 / 3 + Knoten bearbeiten beim 2. oder letzten Process-Reihenfolge: Besuch Notation-Reihenfolge: einfacher algebraischer Taschenrechner (ohne Klammern)
Anwendung
Invers Polish Notation, HP Taschenrechner, FORTH
Anwendung
CBDAE 20 / 5 + 3
205
206
4.3 Binre Suchbume In einem Binrbaum besitzt jeder (interne) Knoten eine linke und eine rechte Verbindung, die auf einen Binrbaum oder einen externen Knoten verweist
Verbindungen zu externen Knoten heien Nullverbindungen, externe Knoten besitzen keine weiteren Verbindungen
Schlsseleigenschaft im BST Fr jeden internen Knoten gilt, dass alle Werte der Nachfolger im linken Unterbaum kleiner (oder gleich) dem Knotenwert und die Werte der Nachfolger im rechten Unterbaum grer als der Interne Knotenwert sind
12 <= > 3 10 11 15 21
Knoten Externe Knoten
Reprsentieren quasi die Datenspeicher (enthalten nur mehr Schlssel und Daten, keine Zeiger auf Nachfolger), z.B. Seiten auf der Platte Bei Hauptspeicherstrukturen meist vernachlssigbar
werden im Weiteren grafisch oft nur mehr durch einen Strich dargestellt
Ein binrer Suchbaum (binary search tree, BST) ist ein Binrbaum, bei dem jeder interne Knoten einen Schlssel besitzt
externe Knoten besitzen keine Schlssel Auf den Schlsseln ist eine lineare Ordnung < definiert
Wenn x und y verschieden sind, so gilt x<y oder y<x; ist x<y und y<z, dann gilt auch x<z
207
208
Eigenschaften binrer Suchbume Verwaltung beliebig groer Datenbestnde

dynamische Struktur Erstellen
Erzeugen eines leeren Suchbaumes
Operationen
Effiziente Administration
Aufwand proportional zur Hhe des Baumes und nicht zur Anzahl der Elemente Einfgen, Zugriff und Lschen im Durchschnitt von O(log n) Signifikante Verbesserung im Vergleich zum linearen Aufwand (O(n)) bei Liste Zugriff auf Elemente in sortierter Reihenfolge durch inorder Traversierung
Einfgen
Einfgen eines Elementes in den Baum unter Bercksichtigung der Ordnungseigenschaft
Suche
Test auf Inklusion
Lschen
Entfernen eines Elementes aus dem Baum unter Erhaltung der Ordnungseigenschaft
Ausgabe
Ausgabe aller Elemente in sortierter Reihenfolge
...
209
210
Klassendefinition
typedef int ItemType; class SearchTree { class node { public: node public ItemType info; node * leftchild, * rightchild; node(ItemType x, node * l, node * r) {info=x; leftchild=l; rightchild=r;} }; typedef node * link; link root; void AddI(ItemType); void AddR(link&, ItemType); bool MemberI(ItemType); bool MemberR(link, ItemType); node void PrintR(link, int); public: SearchTree(){root = 0;} leftchild info rightchild void Add(ItemType); int Delete(ItemType); bool Member(ItemType); void Print(); };
Suchen in einem binren Baum

Beim Suchen eines Schlssels wird ein Pfad von der Wurzel abwrts verfolgt
Bei jedem internen Knoten wird der Schlssel x mit dem Suchschlssel s verglichen Falls x = s liegt ein Treffer vor, falls s <= x suche im linken Teilbaum, sonst im rechten Wenn man einen externen Knoten erreicht, war die Suche erfolglos Erfolgreiche Suche (z.B. 11)
12 7 3 11 15 21 3 7 11
Einfachheitshalber in alles
Erfolglose Suche (z.B. 13)

12 15 21
E. Schikuta
E. Schikuta
211
212
Suche (iterativ)
bool SearchTree::MemberI(ItemType a) { if(root) { link current = root; while(current) { if(current->info == a) return true; if(a < current->info) current = current->leftchild; else current = current->rightchild; } } return false; } bool SearchTree::Member(ItemType a) { return MemberI(a); }
Suche (rekursiv)
bool SearchTree::MemberR(link h, ItemType a) { if(!h) return false; else { if(a == h->info) return true; if(a < h->info) return MemberR(h->leftchild, a); else return MemberR(h->rightchild, a); } } bool SearchTree::Member(ItemType a) { return MemberR(root, a); } Aufruf: SearchTree t; t.Member(7);
Aufruf:
SearchTree t; t.Member(7); Verzweigung auf root->leftchild, da root->info > a (d.I. 12 > 7) 12 15
7 return true, da root->info == a (gefunden!)

E. Schikuta
E. Schikuta
213
214
Einfgen in einem binren Suchbaum Das Einfgen entspricht einer erfolglosen Suche (wobei gleiche Schlssel bergangen werden) und dem Anfgen eines neuen Knotens an der Nullverbindung wo die Suche endet (anstelle des externen Knotens)
Einfgen 13 Suche
12 7 3 11 15 21 3 7 11 13
Einfgen (iterativ)
hnlich dem Einfgen in eine Liste (2 Hilfszeiger)
void SearchTree::AddI(ItemType a) { Aufruf: if(root) { link current = root; SearchTree t; link child; current, child while(1) { t.Add(7); if(a <= current->info) { child = current->leftchild; if(!child) {current->leftchild = new node(a, 0, 0); return;} } else { child = current->rightchild; if(!child) {current->rightchild = new node(a, 0, 0); return;} } current = child; } } else { current root = new node(a, 0, 0); return; child } } 12 void SearchTree::Add(ItemType a) { AddI(a); 7 15 }
Hilfszeiger:
Knoten anfgen
12 15 21
E. Schikuta
E. Schikuta
215
216
Einfgen (rekursiv)
void SearchTree::AddR(link& h, ItemType a) { if(!h) {h = new node(a, 0, 0); return;} if(a <= h->info) AddR(h->leftchild, a); Man beachte die Verwendung eines Referenzparameters else (link&), erspart die 2 AddR(h->rightchild, a); Hilfszeiger } void SearchTree::Add(ItemType a) { AddR(root, a); }
Traversieren
void SearchTree::PrintR(link h, int n) { if(!h) return; Inorder PrintR(h->rightchild, n+2); Traversierung for(int i = 0; i < n; i++) cout << " "; cout << h->info << endl; PrintR(h->leftchild, n+2); } void SearchTree::Print() { PrintR(root, 0); Gibt Baum um 90 Grad gegen den }
Aufruf
SearchTree t; t.Add(7);
Aufruf
SearchTree t; t.Print();
Uhrzeigersinn verdreht aus
E. Schikuta
E. Schikuta
217
218
Lschen in einem binren Baum Der Lschvorgang unterscheidet 3 Flle

Lschen von internen Knoten mit (1) keinem (2) einem internen Knoten als Kinder (3) zwei Fall 1
Lschen (2)
Lschen von Knoten 3 durch Ersetzen des linken Kindzeigers von Knoten 7 durch eine Nullverbindung (externer Knoten)
12 7 3 11 15 21
7
12 15 11 21
Flle 1 und 2 sind einfach durch Anhngen des verbleibenden Teilbaums an den Elternknoten des zu lschenden Knotens zu lsen. Fr Fall 3 muss ein geeigneter Ersatzknoten gefunden werden. Hierzu eignen sich entweder der kleinste im rechten (Inorder Nachfolger) oder der grte im linken Teilbaum (Inorder Vorgnger)
Fall 2
Lschen von Knoten 15 durch Einhngen des Knoten 21 als rechtes Kind von 12
12 7 11 15 21
7
12 21 11
E. Schikuta
219
220
Lschen (3)
Fall 3
7 3 11 12 15 21
Laufzeit
Erwartungswert der Einfge- und Suchoperationen bei n zuflligen Schlsselwerten ist ungefhr 1,39 ld n Im ungnstigsten Fall kann der Aufwand zu ungefhr n Operationen entarten Beispiele fr ungnstige Suchbume
3 3 7 11 12 15 21 11 12 7 15 21
Im Falle des Lschens von 12 eignen sich als Ersatz die Knoten mit den Werten 11 (grte im linken) oder 15 (der kleinste im rechten Teilbaum). Dies resultiert in 2 mglichen Bumen:
11 7 3 15 21 3 7 11 15 21
Somit muss der Lschvorgang fr Fall 3 in zwei Teile zerlegt werden: 1. Finden eines geeigneten Ersatzknotens 2. Ersetzen des zu lschenden Knotens (was wiederum aus dem Entfernen des Ersatzknotens aus seiner ursprnglichen Position (entspricht Fall 1 oder 2) und dem Einhngen an der neuen Stelle besteht)
E. Schikuta
221
222
Analyse binrer Suchbaum

Datenverwaltung
untersttzt Einfgen und Lschen
4.4 Hhenbalanzierter binrer Baum

Hhenbalanziert (bekannt!): Fr jeden Knoten ist der Unterschied der Hhe des linken und rechten Kindes maximal 1
Geeignete Algorithmen fr Einfgen und Lschen erhalten die Balanzierungseigenschaft und vermeiden dadurch die Entartung der Laufzeit zu O(n) und garantieren O(log n)
Datenmenge
unbeschrnkt
Modelle
Hauptspeicherorientiert Untersttzung komplexer Operationen
Bereichsabfragen, Sortierreihenfolge
Laufzeit
Speicherplatz Konstruktor Zugriff Einfgen Lschen Sortierreihenfolge
O(n) O(1) O(log n) O(log n) O(log n) O(n)
Bitte beachten: betrchtlicher konstanter Aufwand ist notwendig!

223
224
AVL Bume AVL Bume sind hhenbalanzierte binre Suchbume

Adelson-Velski und Landau, 1962
Einfgen in einen AVL Baum Das Einfgen verluft analog zum Einfgen im binren Suchbaum
4 46 5 46
Beispiel
4 46 2 17 3 78 1 32 2 50 1 88 0 0 1 48 62 1 0 00 0 1 48 62 1 2 50 1 88 3 78
Einfgen 54
2 17 1 32
4 78 3 50 1 88
Hhen sind neben den 2 17 Knoten angegeben Anmerkung: externe Knoten 0 nicht vergessen, sie haben die 1 32 Hhe 0!
Problem: die Balanzierungseigenschaft kann durch das Einfgen verletzt werden d.h. Korrektur notwendig
1 48 62 2
1 54
E. Schikuta
E. Schikuta
225
226
Rotationen Balanzierungskorrektur durch Knotenrotationen

2 generelle Flle (einfach und doppelt) zu unterscheiden
Jeweils 2 weitere symmetrische Flle 5 46
Einfgen Beispiel
Fall 1
B A
C
eigentlich T4 T3
Fall 2
A
4 46 2 17 1 32 1 4 78 3 50 88
T4
B B A C
T1 T2
T4
2 17
Doppelte Rotation
3 62 2 50 1
T3
1 32 1
2 78 1 88
T4
T1
T2
T3
48
T1
62 2
Einfache Rotation
T1
Doppelte Rotation
T4
48
T3 T1
54
T2
T2
T3
1. Schritt produziert Fall 1, danach einfache Rotation

E. Schikuta
1 54
T2
E. Schikuta
227
228
Einfache Rotationen
Nach Einfgen eines Elementes ( ) Baum nicht mehr balanziert Durch Symmetrie 2 einfache Rotationsflle zu unterscheiden B A
LL-Rotation
2 3 1 2
Doppelte Rotationen
Die doppelte Rotation besteht eigentlich aus 2 einfachen Rotationen Die RL Rotation aus einer LL Rotation des rechten Subbaumes und danach einer RR Rotation des gesamten Baumes der nicht balanziert ist (die LR Rotation funktioniert entsprechend umgekehrt)
Ausgangspunkt A C B
1 2 3 4
Zwischenphase
RL-Rotation 1.Phase: LL Rotation
Ergebnis
RL-Rotation 2.Phase: RR Rotation
A B C
1 2 3
LL-Fall
1
B B
RR-Rotation
3 1
RR-Fall
1 2
A
3
Fall Bestimmung 1. Ausgehend vom Knoten, bei dem die Balanzierung verletzt ist, berprft man, welcher Teilbaum lnger ist (L oder R). 2. Danach beim Kindknoten im nicht balanzierten Teilbaum feststellen, welcher weiterer (Sub)Teilbaum lnger ist (L oder R) (bei gleicher Lnge einfacher Fall)
B A
2 3
C A B
4
LR-Rotation 1.Phase: RR Rotation
C B A
3
LR-Rotation 2.Phase: LL Rotation
B A C
2 3
E. Schikuta
E. Schikuta
229
230
Beispiel Einfgen im AVL Baum Einfgereihenfolge: 4,5,7,2,1,3,6

4, 5 bal. simpel
Beispiel Einfgen im AVL Baum (2)

5
4 1 0
4 7
LR Rot.
4 5
7 unbal.
0
3 2 1 0 4
5 5
RR Rot.
3 unbal.
3 1
2
2 0
2 1 3
5 7
2 bal.
1
0 0
4
1 0
0 0
3
0 0
5
simpel
5 7
1 unbal.
2 1 0 3
4
1 0
4 3
4 5
0 2
4 2
4
0 0 0
5
LL Rot.
unbal.
2
1 1
RL Rot.
2 1 3 5
6 7
2
0
2 1 4
7
0
1
0
3
0 0
7
1 0 0
6
0
231
232
Lschen im AVL Baum Das Lschen funktioniert analog zum Lschen im binren Suchbaum Gelschte Knoten knnen zu nicht balanzierten Bumen fhren Lsung durch Rotationen analog zum Einfgen
Eine (Lsch) Rotation kann aber die Balanzierung eines anderen Knoten verletzen Daher kann ein Lschvorgang eine Serie von Rotationen auslsen um Unbalanziertheiten vom Lschort bis zur Wurzel aufzulsen Die ist unterschiedlich zum Einfgen, wo mit einer Rotation die Unbalanziertheit behoben werden kann
Beispiel Lschen im AVL Baum

Lschreihenfolge: 4,8,6,5,2,1,7
5 3 2 1 5 2 1 3 7 9
5 8
4 LL Rot.
5 8
8 simpel
2 1 3 6 7
2 1 3 6
7 10 9
7 RR Rot.
6 RR Rot.
4 6
7 9
10 11 3 2 1 7 9
10 9 7 11
Beim Lschen Fall 3 oBdA Ersatzknoten = grter links
11 10 3 9 11
10 11
5 simpel
10 11
2 RL Rot.
3 1 9
10 11
1 simpel
7 3 9 10 11
E. Schikuta
233
234
Analyse AVL Baum

Datenverwaltung
untersttzt Einfgen und Lschen
4.5 Mehrwegbume sind Bume mit Knoten, die mehr als 2 Kinder besitzen knnen
Intervallbasierten Suchdatenstrukturen
k1
x < k1
Datenmenge
unbeschrnkt
Modelle
k2 ... km-1 p1
km pm-1
km x
p0
k1 x < k2
km-1 x < km
pm
Laufzeit
Speicherplatz Rotation Zugriff Einfgen Lschen Sortierreihenfolge
Heuristische Analyse (Wirth 79) zeigt, dass eine Rotation bei jeder 2-ten Einfgeoperationen und nur bei jeder 5-ten Lschoperation vorkommt Die Hhe eines AVL-Baumes mit n Knoten ist 1.45 log n, d.h. hchstens 45 % grer als erforderlich.
E. Schikuta
Knoten besteht aus einer Menge von m Schlsselwerten k1, k2, , km und m+1 Verweisen (Kanten) p0, p2, , pm, sodass fr alle Schlssel xj im Unterbaum, der durch pi referenziert wird, gilt ki xj < ki+1 (Schlssel liegen im Intervall [ki, ki+1[).
Beispiel
3 9
11 37 13 39 41 53
Interne Knoten Externe Knoten
E. Schikuta
235
236
Suchen im Mehrwegbaum
hnlich zur Suche im binren Suchbaum Bei jedem internen Knoten mit Schlsseln k 1, k2, , km und Verbindungen p0, p1, , pm
Suchschlssel s = ki (i = 1, , m): Suche erfolgreich S k1: fortsetzen im Unterbaum p0 ki s < ki+1: fortsetzen im Unterbaum pi s > km: fortsetzen im Unterbaum pm Falls man einen externen Knoten erreicht: Suche erfolglos
2-3-4 Bume Ein 2-3-4 Baum ist ein Mehrwegbaum mit den folgenden 2 Eigenschaften
Greneigenschaft: jeder Knoten hat mindestens 2 und maximal 4 Kinder Tiefeneigenschaft: alle externe Knoten besitzen dieselbe Tiefe Abhngig von der Anzahl der Kinder heit ein interner Knoten 2-Knoten, 3-Knoten oder 4-Knoten
11 37 3 9 13 39 45 53
Beispiel: Suche 50
11 37 3 9 13 39 45 53 50
E. Schikuta
237
238
Hhe eines 2-3-4 Baumes Satz: Ein 2-3-4 Baum, der n interne Knoten speichert, hat eine Hhe von O(log n) Beweis
Die Hhe des 2-3-4 Baumes mit n internen Knoten sei h Da es mindestens 2i interne Knoten auf den Tiefen i = 0, , h-1 gibt und keine internen Knoten auf Tiefe h, gilt n 1 + 2 + 4 + + 2h-1 = 2h 1 Daher gilt h log2 (n + 1) Knoten Tiefe
1 2 2h-1 0
Einfgen in einen 2-3-4 Baum

Ein neuer Schlssel s wird im Elternknoten v des externen Knotens eingefgt, den man bei der Suche nach s erreicht hat
Die Tiefeneigenschaft des Baumes wird erhalten, aber es wird mglicherweise die Greneigenschaft verletzt Ein (Knoten-) berlauf ist mglich (es entsteht ein 5-Knoten)
Beispiel: Einfgen von 30 erzeugt berlauf

11 24 3 9 13 27 32 35 v 11 24 3 9 13
0 1 h-1 h
5-Knoten
v 27 30 32 35
E. Schikuta
239
240
berlauf und Split

Ein berlauf (Overflow) bei einem 5-Knoten v wird durch eine Split Operation aufgelst
Die Kinder von v seien v1, , v5 und die Schlssel von v seien k1, , k4 Knoten v wird durch die Knoten v und v ersetzt, wobei
v ein 3-Knoten mit den Schlsseln k 1 und k2 und Kindern v1, v2 und v3, v ein 2-Knoten mit Schlssel k 4 und Kindern v4 und v5 ist
Lschen Der Lschvorgang wird auf den Fall reduziert, wo der zu lschende Schlsselwert in einem internen Knoten mit externen Knotenkindern liegt Andernfalls wird der Schlsselwert mit seinem Inorder Nachfolger (oder Inorder Vorgnger) ersetzt
Analog Fall 3 binre Suchbume
Schlssel k3 wird in den Elternknoten u von v eingefgt (dadurch kann eine neue Wurzel entstehen)
Ein berlauf kann an die Vorgnger von u propagiert werden

11 24 3 9 13 u v 27 30 32 35 v1 v2 v3 v4
Beispiel Lschen Schlssel 24

11 24 11 27 27 32 35 3 9 13 32 35 v v5
11 24 32 3 9 v5 13
u v v3 v4 35 3 9
27 30 v1 v2
13
E. Schikuta
E. Schikuta
241
242
Unterlauf
Durch das Lschen eines Schlssels in einem Knoten v kann es zu einem Unterlauf (underflow) kommen
Knoten v degeneriert zu einem 1-Knoten mit einem Kind und keinem Schlssel 11 27 v 3 9 13
Verschmelzen im 2-3-4 Baum Fall 1: Verschmelzen von Knoten

Bedingung: Alle adjazenten Knoten (benachbarte Knoten auf derselben Tiefe) zum unterlaufenden Knoten v sind 2Knoten Man verschmilzt v mit einem/dem adjazenten Nachbarn w und verschiebt den nicht mehr bentigten Schlssel vom Elternknoten u zu dem verschmolzenen Knoten v Das Verschmelzen kann den Unterlauf zum Elternknoten propagieren
u 3 9 11 27 13 w v u 3 9 11 13 27 v
Bei einem Unterlauf kann man 2 Flle unterscheiden

Fall 1: Verschmelzen
Benachbarte Knoten werden zu einem erlaubten Knoten verschmolzen
Fall 2: Verschieben
Schlsselwerte und entsprechende Kinder werden zwischen Knoten verschoben
E. Schikuta
E. Schikuta
243
244
Verschieben im 2-3-4 Baum Fall 2: Verschieben von Schlsseln

Bedingung: Ein adjazenter Knoten (benachbarter Knoten auf derselben Tiefe) w zum unterlaufenden Knoten v ist ein 3-Knoten oder 4-Knoten Man verschiebt ein Kind von w nach v Man verschiebt einen Schlssel von u nach v Man verschiebt einen Schlssel von w nach u Nach dem Verschieben ist der Unterlauf behoben
u 3 9 11 27 13 20 w v 3 9 u 11 20 13 w 27 v
Analyse 2-3-4 Baum

Datenverwaltung
Einfgen und Lschen untersttzt
Datenmenge
unbeschrnkt
Modelle
Laufzeit
Speicherplatz Verschmelzen, Verschieben Zugriff Einfgen Lschen Sortierreihenfolge

E. Schikuta
E. Schikuta
245
246
Vergleich der Baumvarianten Ziel

Baumhhe + Baumvariante Aufwand der Operationen Allgemeiner Binrer Suchbaum AVL-Baum Im Durchschnitt log(n) log(n) Balanzierungsform Abhngig von der Eingabe Methode Zufall, Gesetz der groen Zahlen Rotationen
4.6 Externspeicherverwaltung
Erstellen eines Schlsselbaumes fr eine groe Anzahl von Elementen
Problem
Hauptspeicher zu klein
Lsung
Speicherung der Knoten auf dem Externspeicher (Platte)
Hauptspeicher
hhenbalanziert
2-3-4 Baum
log(n)
Split, perfektbalanziert Verschmelzen, Verschieben
01001010010101 11101101101010 01010101011101 ...
Platte
E. Schikuta
E. Schikuta
247
248
Plattenzugriffe Ansatz
Referenzieren eines Knotens entspricht Zugriff auf die Platte
Bei Aufbau eines binren Schlsselbaumes fr eine eine Datenmenge von z.B. einer Million Elementen ist die durchschnittliche Baumhhe log2106 20, d.h. 20 Suchschritte 20 Plattenzugriffe
Seitenverwaltung Lsung
Zerlegung des binren Baumes in Teilbume, diese in sog. Seiten (pages) speichern
Dilemma
Unterschied Aufwand Platten- zu Hauptzugriff Faktor 100000, milli- zu nano-Sekunden (z.B. 5ms 60 ns) Jeder Suchschritt bentigt einen Plattenzugriff hoher Aufwand an Rechenzeit
Mehrwegbaum (multiway-tree)
Bei 100 Knoten pro Seite fr 1 Million Elemente nur mehr log 100106 = 3 Seitenzugriffe Im schlimmsten Fall (lineare Entartung) aber immer noch 10 4 Zugriffe (10 6 / 100)
249
250
Seitenverwaltung (2)
Knoten entsprechen Seiten (Blcke)
besitzen eine Gre, Seitengre (Anzahl der enthaltenen Eintrge bzw. Speichergre in Bytes) reprsentieren die Transfereinheit zwischen Haupt- und Externspeicher Zur Effizienzsteigerung des Transfers wird die Gre der Seiten an die Blockgre der Speichertransfereiheiten des Betriebssystems angepat (Unit of Paging/Swapping)
Indexstruktur Indexstruktur besteht aus Schlsselteil (Index) und Datenteil

Graphische Struktur
Index Hauptspeicher
schreiben
Externspeicher
Daten
Seiten
... lesen ...
Index
ermglicht den effizienten Zugriff auf die Daten
Disk
Daten
enthalten die gespeicherte Information (vergleiche externe Knoten)
251
252
Knotenarten 2 Knotenarten
Indexknoten
Erlauben effizienten Zugriff auf die externe Knoten Definieren die Intervallbereiche der Elemente, die im zugeordneten Teilbaum gespeichert sind. realisiert durch interne Knoten
4.7 B+-Baum Hhenbalanzierter (perfektbalanzierter) Mehrwegbaum

Eigenschaften
Externspeicher-Datenstruktur Eine der hufigsten Datenstrukturen in Datenbanksystemen Dynamische Datenstruktur (Einfgen und Lschen) Algorithmen fr Einfgen und Lschen erhalten die Balanzierungseigenschaft Garantiert einen begrenzten (worst-case) Aufwand fr Zugriff, Einfgen und Lschen Der Aufwand fr die Operationen Zugriff, Einfgen und Lschen ist bedingt durch die Baumstruktur maximal von der Ordnung log n (O(log n)). Besteht aus Index und Daten Der Weg zu allen Daten ist gleich lang
Externe Knoten
Enthalten die zu verwaltende Information realisiert durch Blattknoten
Beispiel
11
3 9 11
25
25
37
26 37
Indexknoten Externe Knoten

E. Schikuta
253
254
Definition B+-Baum B+-Baum der Ordnung k

alle Blattknoten haben die gleiche Tiefe (gleiche Weglnge zur Wurzel) die Wurzel ist entweder ein Blatt oder hat mindestens 2 Kinder jeder (interne) Knoten besitzt mindestens k und maximal 2k Schlsselwerte, daher mindestens k+1 und maximal 2k+1 Kinder
Fr jeden in einem Knoten referenzierten Unterbaum gilt, dass die in ihm gespeicherten Elemente kleiner als die Elemente im rechten und grer als die Elemente im linken Unterbaum sind. Die Intervallgrenzen werden durch die Schlsselwerte bestimmt.
Beispiel B+-Baum B+-Baum der Ordnung 2

11 23 35 Anmerkung: Im weiteren werden Indexknoten grn und externe Knoten wei dargestellt
11
17
19
21
23
25
30
35
37
46
Jeder Indexknoten hat mindestens 2 und maximal 4 Grenzwerte und folglich mindestens 3 und maximal 5 Kinder Ausnahme ist die Wurzel Die Gre der externen Knoten ist eigentlich durch die Ordnung nicht definiert, wird aber blicherweise in der Literatur gleichgesetzt
E. Schikuta
255
256
Suche
11 1 3 8 11 17 19 23 21 35 23 25 30 35 37 46
B+-Baum Einfgen (1) Fall 1: Einfgen Element 26

Platz im externen Knoten vorhanden, einfaches Einfgen
Suchen
11 11 17
Element 17
23 35 11 11 x < 23 19 21 enthalten
Element 27
23 35 23 nicht enthalten 25 30 1 3 8 11 17 11 23 21 35 23 x < 35
19
23
25
30
35
37
46
?
11 23 35
Aufwand der Suche

Hhe eine B+-Baumes der Ordnung k mit Datenblockgre b (mind. b, max 2b Elemente) ist maximal log k+1(n/b).
Bereichsabfrage mglich
Suche alle Element im Breich [Untergrenze, Obergrenze]
Warum?
11
17
19
21
23
25
26
30
35
37
46
E. Schikuta
E. Schikuta
257
258

Kein Platz mehr im externen Knoten (berlauf, Overflow), externer Knoten muss geteilt werden Split
11 23 25 23 26 35 30 Splitten 23 25 26 28 30 11 11 11 1 3 8 17 19 21 23 25 23 28 28 26 35 30 35 37 46 1 3 8 17 28 neue Grenze 11 19 23 21 25 26 23

Kein Platz mehr im Knoten und kein Platz mehr im darberliegenden Indexknoten, Indexknoten muss gesplittet werden
28 28 35 30 35 37 46
E. Schikuta
E. Schikuta
259
260
B+-Baum Einfgen (4)

Beim Splitten eines Indexknoten wird das mittlere Indexelement im darberliegenden Indexknoten eingetragen. Falls der nicht existiert (Wurzelsplit), wird eine neue Wurzel erzeugt
B+-Baum Einfgen (5) Der resultierende Baum hat folgendes Aussehen

23 11 1 3 8 11 19 23 17 18 19 21 25 28 26 28 35
30 35 37 46
11 19 11 17 18
23
28
35 23 11 19 28 35
Unterscheidung des Splits fr externe und interne Knoten

Externe Knoten: 2k+1 Elemente werden auf 2 benachbarte externe Knoten aufgeteilt Interne Knoten: 2k+1 Indexelemente (Schlsselwerte) werden auf 2 benachbarte Indexknoten zu je k Elemente aufgeteilt, das mittlere Indexelement wird in die darberliegende Indexebene eingetragen. Falls keine darberliegende Ebene existiert, wird eine neue Wurzel erzeugt, der Baum wchst um eine Ebene (Baum wchst von den Blttern zur Wurzel), der Zugriffsweg zu den Daten erhht sich um 1.
19
21
261
262
B+-Baum Lschen (1) Fall 1: Entfernen von Element 46

Externer Knoten nach Lschen nicht unterbesetzt
23 11 1 3 8 11 17 19 23 18 19 21 25 28 26 28 30 35 37 46 35 1 3 11 8 11 17 19 23 18 19 21 25
B+-Baum Lschen (2) Fall 2: Entfernen von Element 37

Externer Knoten nach dem Lschen unterbesetzt
23 28 26 28 30 35
verschmelzen
35
37
23 11 1 3 8 11 17 19 23 18 19
Element wird einfach aus dem externen Knoten entfernt

28 25 26 28 30 35 37
E. Schikuta
Element wird entfernt, ist Knoten unterbesetzt ( Underflow), Elementanzahl < k Umgekehrter Vorgang zum Split benachbarte Knoten werden verschmolzen (merge) 23 25 28 26 28 Interner Knoten unterbesetzt, muss ebenfalls mit Nachbarn verschmolzen werden.
E. Schikuta
35
21
30
35
263
264
B+-Baum Lschen (3) Das Verschmelzen kann zur Verringerung der Baumhhe fhren, 2 Knoten werden zur neuen Wurzel verschmolzen, alte Wurzel wird entfernt.
11 11 1 3 8 17 18 19 21 19 23 23 28 25 26 28 30 35 11 16 19 17 21 18 11 16 17
B+-Baum Lschen (4)

Anmerkung
Das Verschmelzen zweier Knoten kann zu einem berlauf (analog Einfgen) des neuen Knoten fhren, was einen nachfolgenden Split notwendig macht.
Beispiel: (Baumausschnitt)
Lschen von 19
...
Verschmelzen - berlauf
... ...
Splitten
...
19
21 18
...
18 17 21
...
21
11
16 18
Diese (Verschmelzen-Splitten) Sequenz erzeugt eine besseren Aufteilung der Datenstze zwischen benachbarten Knoten. Dies wird auch hier (siehe 2-3-4 Baum, eigentlich flschlicherweise) als Datensatzverschiebung (shift) bezeichnet.
265
266
Datenblockverkettung
In der Praxis werden die Datenblcke linear verkettet, um einen effizienten, sequentiellen Zugriff in der Sortierreihenfolge der gespeicherten Elemente zu ermglichen
11 11 1 3 8 17 18 19 21 19 23 23 28 25 26 28 30 35
Analyse B+ - Baum Datenverwaltung

Datenmenge
unbeschrnkt
abhngig von der Gre des vorhandenen Speicherplatzes
Modelle
Externspeicherorientiert Untersttzung komplexer Operationen
E. Schikuta
E. Schikuta
267
268
Analyse B+ - Baum (2) Ein Trie ist ein digitaler Suchbaum

Speicherplatz Split, Verschmelzen Zugriff Einfgen Lschen Sortierreihenfolge O(n) O(1) O(log n) O(log n) O(log n) O(n) A B C D E ...
4.8 Trie
Dient zur Speicherung von Strings (Verwaltung von Wrterbchern, Telefonbchern, Spellcheckern, etc.)
Bezeichnung wird abgeleitet von retrieval, wird aber wie try ausgesprochen
Bei k Buchstaben ein k+1-ary Tree, wobei jeder Knoten durch eine Tabelle mit k+1 Kanten auf Kinder reprsentiert wird.
Y Z $
Bitte beachten: Ordnung des Baumes ist konstanter Faktor!
Spezialformen
Patricia Tree, de la Briandais Tree
269
270
Beispiel Trie Trie

TEN THE THEN THIN THIS TIN SING PIN WIN
Patricia Trie Practical Algorithm to Retrieve Information Coded in Alphanumeric

Ziel ist die Komprimierung des Tries
P I N $ I N G $
S E N $ $ E H
T I I N N $ $ S $
W I N $ N $ PIN SING
PSTW EHI TEN N THEN

WIN TIN N THIN S THIS

E. Schikuta
I $ THE
Einfgen Suchen
271
272
de la Briandais Trie Listen-Reprsentation eines Tries

statt der Tabellen im Knoten lineare Liste
Knoten besteht aus 2 Kinderkomponenten Nchster Wert - Nchster Level
P S T W
Analyse Trie
Datenverwaltung
Einfgen und Lschen untersttzt Struktur des Tries unabhngig von der Einfgereihenfolge
Datenmenge
unbeschrnkt
Modelle
Laufzeit
Speicherplatz O(n) O(log n) O(log n) O(log n) O(n) Zugriff Einfgen Lschen Sortierreihenfolge
Bei der exakten Berechnung ist die Basis des Logarithmus von der Kardinalitt der Zeichenmenge, z.B. 26 (Grossbuchstaben), 2 (Bitstrings)
E. Schikuta
E. Schikuta
273
274
4.9 Priority Queues Datenstruktur zum wiederholten Finden und Entfernen des Elementes mit dem kleinsten (bzw. grten) Schlsselwert aus einer Menge
Anwendungen
Simulationssysteme (Schlsselwerte reprsentieren Exekutionszeiten von Ereignissen) Prozessverwaltung (Prioritten der Prozesse) Numerische Berechnungen (Schlsselwerte entsprechen den Rechenfehlern, wobei zuerst die groen beseitigt werden) Grundlage fr eine Reihe komplexer Algorithmen (Graphentheorie, Filekompression, etc.) Anmerkung: Im folgenden betrachten wir o.B.d.A. nur Priority Queues die den Zugriff auf die kleinsten Elemente untersttzen VO Algorithmen und Datenstrukturen E. Schikuta
275
Operationen Construct
Erzeugen einer leeren Priority Queue
IsEmpty
Abfrage auf leere Priority Queue
Insert
Einfgen eines Elementes
FindMinimum
Zurckgeben des kleinsten Elementes
DeleteMinimum
Lschen des kleinsten Elementes
276
Implementationsanstze Ungeordnete Liste

Elemente werden beliebig in die Liste eingetragen (Aufwand O(1)). Beim Zugriff bzw. Lschen des kleinsten Elementes muss die Liste abgesucht werden Aufwand O(n).
Priority Queue als Baumstruktur Balanzierte Schlsselbume

Einfgen im balanzierten Schlsselbaum vom Aufwand O(log n) Zugriff realisieren durch Verfolgen des uersten linken Weges im Baum (zum kleinsten Element) Aufwand O(log n)
Geordnete Liste
Elemente werden in der Reihenfolge ihrer Gre eingetragen (Aufwand O(n)). Zugriff bzw. Lschen konstanter Aufwand O(1)
Gnstigste Realisierung ber ungeordnete, komplette Schlsselbume

mit der Eigenschaft, dass fr alle Knoten die Schlsselwerte ihrer Nachfolger grer (oder kleiner) sind
Problem
Aufwand O(n) schwer zu vermeiden.
E. Schikuta
277
278
Ungeordneter, kompletter Schlsselbaum Wertemenge

3 6 5 10 9 11
6 5 3
Heap Datenstruktur Realisierung eines Heaps effizient durch ein Feld

Die n Schlsselwerte des Heaps knnen als Folge von Elementen x0, x1, x2, xn-1 interpretiert werden, wobei die Position der einzelnen Knotenwerte im Feld durch folgende Regel bestimmt wird:
Wurzel in Position 0, die Kinder des Knotens i werden an Position 2i+1 und 2i+2 gespeichert.
10
11
Heap
Binrer kompletter Baum Wert jedes Knotens ist kleiner (grer) oder gleich den Werten seiner Nachfolgerknoten Wurzel enthlt kleinstes (grtes) Element Anordnung der Unterbume bez. Ihrer Wurzel undefiniert (ungeordneter Baum)
Beispiel
6
1
3
0
6
1
5
2
10
3
9
4
11
5
10
11
5
E. Schikuta
279
280
Zugriff Zugriff auf das kleinste Element mit konstanten Aufwand: O(1) Wurzel = erstes Element im Feld.
3 6 10 3
0
Klasse Priority Queue

class PQ { int *a, N; public: PQ(int max) { a = new int[max]; N = -1; } ~PQ() { delete[] a; } int FindMinimum(){ return a[0]; } int IsEmpty() { return (N == -1); } void Insert(int); int DeleteMinimum(); };
5 9 11 10
3
6
1
5
2
9
4
11
5
E. Schikuta
E. Schikuta
281
282
Einfgen in einen Heap

Neues Element an der letzten Stelle im Feld eintragen berprfen, ob die Heap Eigenschaft erfllt ist Wenn nicht, mit Elternknoten vertauschen und solange wiederholen bis erfllt Eintragen von 4
(an der letzten Stelle im Feld) Aufwand: O(log n) jetzt ok! 4 9 11 5
Methode Insert
void PQ::Insert(int v) { int child, parent; a[++N] = v; child = N; parent = (child - 1)/2; while(child != parent) { if(a[parent] > a[child]) { swap(a[parent], a[child]); child = parent; parent = (parent - 1)/2; } else break; // to stop the loop } }
3 6 10 9
Heap Eigenschaft nicht erfllt, daher mit Elternknoten vertauschen 5 11 4 10 6
E. Schikuta
283
284
Lschen aus einen Heap

Wurzel mit uerst rechten Blattknoten tauschen, diesen Blattknoten lschen, Wurzel in den Baum sinken lassen (mit kleinerem Kindknoten vertauschen), bis Heap Eigenschaft gilt. Aufwand: O(log n)
3 6 10 9 5 6 10 9 11 4 10 11 4 5
vertauschen, sinken lassen vertauschen
Methode DeleteMinimum
int PQ::DeleteMinimum() { int parent = 0, child = 1; int v = a[0]; a[0] = a[N]; N--; while(child <= N) { if(a[child] > a[child+1]) child++; if(a[child] < a[parent]) { swap(a[parent], a[child]); parent = child; child = 2*child + 1; } else break; // to stop the loop } return v; }
5 6 10 9 4 6 9 11
E. Schikuta
4 11 3
lschen ok!
285
286
Analyse Heap
Datenverwaltung
Heaps und Heaps Bitte zu unterscheiden! Der Begriff Heap wird in der Informatik zur Bezeichnung verschiedener Konzepte verwendet
Heap als Datenstruktur zur Speicherung von Priority Queues Heap als Speicherbereich zur Verwaltung (vom Benutzer selbst verwalteter) dynamisch allozierter Speicherbereiche Heap als Speicherform in Datenbanken
Datenmenge
unbeschrnkt
Modelle
Hauptspeicherorientiert Nur simple Operationen
Laufzeit
Speicherplatz Zugriff (Minimum/Maximum) Einfgen Lschen O(n) O(1) O(log n) O(log n)
Der Heap stellt eine effiziente Basisdatenstruktur fr viele weitere darauf aufbauende Datenstrukturen dar
E. Schikuta
E. Schikuta
287
288
Was nehmen wir mit? Baumstrukturen

Notation spez. Eigenschaften, von O(n) auf O(log n) Kapitel 5:
Suchbume
Binre Suchbume AVL-Bume 2-3-4 Bume B+-Baum Balanzierung
Vektoren
Trie Priority Queues

Heap
289
290
5 Vektoren Ein Vektor (Feld, array) verwaltet eine fix vorgegebene Anzahl von Elementen eines einheitlichen Typs.
Zugriff auf ein Element ber einen ganzzahligen Index (die Position im Vektor) Aufwand des Zugriffes fr alle Elemente konstant
5.1 Dictionary Ein Dictionary ist eine Datenstruktur, die nur die einfachen Operationen des Einfgens, Lschens und der Suche zur Verfgung stellt.
Ein Elemente im Dictionay besteht meist aus einem Schlssel- (key) und einem Informationsteil (info). Beispiele sind
Wrterbcher, Namenslisten, Bestandslisten, etc.
x0
x1
x2
xn-2
Xn-1
Vektoren sind zur Realisierung von Dictionaries gut geeignet Struktur

key0 info0
Methoden
Hashing: Datenorganisationsform Sortieren: Datenreorganisationsmethoden
key1 info1
key2 info2
Keyn-1 Infon-1
E. Schikuta
291
292
Beispiele Wrterbuch
(Ausschnitt)
Schlssel computable computation compute computer Information berechenbar Berechnung (be)rechnen Rechenautomat
Operationen Construct
Erzeugen eines leeren Dictionary
IsEmpty
Abfrage auf leeres Dictionary
Insert
Einfgen eines Elementes
Bestandsliste
Schlssel 1 4 17 25 Information CPU Bildschirm Tastatur Maus
Delete
Lschen eines Elementes
LookUp
Abfrage eines Elementes ber seinen Schlssel und liefern der Information
293
294
Klasse Dictionary
class Dictionary { private: node { KeyType Key; InfoType Info; }; node *Dict; int NumberElements; public: Dictionary(int max) { Dict = new node[max]; NumberElements = 0; } ~Dictionary() { delete Dict; } void Insert(KeyType k, InfoType I); void Delete(KeyType k); InfoType LookUp(KeyType k); };
5.2 Hashing Hashing ist eine Methode Elemente in einer Tabelle direkt zu adressieren, in dem ihre Schlsselwerte durch arithmetische Transformationen direkt in Tabellenadressen (Indizes) bersetzt werden
Mit anderen Worten, der Index (die Position in der Tabelle) eines Elements wird aus dem Schlsselwert des Elements selbst berechnet. Tabelle Schlssel Adresse (Index)
0 1 2 3 4 5 6
Schlssel
Transformation
...
m-1
E. Schikuta
295
296
Hashing, allgemein Ansatz

Menge K von n Schlsseln {k0, k1, , kn-1} Hashtabelle T der Gre m Randbedingung: n >> m
(Anzahl der mglichen Schlsselwerte viel grer als Pltze in der Tabelle)
Hashfunktion Gewnschte Eigenschaften

Einfach und schnell zu berechnen. Elemente werden gleichmig in der Tabelle verteilt. Alle Positionen in der Tabelle werden mit gleicher Wahrscheinlichkeit berechnet. Beispiele
Modulo Bildung, Schlssel mod m Man sollte darauf achten, da m eine Primzahl ist, sonst kann es bei Schlsseltransformationen (Strings) zu Clusterbildungen (Anhufungen) durch gemeinsame Teiler kommen. Bitstring-Interpretation Teile aus der binren Reprsentation des Schlsselwertes werden als Hashwert herangezogen. Transformationstabellen
Transformation
Hash-Funktion h h: K {0, 1, m-1} Fr jedes j soll der Schlssel k j an der Stelle h(kj) in der Tabelle gespeichert werden. Der Wert h(K) wird als HashWert von K bezeichnet.
Wahl der Hashfunktion (eigentlich) beliebig!
297
298
Beispiel Hashing
Bestandsliste
Gre der Liste 7 Hashfunktion h(k) = k mod 7
Kollision Eine Kollision tritt auf, wenn zwei oder mehrere Schlsselwerte auf dieselbe Tabellenposition abgebildet (gehasht) werden.
Datenstze
Schlssel 1 4 17 25 Information CPU Bildschirm Tastatur Maus
1 mod 7 = 1 17 mod 7 = 3 4 mod 7 = 4
0 1 2 3 4 5 6
1 17 4
CPU Tastatur Bildschirm
Dies bedeutet, da fr 2 Schlssel ki, kj, mit ki kj, gilt h(ki) = h(kj).
Diese Situation ist aber zu erwarten, da es viel mehr mgliche Schlssel als Tabellenpltze gibt (n >> m als Randbedingung). Die Hashfunktion h ist i.a. nicht injektiv, d.h. aus h(x)=h(y) folgt nicht notwendigerweise x=y.
25 mod 7 = 4 Position in der Tabelle schon besetzt
Kollision
299
300
Kollisionsbehandlung Eine Kollision lst eine notwendige Kollisionsbehandlung aus.
5.2.1 Separate Chaining Beim Separate (Simple) Chaining wird die Kollisionsbehandlung mit linearen Listen bewerkstelligt.
Kollidierende Schlsselwerte werden in einer linearen berlaufkette (Liste) ausgehend vom ursprnglich gehashten Tabellenplatz gespeichert. Wichtig: Element am Beispiel: Kopf der Liste
0 1 2 3 4 5 6 4 Bildschirm 17 39 Tastatur Drucker 25 Maus 1 CPU
D.h., fr den kollidierenden Schlsselwert mu ein Ausweichsplatz gefunden werden.

Manahmen zur Kollisionsbehandlung sind meist recht aufwendig und beeintrchtigen die Effizienz von Hashverfahren.
h(k) = k mod 7
einfgen, da sonst der Aufwand gegen O(n) wachsen kann!
der Kollisionspfad ist definiert durch die Ausweichpltze aller Elemente, die auf den gleichen Platz "ge-hasht" wurden Wir betrachten nun 2 simple Kollisionsbehandlungen Separate Chaining und Double Hashing
Der Eintrag des Elementes (39, Drucker) fhrt zu einer Verlngerung der berlaufkette.
301
302
5.2.2 Double Hashing Beim Double Hashing wird bei Kollision eine zweite, von h unabhngige, Hashfunktion zur Bestimmung einer alternativen Position verwendet.
berlauf auf Position a0 = h(k) Bestimmung einer alternativen Position mit Kollisionsfunktion g : K {1, m-1}, z.B. ai+1 = (ai + g(k)) mod m Beispiel Kollision K
h(k) = k mod 7 g(k) = letzte Ziffer von k mal 3 K a0 = 25 mod 7 = 4 a1 = (4 + (5*3)) mod 7 = 5 K a0 = 39 mod 7 = 4 a1 = (4 + (9*3)) mod 7 = 3 a2 = (3 + (9*3)) mod 7 = 2
Linear Probing Spezialfall des Double Hashing Kollisionsbehandlung: Man verwendet den nchsten freien Platz
Bei Erreichen des Tabellenendes sucht man am Tabellenanfang weiter Hashfuktionen: a0 = h(k), ai+1 = (ai + g(k)) mod m
g(k) = 1
0 1 2 3 4 5 6
1 39 17 4 25
CPU Drucker Tastatur Bildschirm Maus
Beispiel
25 mod 7 = 4 (4+1) mod 7 = 5 39 mod 7 = 4 (4+1) mod 7 = 5 (5+1) mod 7 = 6
0 1 1 17 4 25 39 CPU Tastatur Bildschirm Maus Drucker 2 3 4
K K K
5 6
E. Schikuta
303
304
Suchen und Lschen in Hashtabellen Suchen

Solange eine Zieladresse durch ein Element belegt ist, und der gesuchte Schlsselwert noch nicht gefunden wurde, mu ber den Kollisionspfad weitergesucht werden.
Separate Chaining: Verfolgen der linearen Liste Double Hashing: Aufsuchen aller mglichen Pltze der Kollisionsfkt.
Eigenschaften Generell fr Hashverfahren

+ Aufwand beim Zugriff auf ein Element im besten Fall konstant, O(1), einfache Evaluation der Hashfunktion. - Kollisionsbehandlung aufwendig, volle Hashtabelle fhrt zu vielen Kollisionen, daher (Faustregel) nie ber 70% fllen. - Kein Zugriff in Sortierreihenfolge.
Lschen
Separate Chaining: Entfernen des Listenelements Double Hashing: Positionen, an denen ein Element gelscht wurde, mssen gegebenenfalls mit einem speziellen Wert (wiederfrei) markiert werden, damit der entsprechende Kollisionspfad fr die restlichen Elemente nicht unterbrochen wird.
Separate Chaining
+ Dynamische Datenstruktur, beliebig viele Elemente. - Speicherplatzaufwendig (zustzliche Zeigervariable).
Double Hashing
+ Optimale Speicherplatzausntzung. - Statische Datenstruktur, Tabellengre vorgegeben. - Kollisionbehandlung komplex, wiederfrei Markierung beim Lschen.
305
306
Analyse Hashing Datenverwaltung

Analyse Hashing (2)
Datenmenge
beschrnkt
abhngig von der Gre der vorhandenen Hashtabelle
Speicherplatz Konstruktor Zugriff Einfgen Lschen
O(1) O(1) O(1) O(1) O(1)
Modelle
Hauptspeicherorientiert Untersttzung simpler Operationen
keine Bereichsabfragen, keine Sortierreihenfolge
gltig nur fr reines Hashverfahren ohne Kollisionsbehandlung
Bitte beachten: Aufwand von Hashing stark abhngig vom Kollisionsverfahren, geht aber oft gegen O(n)
307
308
5.3 Dynamische Hash-Verfahren Dynamischen Hash-Verfahren versuchen im Falle von Kollisionen die ursprngliche Hashtabelle zu erweitern
Anlegen von berlaufbereichen (z.B. lineare Listen) Vergrerung des Primrbereichs (ursprngliche Tabelle)
Erfordert Modifikation der Hash-Funktion Ansatz: Familien von Hash-Funktionen h1: K addr1 ... hn: K addrn Wobei |addr1| < |addr2| < ... < |addrn| Ziel: Wechsel von addri auf addri+1 erfordert minimale Reorganisation der Hash-Tabelle (d.h. Umspeichern von Daten minimieren)
Hash-Funktionen Schema Simpler Ansatz

|addri+1| = 2 * |addri| h(x) ist eine Hash-Funktion hi(x) seien die i least significant bits von h(x)
Somit gilt
hi+1(x) = hi(x) oder hi+1(x) = hi(x) + 2i Beispiel:
addr2 = 0 .. 3, addr3 = 0 .. 7, h(x) = x 4 Adresswechsel
Wert 7 8 9 10 13 14 23 26
h(x) 7 8 9 10 13 14 23 26
binr 00111 01000 01001 01010 01101 01110 10111 11010
h 2(x) 11=3 00=0 01=1 10=2 01=1 10=2 11=3 10=2
h3(x) 111=7 000=0 001=1 010=2 101=5 110=6 111=7 010=2

E. Schikuta
309
310
Dynamische Hashverfahren Two-Disk-Access Prinzip

Finden eines Schlssel mit maximal 2 Platten Zugriffen
5.3.1 Linear Hashing W. Litwin 1980 Organisation der Elemente in Blcken (Buckets)
Analog zu B-Bumen Blockgre b
Hashverfahren fr externe Speichermedien

Linear Hashing
Verzeichnisloses Hashverfahren Primrbereiche, berlaufbereiche
Idee
Bei berlauf eines Blocks (Splitting) wird der Primr- und berlaufbereich um jeweils einen Block erweitert Primrbereich durch Hinzufgen eines Blocks am Ende der Hash-Tabelle berlaufbereich durch lineare Liste
Extendible Hashing
Verzeichnis mit binrer Expansion Primrbereiche
Bounded Index Size Extendible Hashing

Verzeichnis mit beschrnkter Gre Binre Expansion der Blcke
E. Schikuta
311
312
Splitting und Suche Splitting wird Runden-weise durchgefhrt

Eine Runde endet, wenn alle ursprnglichen N Blocks (fr Runde R) gesplittet worden sind
Blocks 0 bis NextToSplit-1 sind schon gesplittet Nchster Block zum Splitten ist definiert durch Index NextToSplit
Einfgen Einfgen
Suche Block (hd oder hd+1) Falls Block voll
Fge Element in einen berlaufblock Neues Element in der linearen Liste Splitte Block NextToSplit und erhhe NextToSplit um 1
Aktuelle Rundennummer ist definiert durch d
Suche
Suche nach Wert x
d=2, NextToSplit=1, b=3

2=000010 8=001000 17=010001 25=011001 28=011100 34=100010 50=110010
Beispiel: Einfgen von 6 (=000110)

d=2, NextToSplit=1, b=3 000 8 01 17 25 10 34 50 2 11 100 28
d=2, NextToSplit=2, b=3 000 8 001 17 25 10 34 50 2 11 100 28 101
000 8 a = hd(x); 01 17 25 if(a < NextToSplit) a = hd+1(x); 10 34 50 2 11 100 28
2=000010 8=001000 17=010001 25=011001 28=011100 34=100010 50=110010
E. Schikuta
E. Schikuta
313
314
Beispiel: linear Hashing

Aktuelle hi(x) = h3(x)
d=3, NextToSplit=0, b=3 000 001 010 011 100 101 110 111
Bemerkungen
Die Rundennummer d wird erhht, wenn das Splitting einmal durch ist, d.h.
if(NextToSplit == 2d) { d++; NextToSplit=0; }
Einfgen: 16, 13, 21, 37

d=3, NextToSplit=0, b=3 000 001 010 011 100 101 110 111 d=3, NextToSplit=1, b=3 0000 001 010 011 100 101 110 111 1000
8 17 25 34 50 2 28 5 55
28=011100 34=100010 50=110010 55=110111
8 16 17 25 34 50 2 28 5 13 21 55 37 Split
16 17 25 34 50 2 28 5 13 21 55 8
Expansionspolitik
Bei jedem berlauf Splitten nicht wirklich sinnvoll Salzberg schlgt vor Expansion durchzufhren, wenn seit der letzten Expansion genau L * b Datenstze eingefgt wurden L ist definiert durch den Belegungsfaktor, d.h L = Rohdatenvolumen / Volumen der Datenstruktur Lange berlaufketten werden in jedem Fall vermieden
2=000010 5=000101 8=001000 17=010001 25=011001
16=010000 13=001101 21=010101 37=100101
37 berlaufblock
E. Schikuta
In der Praxis keine linearen Adressrume sondern Aufteilen des Primrbereiches auf mehrere Hash Dateien pro Platte
Zuordnungssystem ber Verwaltungsblcke
E. Schikuta
315
316
5.3.2 Extendible Hashing Hash-Verfahren mit Index

R. Fagin, J. Nievergelt, N. Pippenger and H.R. Strong, 1979 Eigenschaften
Struktur und Suche

d=2, b=4 14 8 10 26 9 13 7 31 23
14=01110 23=10111 26=11010 31=11111
1
Idee
Wenn Primrbereich zu klein wird, Vergrerung durch Verdopplung Primrbereich wird ber Index T verwaltet Bei berlauf eines Blocks Split dieses Blocks und Verwaltung des Blocks durch Verdoppeln des Index
Index ist viel kleiner als die Datei, daher Verdoppeln viel gnstiger
Index T Jeder Indexeintrag referenziert genau einen Datenblock Jeder Datenblock wird von genau 2k mit k 00 aus N0 Indexeintrgen referenziert 01 10 Die Anzahl der Indexeintrge, die den 11 Block referenzieren ist im Block lokal bekannt
Wird durch eine lokale Tiefe t verwaltet (Gegensatz globale Tiefe d fr die gesamte Hash-Tabelle) Anzahl der den Block referenzierenden Verzeichniseintrge entspricht 2d-t
Keine berlaufbereiche Suche
7=00111 8=01000 9=01001 10=01010 13=01101
Lokale Tiefe
Element x im Block T[hd(x)]

317
318
Einfgen Zwei Flle zu unterscheiden falls ein Block berluft

t < d: mehrere Indexeintrge referenzieren diesen Block t = d: ein Indexeintrag referenziert diesen Block
Einfgen Fall 1: t < d

Versuch den Split ohne Indexexpansion durchzufhren
Neuen Datenblock anfordern Aufteilung der Daten des berlaufenden Blocks nach ht+1 t = t + 1 fr alten und neuen Datenblock Falls Split wieder zu einem berlauf fhrt, wiederholen
Fall 1: t < d
Einfgen von 6
6=00110 d=2, b=4 14 8 10 26
00 01 10 11
1
Fall 2: t = d
Einfgen von 15, 19
15=01111 19=10011
9 13 7 31 23
7=00111 8=01000 9=01001 10=01010 13=01101 14=01110 23=10111 26=11010 31=11111
Einfgen von 6 (=00110)

d=2, b=4 14 8 10 26
00 01 10 11
1
d=2, b=4
00 01 10 11
8 14 6 10 26 9 13 7 31 23
9 13 7 31 23
2
E. Schikuta
E. Schikuta
319
320
Einfgen Fall 2: t = d
Erfordert eine Indexexpansion (Verdoppelung)
Neuen Speicherbereich fr 2d zustzliche Referenzen anfordern Fr jedes T[x], fr das gilt x 2d: T[x] = T[x-2d] d = d+1
Einfgen Fall 2: t = d (2)

Jetzt Fall 1
7=00111 15=01111 19=10011 23=10111 31=11111
Danach Rckfhrung auf Fall 1 Einfgen von 15 und 19

d=2, b=4
00 01 10 11
d=3, b=4
000 001 010 011 100 101 110 111
d=3, b=4 8 9 13 14 6 10 26 7 31 23 15
2
d=3, b=4 8 9 13 14 6 10 26 7 31 23 15
2
8 9 13 14 6 10 26 7 31 23 15
Indexexpansion
000 001 010 011 100 101 110 111
19
000 001 010 011 100 101 110 111
8 9 13 14 6 10 26 19 7 31 23 15
3 3
E. Schikuta
E. Schikuta
321
322
Problem des Indexwachstums

Indexexpansion kann scheitern, mehrfache Verdoppelungen
d=1, b=4
0 1
Kommentare Lschen leerer Blcke nicht einfach

Verschmelzung mit ihren Split-Buddies (Split-Images) Analog fr Indexverkleinerung
16 8 28 32 9 13
Einfgen 56 d=2, b=4

00 01 10 11
8=001000 9=001001 13=001101 16=010000 28=011100 32=100000 56=111000
d=3, b=4 16 8 56 32
000 001 010 011 100 101 110 111
3
9 13 28
Falls Index im Hauptspeicher gehalten werden kann, nur ein externer Zugriff notwendig Im worst case exponentielles Indexwachstum
Typisch bei clustered data (Daten sind nicht gleichverteilt) Daher Speicherplatzbedarf fr Index im worst case nicht akzeptierbar
Index normalerweise im Hauptspeicher
16 8 28 32 9 13
56
2
2 2
1. Indexexpansion
2. Indexexpansion
E. Schikuta
Problem der Blockung des Index auf der Platte Keine garantierte Mindestauslastung
323
324
Analyse Analyse komplex

Es lsst sich zeigen, dass Extendible Hashing zur Speicherung einer Datei mit n Datenstzen und einer Blockgre von b Datenstzen ungefhr 1.44*(n/b) Blcke bentigt Das Verzeichnis hat durchschnittlich fr gleichverteilte Datenstze n1+1/b/b Eintrge
5.3.3 Bounded Index Size Extendible Hashing Ansatz durch

Primrbereich (analog zu Extendible Hashing) Index mit beschrnkter Gre Binre Expansion der Datenbereiche
(1 Block, 2, 4, ... Blcke)
Groer Vorteil falls das Verzeichnis in den Hauptspeicher passt, nur ein Plattenzugriff auf einen Datensatz notwendig
Versucht dem Unvermgen des Extendible Hashings, den Index auf der Platte unterzubringen, mit einer speziellen Indexstruktur zu begegnen
E. Schikuta
E. Schikuta
325
326
Struktur
Index besteht aus x Bereichen Ein Bereich enthlt y Eintrge der Form <z, ptr> wobei
ptr ist eine Adresse auf einen Plattenblock z gibt die Anzahl der Verdoppelungen der entspr. Datenbereiche d.h. ptr ist die Adresse eines Datenbereichs mit 2z Plattenblcken x und y sind Potenzen von 2
Beispiel BISEH
b=2 (Blockgre), x=4 (Indexbereiche), y=4 (Eintrge pro IB) 64
00 00 0 01 10 11 225
67
10 11
155
01
0 0 0
255 255 = 1111 11 11 200 = 1100 10 00 56 = 0011 10 00 64 = 0100 00 00 155 = 1001 10 11 67 = 0100 00 11 12 = 0000 11 00 205 = 1100 11 01 225 = 1110 00 01
Hash-Werte werden gezont interpretiert, z.B.

16 Indexbereiche (x=16), 32 Eintrge pro Indexbereich (y=32), 4 Blcke in jedem Datenbereich
Hash-Signatur fr den 0. Block der vom 20. Eintrag im Indexbereich 10 referenziert wird 10. Indexbereich 0110 00 10100 1010
0 0
0
205 200 56
12
0. Plattenblock
20. Eintrag im IB 10
E. Schikuta
E. Schikuta
327
328
Beispiel BISEH (2)

Einfgen von 128 und 144, im ersten Versuch erfolgreich
64 128 0 1 144 225
Beispiel BISEH (2)

Einfgen von 95 und 31, erst im zweiten Versuch erfolgreich
64 128 144 225
67 10 11 0 0 0
255
155 255 = 1111 11 11 200 = 1100 10 00 56 = 0011 10 00 64 = 0100 00 00 155 = 1001 10 11 67 = 0100 00 11 12 = 0000 11 00 205 = 1100 11 01 225 = 1110 00 01 128 = 1000 00 00 144 = 1001 00 00
67 10 11 0 0 2
155 255 = 1111 11 11 200 = 1100 10 00 56 = 0011 10 00 64 = 0100 00 00 155 = 1001 10 11 67 = 0100 00 11 12 = 0000 11 00 205 = 1100 11 01 225 = 1110 00 01 128 = 1000 00 00 144 = 1001 00 00 95 = 0101 11 11 31 = 0001 11 11
E. Schikuta
Ex
n pa
si
on
00 1 0 0
01 0
00 1 0 0
01 0
0
205 200 56
0
205 200 56
12
12
00
95 31 01 255
10 11
E. Schikuta
329
330
Allgemeiner Vergleich von Hash- zu Index-Verfahren Punkte, die zu beachten sind: Kosten der periodischen Reorganisation Hufigkeit von Einfgen und Lschen Average Case versus Worst Case Aufwand Erwartete Abfrage Typen
Hashing ist generell besser bei exakten Schlsselabfragen Indexstrukturen sind bei Bereichsabfragen vorzuziehen
5.4 Sortierverfahren Das Sortieren von Elementen (Werten, Datenstzen, etc.) stellt in der Praxis der EDV eines der wichtigsten und aufwendigsten Probleme dar.
Es existieren hunderte Sortieralgorithmen in den verschiedensten Varianten fr unterschiedlichste Anwendungsflle.
Hauptspeicher - Externspeicher Sequentiell - Parallel Insitu - Exsitu Stable - Unstable ...
Sortierverfahren gehren zu den am umfangreichsten analysierten und verfeinerten Algorithmen in der Informatik.
331
332
Kriterien fr die Auswahl von Sortierverfahren

Hauptspeicher - Externspeicher
Kann der Algorithmus nur Daten im Hauptspeicher oder auch Files (Dateien) oder Bnder auf dem Externspeicher (Platte, Bandstation) sortieren?
Sortierverfahren
Aufgabe
Ein Vektor der Gre n der Form V[0], V[1], , V[n-1] ist zu sortieren.
Lexikographische Ordnung auf den Elementen.
Nach dem Sortieren soll gelten: V[0] V[1] V[n-1].
Insitu - Exsitu
Kommt das Sortierverfahren mit ursprnglichen Datenbereich aus (insitu) oder braucht es zustzlichen Speicherplatz (exsitu)?
Elementare (Simple) Verfahren (Auswahl)

Selection Sort Bubble Sort
Worst Case - Average Case

Ist das (asymptotische) Laufzeitverhalten des Sortierverfahrens immer gleich oder kann es bei speziellen Fllen entarten (schneller oder langsamer werden)?
Verfeinerte (Intelligentere) Verfahren (Auswahl)

Quicksort Mergesort Heapsort
Stable - Unstable
Wenn mehrere Datenstze denselben Schlsselwert haben, bleibt dann die ursprngliche Reihenfolge nach dem Sortieren erhalten?
E. Schikuta
333
334
Klasse Vector
class Vector { int *a, size; public: Vector(int max) { a = new int[max]; size = max; } ~Vector() { delete[] a; } void Selectionsort(); void Bubblesort(); void Quicksort(); void Mergesort(); int Length(); private: void quicksort(int, int); void mergesort(int, int); void swap(int&, int&); };
5.4.1 Selection Sort Selection Sort oder Minimumsuche

Finde das kleinste Element im Vektor und vertausche es mit dem Element an der ersten Stelle. Wiederhole diesen Vorgang fr alle noch nicht sortierten Elemente. Swap
Das Vertauschen (Swap) zweier Elemente (int) stellt einen zentralen Vorgang beim Sortieren dar. void swap(int &x, int &y) { int help = x; x = y; y = help; }
335
336
Selection Sort, Beispiel Beispiel

v[0] n=6 P v[1] E v[2] V v[3] A v[4] K v[5] S
Selection Sort, Algorithmus Algorithmus

void Vector::Selectionsort() { int n = Length(); int i, j, min; for(i = 0; i < n; i++) { min = i; for(j = i+1; j < n; j++) if(a[j] < a[min]) min = j; swap(a[min], a[i]); } }
P A A A A A
E E E E E E
V V V K K K
A P P P P P
K K K V V S
S S S S S V
swap(v[0], v[3]) --swap(v[2], v[4]) --swap(v[4], v[5])
E. Schikuta
337
338
Selection Sort, Eigenschaften Eigenschaften

Hauptspeicheralgorithmus Insitu Algorithmus
sortiert im eigenen Datenbereich, braucht nur eine temporre Variable, konstanter Speicherplatzverbrauch
5.4.2 Bubble Sort Bubble Sort

Wiederholtes Durchlaufen des Vektors. Wenn 2 benachbarte Elemente aus der Ordnung sind (greres vor kleinerem), vertausche (swap) sie.
Dadurch wird beim ersten Durchlauf das grte Element an die letzte Stelle gesetzt, beim 2. Durchlauf das 2.grte an die vorletzte Stelle, usw. Die Elemente steigen wie Blasen (bubbles) auf.
Aufwand
generell O(n2)
E. Schikuta
E. Schikuta
339
340
Bubble Sort, Beispiel Beispiel

v[0]
n=6
Bubble Sort, Algorithmus Algorithmus
v[1] P E
v[2] V
v[3] A
v[4] K
v[5] S
swaps:
P E E A A A
E P A E E E
V A K K K K
A K P P P P
K S S S S S
S V V V V V
P-E, V-A, V-K, V-S P-A, P-K E-A
void Vector::Bubblesort() { int n = Length(); int i, j; for(i = n-1; i >= 1; i--) for(j = 1; j <= i; j++) if(a[j-1] > a[j]) swap(a[j-1], a[j]); }
E. Schikuta
E. Schikuta
341
342
Bubble Sort, Eigenschaften Eigenschaften

sortiert im eigenen Datenbereich, braucht nur eine temporre Variable, konstanter Speicherplatzverbrauch
5.4.3 Quicksort Quicksort (Hoare 1962)

Der Vektor wird im Bezug auf ein frei whlbares Pivotelement durch Umordnen der Vektorelemente in 2 Teile geteilt, soda alle Elemente links vom Pivotelement kleiner und alle Elemente rechts grer sind. divideandDie beiden Teilvektoren werden unabhngig conquer voneinander wieder mit quicksort Eigenschaft (rekursiv) sortiert.
Das Pivotelement steht dadurch auf seinem endgltigen Platz. Es bleiben daher nur mehr n-1 Element (in den beiden Teile) zu sortieren (Verringerung der Problemgre)
Aufwand
generell O(n2)
Beruht auf dem divide-and-conquer Ansatz.
E. Schikuta
E. Schikuta
343
344
Pivotelement umordnen
Beliebiges Element als Pivotelement whlen
(im u.a. Bsp. linkes Element im Vektor, auch zufllige Wahl oder Median aus 3 zuflligen blich)
B T E E E E E E B E E E V A K N B B B B B B A A A A P V B A A P V
Pivotelement umordnen (2)

A K K A P K K K N N P P N N K K K B V N N N P N B P P V V V V V
Pivotelement von links bzw. rechts in den Vektor hineinsinken lassen,

d.h. jeweils sequentiell von links mit allen kleineren Elementen, von rechts mit allen greren vertauschen.
Bei Blockierung, d.h. links kleineres und rechts greres Element, diese beiden Elemente vertauschen
Pivotelement
P
von links hineinsinken von links hineinsinken

E B P
umgeordnete Elemente blockierende Elemente Pivotelement

E. Schikuta
von rechts hineinsinken

B,T
E. Schikuta
von rechts hineinsinken Blockierung u. Tausch
345
346
Quicksort, Rekursion
v[0] n=7 P v[1] E v[2] V v[3] A v[4] K v[5] N v[6] B
Quicksort, Algorithmus
void Vector::Quicksort() { quicksort(0, Length()-1); } void Vector::quicksort(int l, int r) { int i, j; int pivot; if(r > l) { pivot = a[l]; i = l; j = r+1; for(;;) { while(a[++i] < pivot) if (i == r) break; while(a[--j] > pivot); if(i >= j) break; swap(a[i], a[j]); } swap(a[j], a[l]); quicksort(l, j-1); quicksort(j+1, r); } }
Pivot: P swaps: P-E, V-B, P-B, P-A, P-K, P-N E B A K Pivot: E swaps: E-B, E-A B A Pivot: B swaps: B-A A Pivot: A swaps: A A B E K
V Pivot: V swaps: V
K Pivot: K swaps: K
N Pivot: N swaps: N N P V
E. Schikuta
E. Schikuta
347
348
Quicksort, Eigenschaften
sortiert im eigenen Datenbereich, braucht nur temporre Hilfsvariable (Stack), konstanter Speicherplatzverbrauch
5.4.4 Mergesort Mergesort (???, 1938)

Der zu sortierende Vektor wird rekursiv in Teilvektoren halber Lnge geteilt, bis die (trivialen, skalaren) Vektoren aus einem einzigen Element bestehen. Danach werden jeweils 2 Teilvektoren zu einem doppelt so groen Vektor gemerged (sortiert).
Beim Mergen werden sukkzessive die ersten beiden Element der Vektoren verglichen und das kleinere in den neuen Vektor bertragen, bis alle Elemente im neuen Vektor sortiert gespeichert sind. Das Mergen wird solange wiederholt, bis in der letzten Phase 2 Vektoren der Lnge n/2 zu einem sortierten Vektor der Lnge n verschmelzen.
Aufwand
Im Durchschnitt O(n*log(n)) Kann zu O(n2) entarten
Beispiel: Vektor ist vorsortiert und als Pivotelement wird immer das erste oder letzte Vektorelement gewhlt
Empfindlich auf unvorsichtige Wahl des Pivotelements Stabilitt nicht einfach realisierbar Rekursiver Algorithmus
Komplex zu realisieren, wenn Rekursion nicht zur Verfgung steht
divide-and-conquer Ansatz.
349
350
Merging Merging zweier Vektoren

trivialer Fall
Mergesort, Rekursion
n=4
v[0] P
v[1] E E E
v[2] V
v[3] A V V A A Zerlegungsphase
1, 5 P
allgemeiner Fall
E 1, 4, 5, 7, 9, 11, 12, 14 2, 3, 6, 8, 10, 13, 15 A
P E P
A V
Mergephase
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
E. Schikuta
E. Schikuta
351
352
Mergesort, Algorithmus
void Vector::Mergesort() { mergesort(0, Length()-1); } void Vector::mergesort(int l, int r) { int i, j, k, m; Vector help(r-l+1); if(r > l) { m = (r+l)/2; mergesort(l, m); mergesort(m+1, r); for(i=m+1; i>l; i--) help.a[i-1] = a[i-1]; for(j=m; j<r; j++) help.a[r+m-j] = a[j+1]; for(k=l; k<=r; k++) a[k]=(help.a[i]<help.a[j])?help.a[i++]:help.a[j--]; } }
Mergesort, Eigenschaften Eigenschaften

Hauptspeicheralgorithmus, aber auch als Externspeicheralgorithmus verwendbar.
Extern Sortieren: statt Teilphase wird oft vorgegebene Datenaufteilung genommen, oder nur soweit geteilt, bis sich Teilvektor (Datei) im Hauptspeicher sortieren lsst.
Exsitu Algorithmus
braucht einen zweiten ebenso groen Hilfsvektor zum Umspeichern
Aufwand
Generell O(n*log(n)) Braucht doppelten Speicherplatz
Rekursiver Algorithmus
Komplex zu realisieren, wenn Rekursion nicht zur Verfgung steht.
353
354
5.4.5 Heapsort Eine Heap (Priority Queue) kann Basis zum Sortieren bilden (Williams 1964):
1. ein Element nach dem anderen in einen Heap einfgen 2. sukzessive das kleinste bzw. grte Element entfernt
die Element werden in aufsteigender bzw. absteigender Ordnung geliefert
Heapsort (modifizierter Ansatz) Kombination der beiden Arrays, Vermeidung von doppeltem Speicherplatz
6
0
9
1
11
2
10
3 4 5
6
0
9
1
11
2
10
3
5
4
3
5
1.
6 1 10 9
2.
0 5 2 11 10 6 1 9
0 11 2 10 9 1
0 11 2
...
Heap-Eigenschaft umdrehen: Wert jedes Knotens ist grer oder gleich den Werten seiner Kinderknoten
3 0 5 1 10 9 11 2
11 9 1 3 6
0 10 2 5
11
0
9
1
10
2
3
3
6
4
5
5
3 6
0 1
5 10 9 11
2 3 4 5
5
0
6 11 10 9
1 2 3 4 5
6
0
9 11 10
1 2 3 4 5 0 1 2 3 4 5
3
9 10 11
5
E. Schikuta
355
356
Beispiel: buildheap
Wertemenge
9 6 5 10 3 11
6 1 9
0
Beispiel: heapsort
11 10 1 6 11
0
0 5
Idee: Heap-Eigenschaft erzeugen; fr Blattknoten trivialerweise erfllt

2 Nr. 2 erster zu prfender
0 9 2 5 3
4
Idee: Maximum "lschen" und am freiwerdenden Platz sichern

10 6 5 5
5
6
1
5
2
10
3
3
4
11
5
10
3 9
4 0
11
Knoten, 11 passt nicht, in Baum sinken lassen, d.h. 5 mit 11 tauschen

11 0 9 1 6 3 3 4 5 5 2
0 9 6 2 1 5 3 11
4 5
0 3 2
3 10
1
3 9
2
4 6
3
1 3 10 6
0 1
9 6 1 10 3 3 4
0 11 2 5 5 6 3 10 1 3
3 9
2
4 5
3
9
0
3 6
1
3
2
5 10 11
3 4 5
11 2 4 5 5
10
6 5 1 6
0
0 3 2 3 1 5
0
Wert 6 (Nr. 1) passt nicht, in Teilbaum sinken lassen, d.h. mit grerem der Nachfolger vertauschen, d.h. 6 mit 10
Nr. 0 (9) in Baum sinken.
Heap-Eigenschaft erfllt!
11
0
10
1
9
2
6
3
3
4
5
5
5
1
3
2
9 10 11
3 4 5
3
1
6
2
9 10 11
3 4 5
3
0
5
1
6
2
9 10 11
3 4 5 E. Schikuta
E. Schikuta
357
358
Heapsort Algorithmus (1)

void Vector::Heapsort() { int heapsize = Length(); BuildMaxheap(); for(int i = Length()-1; i >= 1; i--) { swap(a[0], a[i]); heapsize--; heapify(0, heapsize); } } void Vector::BuildMaxheap() { for(int i = Length()/2 - 1; i >= 0; i--) heapify(i, Length()); }
Heapsort Algorithmus (2)

void Vector::heapify(int i, int heapsize) { int left = 2*i + 1; int right = 2*i + 2; int largest; if (left < heapsize && a[left] > a[i]) largest = left; else largest = i; if (right < heapsize && a[right] > a[largest]) largest = right; if (largest != i) { swap(a[i], a[largest]); heapify(largest, heapsize); } }
E. Schikuta
359
360
Eigenschaften der komplexen Verfahren Quicksort

Entartung zu O(n2) mglich
Sekunden 500 400 300 200 100 0 2500 3000
Laufzeitvergleich der Verfahren
Wahl des Pivotelements!
Mergesort
immer Laufzeit O( n * log(n) ) doppelter Speicherplatz notwendig
Heapsort
keinen der obigen Nachteile aber hherer konstanter Aufwand
3500
4000
4500
5000
Vektorgre Bubble Sort Mergesort Selection Sort Heapsort Quicksort
E. Schikuta
E. Schikuta
361
362
Comparison Sort Verfahren Man nennt diese bekannten Verfahren Vergleichende Sortierverfahren (Comparison sort)
Die Reihenfolge der Elemente wird dadurch bestimmt, dass die Elemente miteinander verglichen werden
Nur Vergleiche der Form xi < xj,, xi xj, ... angewendet
Entscheidungsbaum Betrachtung der Vergleichenden Sortierverfahren durch Entscheidungsbume

Der Entscheidungsbaum enthlt alle mglichen Vergleiche eines Sortierverfahrens um eine beliebige Sequenz einer vorgegebenen Lnge zu sortieren
Die Blattknoten reprsentieren alle mglichen Permutationen der Eingabe Sequenz
Diese Algorithmen zeigen als gnstigste Laufzeit eine Ordnung von O(n log n), d.h. wir konnten bis jetzt als untere Grenze (n log n) feststellen
Vermutung: Das Problem des Sortierens durch Vergleichen der Elemente lsst sich mit (n log n) beschreiben Falls gltig Algorithmische Lcke geschlossen, da (P) = O(A)
Die Wege von der Wurzel zu den Blttern definieren die notwendigen Vergleiche um die entsprechenden Permutationen zu erreichen
E. Schikuta
363
364
Beispiel Entscheidungsbaum Entscheidungsbaum fr 3 Elemente

d.h. 3! = 6 mgliche Permutationen der Eingabe Elemente < x1 ,x2 ,x3 > x1:x2 x2:x3 1,2,3 x1:x3 2,1,3 x1:x3 x2:x3
Beweis: Untere Grenze fr den worst case

Wir ignorieren Swappen, Administrationsoperationen, etc. Die Anzahl der Bltter im Entscheidungsbaum ist n! Die Anzahl der Bltter in einem binren Baum ist 2h daher
2 h n! h lg(n!) Stirlingsche Nherung n h > lg( ) n = n lg n n lg e e h = (n lg n)

n n n! = 2n ( ) n (1 + (1 / n)) > ( ) n e e
d.h. Algorithmische Lcke fr Vergleichende Sortierverfahren geschlossen
E. Schikuta
1,3,2
3,1,2
2,3,1
3,2,1
E. Schikuta
365
366
5.5 Sortieren in linearer Zeit Sortierverfahren, die nicht auf dem Vergleich zweier Werte beruhen, knnen eine Eingabe Sequenz in linearer Zeit sortieren
Erreichen die Ordnung O(n)
5.5.1 Counting Sort 1954 Erstmals verwendet von Harold H.Seward MIT Thesis Information Sorting in the Application of Electronic Digital Computers to Bussiness Operations als Grundlage fr Radix Sort. 1956 Erstmals publiziert von E.H. Fried 1960 unter dem Namen Mathsort von W. Feurzeig.
Beispiele
Counting Sort Radix Sort Bucket Sort
E. Schikuta
E. Schikuta
367
368
Counting Sort Bedingung

Die zu sortierenden n Elemente sind Integer Werte im Bereich 0 bis k Falls k von der Ordnung n ist (k = O(n)) bentigt das Sortierverfahren O(n)
Counting Sort (2) Erweiterung

Die Elemente stammen aus dem Bereich [1..k] und es gibt keine doppelten Werte Frage: wie knnen wir den ersten Ansatz erweitern?
Allgemeiner Fall
Die Elemente sind aus dem Bereich [1..k], Doppelte sind erlaubt
Ansatz
Gegeben sei eine exakte Permutation 5 8 4 2 7 1 6 3
Idee des Counting Sort

Bestimme fr jedes Element x die Anzahl der Elemente kleiner als x im Vektor, verwende diese Information um das Element x auf seine Position im Ergebnisvektor zu platzieren
Jedes Element wird einfach auf die Position seines Wertes in einem Zielvektor gestellt
369
370
Counting Sort Algorithmus Eingangsvektor A, Ergebnisvektor B, Hilfsvektor C

for(i=1; i<=k; i++) C[i] = 0; for(j=1; j<=length(A); j++) 1: C[i] enthlt die Anzahl der Elemente gleich i, i = 1,2,...,k C[A[j]] = C[A[j]] + 1; for(i=2; i<=k; i++) 2: C[i] enthlt die Anzahl der Elemente kleiner oder gleich i C[i] = C[i] + C[i-1]; for (j=length(A); j>=1; j--) { 3: Jedes Element wird an seine B[C[A[j]]] = A[j]; korrekte Position platziert C[A[j]] = C[A[j]] 1; Falls alle Element A[j] unterschiedlich sind ist die korrekte Position in C[A[j]], } da Elemente gleich sein knnen wird
der Wert C[A[j]] um 1 verringert
Counting Sort Beispiel

1:
A 3 6 4 1 3 4 1 4 C 2 0 2 3 0 1
3:
2. D.
C 1 2 4 6 7 8
2:
C 2 2 4 7 7 8
3:
3. D.
4 4
C 1 2 4 5 7 8
3:
1. Durchlauf
B C 2 2 4 6 7 8
3:
Ende
B 1 1 3 3 4 4 4 6
E. Schikuta
371
372
Counting Sort Analyse

for(i=1; i<=k; i++) C[i] = 0; for(j=1; j<=length(A); j++) C[A[j]] = C[A[j]] + 1; for(i=2; i<=k; i++) C[i] = C[i] + C[i-1]; for (j=length(A); j>=1; j--) { B[C[A[j]]] = A[j]; C[A[j]] = C[A[j]] 1; }
5.5.2 Radix Sort Radixsort betrachtet die Struktur der Schlsselwerte

Die Schlsselwerte der Lnge b werden in einem Zahlensystem der Basis M dargestellt (M ist der Radix) z.B. M=2, die Schlssel werden binr dargestellt, b = 4
8 4 2 1
O(k) O(n) O(k) O(n)
Gewicht b=4 Stelle #
9=
1 0 0 1
3 2 1 0
Daraus folgt, dass der Gesamtaufwand O(n + k) ist In der Praxis haben wir sehr oft k = O(n), wodurch wir einen realen Aufwand von O(n) erreichen
Man beachte, dass kein Vergleich zwischen Werten stattgefunden hat, sondern die Werte der Elemente zur Platzierung verwendet wurden (vergl. Hashing)
Es werden Schlssel sortiert, indem ihre einzelnen Bits an derselben Bit Position miteinander verglichen werden
Das Prinzip lsst sich auch auf alphanumerische Strings erweitern
Counting Sort ist ein stabiles Sortierverfahren

Garantiert durch letzte Schleife, die von hinten nach vorne arbeitet
E. Schikuta
373
374
Radix Sort Algorithmus Allgemeiner Algorithmus

for(Index i luft ber alle b Stellen) { sortiere Schlsselwerte mit einem (stabilen) Sortierverfahren bezglich Stelle i }
Binrer Quicksort Sehr altes Verfahren 1929 erstmals fr maschinelles Sortieren von Lochkarten. 1954 H.H. Seward [MIT R-232 (1954), p25-28 ] eigenstndig und ausfhrlich: P.Hildebrandt , H. Isbitz, H. Rising, J. Schwartz [JACM 6 (1959), 156-163] 1 Jahr vor Quicksort
Richtung des Indexlaufs, Stabilitt

Von links nach rechts
d.h. for(int i=b-1; i>=0; i--) { ... }
Fhrt zum Binren Quicksort (Radix Exchange Sort) Von rechts nach links und stabiles Sortierverfahren
d.h. for(int i=0; i<b; i++) { ... }
Fhrt zum LSD-Radixsort (Straight Radix Sort)

375
376
Binrer Quicksort Idee Idee

Betrachte Stellen von links nach rechts 1. Sortiere Datenstze bezogen auf das betrachtete Bit 2. Teile die Datenstze in M unabhngige, der Gre nach geordnete, Gruppen und sortiere rekursiv die M Gruppen wobei die schon betrachteten Bits ignoriert werden
Binrer Quicksort Partition Aufteilung der Datenstze durch insitu Ansatz hnlich des Partitionierens beim Quicksort
do { scan top-down to find key starting with 1; scan bottom-up to find key starting with 0; exchange keys; } while (not all indices visited)
Beispiel
1 1 0 1 0
Beispiel
1.
0 0 1 1 1 01 2. 0 0 10 11 10 00 1. 0 1 10 10 11
E. Schikuta
...
Scan vom Anfang Scan vom Ende
1 1 0 1 0
0 1 0 1 1
0 0 1 1 1
E. Schikuta
377
378
Binrer Quicksort fr Dezimalzahlen Anzahl der Gruppen M ist 10 Zahlenwerte 0 bis 9

0 2 0 0 0 1 1 2 3 2 1 1 3 6 2 5 2 4 6 5 1 9 3 2 0 0 0 0 3 1 1 3 2 6 5 1 016 015 032 031 123 169 224 252
Binrer Quicksort Eigenschaften Binrer Quicksort verwendet im Durchschnitt ungefhr N log N Bitvergleiche
015 016 031 032 123 169 224 252

E. Schikuta
log N (Kodierung des Zahlenwerts) = konstanter Faktor N = Unsicherheit in der Zahlendarstellung
169 123 224 252
Gut geeignet fr kleine Zahlen Bentigt relativ weniger Speicher als andere Lineare Sortierverfahren Es ist ein Instabiles Sortierverfahren hnlich dem Quicksort nur fr positive ganze Zahlen
E. Schikuta
379
380
LSD-Radixsort Idee
Betrachte Bits von rechts nach links
LSD least significant digit Bei Binrem Quicksort von links nach rechts!
Was bedeutet stabil Bei einem stabilen Sortierverfahren wird die relative Reihenfolge von gleichen Schlsseln nicht verndert Beispiel
Erster Durchgang von letztem Beispiel Die relative Reihenfolge der Schlssel die mit 0 enden bleibt unverndert, dasselbe gilt fr die Schlssel, die mit 1 enden Mgliches Verfahren: Counting Sort
0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 1 0 0 1 1 1 1 0 0 0 0 1 1 1 0 1 0 1 0 0 1 0 0 1 1
Sortiere Datenstze stabil (!) bezogen auf das betrachtete Bit

Zu sortierende Bits pro Durchlauf 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 1 0 0 1 1 1 1 0 0 0 0 1 1 1 0 1 0 1 0 0 1 0 0 1 1 0 0 0 0 1 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1
E. Schikuta
0 0 0 0 1 1 1 1
Stabilitt garantiert Korrektheit des Algorithmus
E. Schikuta
381
382
LSD-Radixsort fr Dezimalzahlen Anzahl der Gruppen M ist 10 Ziffern 0 bis 9

0 2 0 0 0 1 1 2 3 2 1 1 3 6 2 5 2 4 6 5 1 9 3 2 0 0 2 1 2 0 0 1 3 3 5 2 2 1 1 6 1 2 2 3 4 5 6 9 0 0 1 2 0 0 2 1 1 1 2 2 3 3 5 6 5 6 3 4 1 2 2 9 0 0 0 0 1 1 2 2 1 1 3 3 2 6 2 5 5 6 1 2 3 9 4 2
Analyse von Radix Sort

Sortieren von n Zahlen, Schlssellnge b
for(Index i luft ber alle b Stellen) { sortiere n Schlsselwerte mit einem (stabilen) Sortierverfahren bezglich Stelle i }
Bei der Anwendung eines Sortierverfahrens mit der Laufzeit O(n) (wie z.B. Partitionierung bei Radix Exchange Sort, Counting Sort bei Straight Radix Sort) ist daher die Ordnung von Radix Sort O(bn)
Counting Sort ist kein insitu Verfahren, daher doppelter Speicherplatz notwendig, fhrt in der Praxis zum Einsatz von O(n log n) Verfahren
Wenn man b als Konstante betrachtet kommt man auf O(n)

Bei Zahlenbereich von m Werten Darstellung am Computer mit b = log(m) Stellen, da aber Wertebereich am Computer begrenzt, Ansatz b konstant akzeptierbar
383
384
5.5.3 Bucket Sort Annahme ber die n Eingabe Elemente, dass sie gleichmig ber das Intervall [0,1) verteilt sind Idee
Teile das Intervall [0,1) in n gleichgroe Teil-Intervalle (Buckets) und verteile die n Eingabe Elemente auf die Buckets
Da die Elemente gleichmig verteilt sind, fallen nur wenige Elemente in das gleiche Bucket
Bucket Sort Beispiel

Eingabe Vektor A der Gre 10 Bucket Vektor B verwaltet Elemente ber lineare Listen Bucket B[i] enhlt die Werte des Intervalls [i/10, (i+1)/10) .78 .17 .39 .26 .72 .94 .21 .12 .23 .68
0 1 2 3 4 5 6 7 8 9
.12 .21 .39
.17 .23
.26
Sortiere die Elemente pro Bucket mit Selection Sort Besuche die Buckets entlang des Intervalls und gib die sortierten Elemente aus
.68 .72 .94
.78
E. Schikuta
E. Schikuta
385
386
Bucket Sort Algorithmus n = length(A); for(i=1; i<=n; i++) insert A[i] into list B[n*A[i]]; for(i=0; i<n; i++) sort list B[i] with insertion sort; Concatenate the lists B[0], B[1], ..., B[n-1] together in order
Analyse Bucket Sort

Alle Anweisungen auer Sortieren sind von der Ordnung O(n) Analyse des Sortierens
ni bezeichnet die Zufallszahl der Elemente pro Bucket Selection Sort luft in O(n2) Zeit, d.h. die erwartete Zeit zum Sortieren eines Buckets ist E[O(n2)] = O(E[n2]), da alle Buckets zu sortieren ist
O( E[ni2 ]) = O( E[ni2 ]) O(1)

i =0 i =0
n 1
n 1
Um den Ausdruck zu berechnen Verteilung der Zufallsvariable ni bestimmen Es gibt n Elemente mit n Buckets, d.h. die Wahrscheinlichkeit eines Elements in eine Bucket zu fallen ist p = 1/n ni folgt der Binomial-Verteilung Da E[ni2] = Var[ni] + E2[ni] = 1 1/n + 12 = 2 1/n = (1)
E[ni] = n*p = 1 und Var [ni] = n*p*(1-p) = 1 1/n
Daraus folgt, dass der Aufwand fr Bucket Sort O(n) ist

387
388
5.6 Externes Sortieren Externes Sortieren bezeichnet alle Sortierverfahren, die nicht ausschlielich im Hauptspeicher ablaufen
Diese Verfahren bentigen sekundre (Platten) oder tertire (Bnder) Speichermedien blicherweise versteht man darunter Verfahren, die Bndern einsetzen
Eigenschaften von Bndern Bndern entsprechen allgemein Sequenzen Die Datenelemente sind hintereinander angeordnet und man kann auf sie nur sequentiell lesend und schreibend zugreifen
Verwaltung elementweise oder blockweise (ein Block umfasst mehrere gemeinsam verwaltete Elemente) Es ist nicht mglich auf ein beliebiges Element ohne Aufwand O(n) zuzugreifen Bnder knnen blicherweise von beiden Seite gelesen und geschrieben werden bzw. von einem Ende zum anderen gespult werden
Grund fr externe Verfahren sind zu sortierende Datenmengen, die nicht mehr vollstndig in den Hauptspeicher passen
In der Praxis hufig anzutreffen
Ziel ist die Anzahl der Transfers zwischen Hauptspeicher und Externspeicher zu minimieren
E. Schikuta
389
390
Strategie fr externes Sortieren Klassisches Sortieren durch Mischen

Seit den 50er Jahren im Einsatz
Merging Ansatz analog zu Mergesort im Hauptspeicher

Statt Hauptspeicherfeld eben Band
Soviel Daten wie mglich in den Hauptspeicher laden Diese Daten im Hauptspeicher sortieren Sortierte Daten (Run) auf externes Speichermedium schreiben
Ein Run ist eine geordnete Teil-Sequenz der urspr. Datenelemente
Merging zweier Sequenzen

5
simpler Fall
1, 5
Runs ber den Hauptspeicher zu greren Runs zusammenmischen (Merging)

1, 4, 5, 7, 9, 11, 12, 14
allgemeiner Fall
2, 3, 6, 8, 10, 13, 15
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

391
392
5.6.1 Balanced Multiway Merging Idee

Anfnglicher Verteilungsdurchgang Mehrere Mehrweg Mischdurchgnge
Algorithmus Bilden initaler Runs durch Sortieren der Daten im Hauptspeicher und gleichmiges Verteilen auf P Output Bnder Alternieren der Bnder
d.h. Input wird Output und vice cersa
Annahme
N zu sortierende Datenstze auf externem Gert Platz fr M Datenstze im Hauptspeicher 2 P externe Gerte (Bnder) zur Verfgung
P Inputbnder P Outputbnder
Solange
Merging der Runs von den Input auf die Output Bnder und alternieren der Bnder
Input auf Band 0, anderen Bnder 1, 2, , 2P 1 Ziel: sortiertes Ergebnis auf Band 0
bis EIN sortierter Run entsteht
E. Schikuta
393
394
Balanced Multiway Merging Beispiel Dreiweg Mischen, P = 3

Band 0 Band 3 Band 4 Band 5 Band 0 Band 1 Band 2 Band 3 A S O R T I N G A N DM E RG I NG E X AM P L E * A O S * DMN * A E X * I R T * E G R * L MP * AGN * G I N * E * A A G I NO R S T * D E GG I MN N R * A E E L MP X *
Balanced Multiway Merging Analyse Durch Hardwareparameter (langsames Band) Anzahl der Banddurchlufe interessant N ... Anzahl der Elemente M ... Gre des Hauptspeichers Jeder Sortier-Durchlauf erzeugt N/M sortierte Runs Daher bei p-Weg Merging braucht man ungefhr logP(N/M) Durchlufe
Jeder Durchlauf verringert die Anzahl der Durchlufe um Faktor P Beispiel: Zu sortierende Datei 200 GB, Hauptspeicher 1 GB, Sortieren bentigt 5 Durchlufe
Im Beispiel muss noch einmal Band 3 auf Band 0 (Ziel) kopiert werden
A A A D E E E GGG I I L MMN N NO P R R S T X *
E. Schikuta
395
396
Organisation im Hauptspeicher Organisation der Elemente im Hauptspeicher ber Priority Queue (z.B. Heap) Kleinstes Element (nchstes zu Mergen) ist direkt zugreifbar Einfgen eines neuen Elementes vom Band von der Ordnung O(log M)
M beschreibt die Gre des zur Verfgung stehenden Hauptspeichers
5.6.2 Replacement Selection Elemente im Hauptspeicher werden ber eine Priority Queue der Gre p verwaltet (sortiert)
PQ wird mit den kleinsten Elementen der p Runs gefllt Das kleinste Element der PQ wird auf das Output Band geschrieben und das nchste Element nachgeschoben Die PQ Eigenschaft wird mit einer heapify Funktion erhalten
Beispiel
A O S I R T A G N
Im Hauptspeicher sind nur die kleinsten Elemente der Runs, (dargestellt werden aber die ganzen Runs (zur Erklrung)) Realisierung ber Pointer auf die echten Runs = indirekter Heap
Erlaubt auch das Erzeugen von sortierten Runs die viel grer sind als der Hauptspeicher
E. Schikuta
E. Schikuta
397
398
Erzeugung von initialen Runs

Idee ist den ungeordneten Input durch eine groe PQ durchzuschleusen Das kleinste Element rausschreiben und das nchste Element in die PQ aufzunehmen
(falls notwendig) die PQ Bedingung wiederherstellen (heapify)
Erzeugung von initialen Runs Beispiel ASORTINGEXAMPLE

A R S S E E P M T A G P L M T R G E T X E G P L M O Heap der Gre 5 I N R O R O S T S T S G E X A E G T G E A M Erzeugt 2 Runs: O R S T X G G
Spezielle Situation falls ein Element kleiner als das letzte geschrieben ist
Kann nicht mehr Teil des Runs werden, wird markiert und als grer als alle Elemente des aktuellen Runs behandelt
Dieses Element beginnt einen neuen Run Es lsst sich zeigen, dass Runs, die mit Replacement Selection erzeugt wurden ungefhr 2 Mal so gro wie die PQ sind
AINORSTX AEEGLMP
E. Schikuta
399
400
5.6.3 Polyphase Merging Nachteil des Balanced Multiway Merging ist die relativ groe Anzahl von bentigten Bndern
Ansatz mit P Bndern und 1 Output Band bentigt zwar weniger Bnder aber exzessives Kopieren
Output Band muss wieder auf P Bnder aufgeteilt werden Band 0 Band 1 Band 2 Band 0 Band 1 Band 2 Band 0 Band 1 Band 2 A E GOR S T X D EMR GI N AOR S T EGX I N
Polyphase Merging Beispiel

AGN EL D EMR GIN Initiale Runs durch Replacement Selection erzeugt
AMP
Idee des Polyphase Merging

Verteile die mit Replacement Selection erzeugten initialen Runs ungleichmig ber die Bnder (ein Band bleibt leer) Fhre ein Merging-until-empty durch
Merging bis ein Band leer ist, welches das neue Output Band wird
A I MN P
AEG L N
A D E E GMO R R S T X A EG L N
A G I I MN N P
E. Schikuta
E. Schikuta
401
402
Eigenschaften Diese Merge-until-empty Strategie kann auf beliebige Bandzahlen (> 2) angewendet werden Analyse ist kompliziert
Unterschied zwischen Balanced Multiway Sorting und Polyphase Merging eher gering Polyphase Merging nur fr geringe Bandzahlen (p < 9) besser als BMS
Dient eher zum Verringern der Bandzahlen
Was nehmen wir mit? Dictionary Hashing

Statische und dynamische Verfahren
Sortieren
Klassische Verfahren O(n2) und O(n log n) Lineare Verfahren O(n) Externes Sortieren
E. Schikuta
E. Schikuta
403
404
Graphen Graphen sind eine dominierende Datenstruktur in der Informatik

Kapitel 6:
Viele Probleme der Informatik lassen sich durch Graphen beschreiben und ber Graphenalgorithmen lsen Ungerichteter Graph
Graphen
Gerichteter Graph
E. Schikuta
E. Schikuta
405
406
Graphen-Beispiele
Ortsverbindungen
z.B. Zge
Wien Graz
6.1 Ungerichteter Graph Ein ungerichteter Graph G(V, E) besteht aus einer Menge V (vertex) von Knoten und einer Menge E (edge) von Kanten, d.h.
V = {v1, v2, , v|V|} E = {e1, e2, e|E|}
Linz Salzburg
Klagenfurt
Ablaufbeschreibungen
z.B. Projektplanung Maschinenhalle
Kanten rep. Abhngigkeiten
Fundamente Zufahrt Auenanlage Lieferung Maschinen Montage Maschinen
Eine Kante e ist eine ungeordnetes Paar von Knoten aus V, d.h. e = [vi, vj] mit vi,vj V
v1 Rohbau Dach Innenausbau G(V, E) V = {v1, v2, v3} E = {e1, e2, e3} e1 = [v1, v2] v2
e2 = [v1, v3] v3
e3 = [v2, v3]
E. Schikuta
407
408
Kantenfolge, -zug, Weg

Eine Kantenfolge von v1 nach vn in einem Graphen G ist eine endliche Folge von Kanten [v1,v2], [v2,v3], , [vn-1,vn], wobei je 2 aufeinanderfolgende Kanten einen gemeinsamen Endpunkt haben
KF1 = [v1,v2], [v2,v3] v1 v2 oder KF 2 = [v1,v2], [v2,v3], [v3,v1], [v1,v2] v1 v3 v2
Kreis Ein Kreis ist ein Kantenzug, bei dem die Knoten v 1, v2, , vn-1 alle verschieden sind und v n = v1 gilt
v1 v3 v2 v4
Kreise: v2, v3, v5, v7, v2 v3, v4, v5, v3 v2, v3, v4, v5, v7, v2
v6
v3
v5
Eine Kantenzug ist eine Kantenfolge, in der alle Kanten verschieden sind, (im Beispiel ist KF1 ein Kantenzug, KF2 nicht.) Ein Weg oder Pfad ist eine Kantenfolge in der alle Knoten verschieden sind (ein einzelner Knoten gilt auch als Weg)
v7
Ein Graph heit verbunden oder zusammenhngend, wenn fr alle mglichen Knotenpaare vj,vk ein Pfad existiert, der vj mit vk verbindet Ein Baum ist daher ein verbundener kreisloser (azyklischer) Graph
409
410
Teilgraph Ein Graph G(V, E) heit Teilgraph von G(V, E), wenn V V und E E
G(V, E) V = {v1, v3} E = {e2} v1
Komponente Alle Knoten, die durch einen Weg verbunden werden knnen, heien Komponente eines Graphen
e2 = [v1, v3] v3 v1 v2 v4 v6 v3
Ein Teilgraph G(V,E) ist spannender Teilgraph von G(V,E), wenn V = V und G einen Baum bildet
G(V, E) V = {v1, v2, v3} E = {e1, e2} v1 e1 = [v1, v2] v2
e2 = [v1, v3] v3
Komponenten: v1, v2, v5, v6 v3, v4, v7 v8

v7 v5 v8
E. Schikuta
411
412
6.2 Gerichteter Graph Ein gerichteter Graph G(V, E) besteht aus einer Menge V von Knoten und einer Menge E von Kanten, wobei die Kanten geordnete Paare <vi,vj> von Knoten aus V sind
v1 e2 = <v2, v1> v2 e5 = <v4, v5> e4 = <v1, v3> e3 = <v2, v3> v3 v5 e1 = <v4, v1> e6 = <v1, v4> v4 G(V, E) V = {v1, v2, v3, v4, v5} E = {e1, e2, e3, e4, e5, e6}
6.3 Speicherung von Graphen Wir unterscheiden 2 Methoden zur Speicherung von Graphen
Adjazenzmatrix-Darstellung Adjazenzlisten-Darstellung
Ein Knoten v heit adjazent zu einem Knoten w, wenn eine Kante von v nach w fhrt, z.B.
ungerichtete Kante: v adjazent zu w w adjazent zu v
v w
gerichtetet Kante: v adjazent zu w w aber NICHT adjazent zu v

v w
Zwischen v1 und v4 existieren 2 Kanten, eine Hin- und Rckkante (auch Doppelkante).
E. Schikuta
413
414
6.3.1 Adjazenzmatrix Bei der Adjazenzmatrix-Darstellung reprsentieren die Knoten Indexwerte einer 2-dimensionalen Matrix A
Wenn der Knoten v adjazent zum Knoten w ist, wird das Feld A[v,w] in der Matrix gesetzt (z.B. 1, true, Wert, etc.)
v w
Adjazenzmatrix-Beispiele Ungerichteter Graph

v1 v2
... ... v ... w ... ...

w
v ... w ... 1 1 v ... w ... 1

Bei ungerichteten Graphen ist die Matrix symmetrisch
v1 v1 v2 1 v3 1
v2 1 1
v3 1 1
v3
Gerichteter Graph
v1 v2 v4
... v ... w ...
v5 Feld bleibt leer, da w nicht adjazent zu v v3

v1 v1 v2 1 v3 v4 1 v5 v6
v2
v3 1 1
v4 v5 1
v6
1 1
v6
E. Schikuta
415
416
Eigenschaften + gut fr kleine Graphen oder Graphen mit vielen Kanten + berprfung von Adjazenzeigenschaft O(1) + manche Algorithmen einfacher - dfs schlecht, Rechenaufwand O(|V|2) - quadratischer Speicheraufwand O(|V| 2)
6.3.2 Adjazenzliste Bei der Adjazenzlistendarstellung werden fr jeden Knoten alle adjazenten Knoten in einer linearen Liste gespeichert
Somit werden nur die auftretenden Kanten vermerkt
v w w v w v
v w
v w
E. Schikuta
E. Schikuta
417
418
Adjazenzliste-Beispiele
Ungerichteter Graph
v1 v2 v1 v2 v3 v3 v3 V1 v1 v2 v3 v2
Code, Eigenschaften
C-Code
struct node { int v; struct node *next; }; struct node *adjliste[maxV];
Gerichteter Graph
v1 v4 v2 v1 v2 v3 v4 v5 v3 v6 v5 v6 v4 v3 v1 v6 v3 v1 v5
Eigenschaften:
+ gut fr Graphen mit wenigen Kanten + linearer Speicheraufwand O(n) + dfs gut, Rechenaufwand O(|V|+|E|) - berprfung Adjazenzeigenschaft O(|V|) - manche Algorithmen komplexer
E. Schikuta
E. Schikuta
419
420
6.4 Topologisches Sortieren Problem: Ausgehend von einer binren Beziehung (z.B. mu erledigt sein, bevor man weitermachen kann mit) von Elementen ist zu klren, ob es eine Reihenfolge der Elemente gibt, ohne eine der Beziehungen zu verletzen. Beispiel:
Professor Bumstead kleidet sich an Kleidungsstcke sind: Unterhose, Socken, Schuhe, Hosen, Grtel, Hemd, Krawatte, Sakko, Uhr Beziehung: Kleidungsstck A muss vor B angezogen werden Problem: Finde eine Ankleidereihenfolge damit sich Prof. Bumstead anziehen kann.
Interpretation durch gerichteten Graphen Binre Beziehung zwischen Elementen ist gerichtete Kante zwischen entsprechenden Knoten
Prof. Bumstead
Unterhose Hose Hemd Grtel Krawatte Sakko
Socken Uhr Schuhe
421
422
Topologische Ordnung eines DAG Eine Topologische Ordnung eines gerichteten azyklischen Graphs G (directed acyclic graph, DAG) ist eine lineare Anordnung aller Knoten, sodass wenn G eine Kante <u, v> enthlt, u vor v in der Anordnung steht
Falls der Graph nicht azyklisch ist, gibt es keine topologische Ordnung Lsung Professor Bumstead
Socken Unterhose Hose Schuhe Uhr Hemd Grtel Krawatte Sakko
Eine mgliche Vorgangsweise 1. Suche einen Knoten aus dem nur Kanten hinausfhren 2. Ordne ihn in der topologischen Ordnung an 3. Lsche ihn aus dem Graphen 4. Weiter bei 1.
E. Schikuta
E. Schikuta
423
424
Knotengrad Eingangs- und Ausgangsgrad eines Knoten indegree(v) mit v aus V: | { v' | <v', v> aus E} |
d.h. Anzahl der in v einmndenden Kanten
induzierter Teilgraph Ein Graph G(V, E) heit induzierter Teilgraph (Untergraph) von G(V, E), wenn V V und E=E{VxV}.
V={v1, v2, v3, v4, v5, v6}
v1 v2 v4 v2 v5 v3 v6 v3 v6 v5
outdegree(v) mit v aus V:
| { v' | <v, v'> aus E} |

V = V \ {v1} = {v2, v3, v4, v5, v6}
v4
d.h. Anzahl der von v ausgehenden Kanten
Hose
Hemd
indegree: 1, outdegree: 2
indegree: 0, outdegree: 2
E. Schikuta
E. Schikuta
425
426
Algorithmus zum toplogischen Sortieren

lfdNr = 0; while ( v G: indegree(v) = 0) { lfdNr = lfdNr + 1; N[v] = lfdNr; G = induzierter Teilgraph von V\{v}; } if (V = {}) G ist azyklisch; // N enthlt die topologische Ordnung fr G else G ist nicht azyklisch; // es existiert keine top. Ordnung
6.5 Traversieren eines Graphen

Unter dem Traversieren eines Graphen versteht man das systematische und vollstndige Besuchen aller Knoten des Graphen Es lassen sich prinzipiell 2 Anstze unterscheiden:
Tiefensuche, dfs depth-first search - Traversierung Breitensuche, bfs breadth-first search - Traversierung
ber diese beiden Anstzen lassen sich fast alle wichtigen Problemstellungen auf Graphen lsen, z.B.
Suche einen Weg vom Knoten v nach w? Besitzt der Graph einen Zyklus? Finde alle Komponenten? ...
E. Schikuta
E. Schikuta
427
428
Das Knigsberger Brcken Problem Leonhard Euler, 1736

Die Stadt Knigsberg (Kaliningrad) liegt an den Ufern und auf 2 Inseln des Flusses Prigel und ist durch 7 Brcken verbunden
A
Abstraktion
Frage: Gibt es einen Kreis im Graphen der alle Kanten genau einmal enthlt? A
Frage: Gibt es einen Weg auf dem ich die Stadt besuchen kann, alle Brcken genau einmal berquere und an den Anfangspunkt zurckkehre?
Euler lste das Problem, indem er bewies, dass so ein Kreis genau dann mglich ist, wenn der Graph zusammenhngend und der Knotengrad aller Knoten gerade ist Eulersche Graphen
Solche Graphen werden Eulersche Graphen genannt.
Fr Kaliningrad gilt dies offensichtlich nicht.

werden als das erste gelste Problem der Graphentheorie angesehen
E. Schikuta
429
430
Beweisskizze
Satz: Damit so ein Kreis existieren kann, mssen alle Knoten geraden Knotengrad haben
Knoten muss einmal betreten und einmal verlassen werden
Beweisskizze (2)
Graph erfllt Bedingung, d.h. Kreis muss existieren
Laut Beweis entferne einen Kreis nach dem anderen, bis alle Kanten entfernt sind, Kombination der Kreise liefert Lsung A C C B B Aus der Regel fr die Kombination der Kreise lsst sich ein entsprechender Algorithmus zum Finden eines Eulerschen Kreises ableiten fhrt zur Problemstellung des Traversieren eines Graphen
Bedingung suffizient? Existiert immer ein Kreis?

Beweis durch Induktion
Hypothese: verbundener Graph G mit < m Kanten, wobei alle Knoten geraden Knotengrad besitzen, enthlt einen Kreis, dessen Kanten genau einmal besucht werden Ansatz: Entferne einen Kreis P (gerader Knotengrad, gerade Anzahl von Kanten) aus dem Graph, es bleibt ein Graph G mit geraden Knotengrad zurck (weiteren Kreis entfernen usw.) Problem: Graph knnte durch das Entfernen eines Kreises in Komponenten G 1, G2, ... Gk zerfallen, jede Komponente erfllt aber wieder Bedingung gerader Knotengrad, d.h. Hypothese auf Komponenten ebenfalls anwendbar, ergibt k Kreise P1, P2, ... Pk Kombination dieser Kreise zu Gesamtkreis, indem man bei beliebigem Knoten im Kreis P beginnt und Kreis solange bis zu einem Knoten v j, verfolgt, der zu Komponente G j gehrt. Von dort Verfolgung von entsprechenden Kreis P j
A A C C B D B A D
1 5
A
4 7
C
6
D
3
431
432
6.5.1 Depth-first Search Idee

Wir interpretieren den Graphen als Labyrinth, wobei die Kanten Wege und die Knoten Kreuzungen darstellen. Beim depth-first search Ansatz versuchen wir einen mglichst langen neuen Pfad zurckzulegen. Wenn wir keinen neuen Weg mehr finden, gehen wir zurck und versuchen den nchsten Pfad. Wenn wir zu einer Kreuzung kommen, markieren wir sie (im Labyrinth durch einen Stein). Wir merken uns mgliche Pfadalternativen. Kommen wir zu einer markierten Kreuzung ber einen noch nicht beschrittenen Weg, gehen wir diesen Weg wieder zurck (wir waren schon mal da).
Ansatz
Algorithmus
rekursiver Ansatz, zu besuchende Knoten werden am Stack (Rekursion) vermerkt. Zuerst in die Tiefe , danach in die Breite gehen
void besuche-dfs ( Knoten x ) { markiere Knoten x mit besucht; for ( alle zu x adjazente nicht besuchte Knoten v ) besuche-dfs ( v ); Rekursiver Ansatz }
Markierung: Ein Feld mit den Knotenbezeichnungen als Index, initialisiert mit unbesucht (keine Steine).
Analogie
Buch lesen, Detailinformation suchen, Sukkzessiver Lernansatz, Entscheidungsbaum, Auswahlkriterien, etc.
433
434
Beispiel, dfs
v1 v4 Markierung Adjazenzliste v2 v4 v3 v5 v1 v2 v3 v4 v6 v5 v6 v5 v6 v5 v1 v4 v1 v3 v2 v1 v1 v3 v2 v1 u v2 u v3 u v4 u v5 u v6 u
Methode dfs
dfs-Traversierung eines Graphen
Ausgehend vom Knoten v1 wird der Graph mit dem dfs-Ansatz traversiert. Besuchte Knoten werden auf einem Stack (Rekursion) vermerkt.
1.
v1 v4
2.
6.
v2
5.
v3
3.
v5
Verhalten des Stacks

Schritt v1 1. v1
v4 v3 v2
Reihenfolge der Knoten eigentlich beliebig, abh. von der physischen Speicherung des Graphen 2. v4 v3 v2 Push v4 v5 3. v5 v3 v2 Pop v5 v6 4. v6 v3 v2 v6
4.
v6 5. v3 v2 v3 6. v2
v2
E. Schikuta
E. Schikuta
435
436
Beispiel, dfs (2)

v1 besuche-dfs(1) besuche-dfs(4) check 1 besucht besuche-dfs(5) check 4 besucht besuche-dfs(6) check 5 besucht besuche-dfs(3) besuche-dfs(2) check 1, 3 besucht check 1 besucht check 2 besucht b b b b b b v2 u u u u u b v3 u u u u b b v4 u b b b b b v5 u u b b b b v6 u u u b b b
C++ - Code
#define besucht 1 #define unbesucht 0 // maxV defined elsewhere class node { public: int v; node *next;} node *adjliste[maxV]; // Adjazenzliste int mark[maxV]; // Knotenmarkierung void traversiere() { int k; for(k = 0; k <= maxV; ++k) mark[k] = unbesucht; for(k = 0; k <= maxV; ++k) if(mark[k]==unbesucht) besuche-dfs(k); } void besuche-dfs(int k) { node *t; mark[k] = besucht; for(t = adjliste[k]; t != NULL; t = t->next) if(mark[t->v] == unbesucht) dfs(t->v); }
E. Schikuta
E. Schikuta
437
438
6.5.2 Breadth-first Search Idee

Man leert einen Topf mit Tinte auf den Startknoten. Die Tinte ergiet sich in alle Richtungen (ber alle Kanten) auf einmal Beim breadth-first search Ansatz werden alle mglichen Alternativen auf einmal erforscht, ber die gesamte Breite der Mglichkeiten Dies bedeutet, dass zuerst alle mglichen, von einem Knoten weggehenden, Kanten untersucht werden, und danach erst zum nchsten Knoten weitergegangen wird Iterativer Ansatz
Algorithmus
zu besuchende Knoten werden in einer Queue gemerkt
Zuerst in die Breite , danach in die Tiefe gehen
Analogie
berblick ber Buch verschaffen, Generelle Information suchen, Hierarchischer Lernansatz, Auswahlberblick, etc.
void besuche-bfs(Knoten x) { stelle (Enqueue) Knoten x in Queue; markiere Knoten x besucht; while(Queue nicht leer) { hole (Dequeue) ersten Knoten y von der Queue; for(alle zu y adjazente nicht besuchte Knoten v) { stelle (Enqueue) v in die Queue; markiere Knoten v besucht; } // for Iterativer } // while Ansatz }
Achtung: Da kein Stack automatisch zur Verfgung steht, muss eine geeignete Datenstruktur zum Merken der zu besuchenden Knoten vorgesehen werden: Queue
439
440
Beispiel, bfs
v1 v4 Markierung Adjazenzliste v2 v4 v3 v5 v1 v2 v3 v4 v6 v5 v6 v5 v6 v5 v1 v4 v1 v1 v3 v2 v1 v1 Schritt 1. v1 v2 v3 v4 2. v5 v2 v3 v4 v4 Enqueue
Methode bfs
bfs-Traversierung eines Graphen
Ausgehend vom Knoten v1 wird der Graph mit dem bfs-Ansatz traversiert Besuchte Knoten werden in einer Queue vermerkt
1. 4.
v1 u
v2 u
v3 u
v4 u
v5 u
v6 u
v1 v4
2.
v2
3.
v3
5.
v5
v3
v2
Verhalten der Queue

6.
3. v5 v2 v3 v3
4.
v6 5. v6
6.
v5 v2 v2 Dequeue
v5 v5
v6 v6
E. Schikuta
441
442
Beispiel, bfs (2)
C++ - Code
#define besucht 1 #define unbesucht 0 // maxV defined elsewhere ,mark initialized unbesucht class node { public: int v; node *next;} node *adjliste[maxV]; // Adjazenzliste int mark[maxV]; // Knotenmarkierung Queue queue(maxV); void besuche-bfs(int k) { node *t; queue.Enqueue(k); mark[k]= besucht; while(!queue.IsQueueEmpty()) { k = queue.Dequeue(); for(t = adjliste[k]; t != NULL; t = t->next) if(mark[t->v] == unbesucht) { queue.Enqueue(t->v); mark[t->v] = besucht; } } } }
besuche-bfs(1) Enqueue(1), Dequeue(1) Enqueue(4,3,2) Dequeue(4) Enqueue(5) check 1 besucht Dequeue(3) check 2,1 besucht Dequeue(2) check 3,1 besucht Dequeue(5) Enqueue(6) check 4 besucht Dequeue(6) check 5 besucht
v1 b b b b b b
v2 u u u b b b
v3 u u b b b b
v4 u b b b b b
v5 u u u u b b
v6 u u u u u b
E. Schikuta
E. Schikuta
443
444
Aufwand von dfs und bfs Aufwandsabschtzung abhngig von der Speicherungsform des Graphen
Bestimmend Aufwand fr das Finden der adjazenten Knoten
Schichtenkonzept zur Problemlsung

Anwendungsebene:
Beispiele - gnstigste Weg von a nach b - gute Zge in einem Spiel
Adjazenzliste
dfs und bfs: O (|V| + |E|) Jeder Knoten wird einmal besucht, Adjazenzlisten werden iterativ abgearbeitet
Bei vollstndig verbundenen Graphen O ( |V2| ), da jeder Knoten |V|-1 Kanten besitzt, d.h. |E| |V2|
Werkzeugebene:
Beispiele - Graphdurchquerung von v1 nach v2 - Topologische Anordnung
Adjazenzmatrix
dfs und bfs: O ( |V|2 ) Aufwand zum Finden der adj. Nachfolger eines Knoten O( |V| )
Implementationsebene:
Beispiele - Rekursive Traversierung - Iterative Traversierung
E. Schikuta
445
446
Lsungsskizzen Beispiele
Weg von Knoten x nach y finden
Von x ausgehend Graph traversieren bis man zu y kommt (d.h. y markiert wird).
6.5.3 Das Bauer, Wolf, Ziege und KohlkopfProblem Klassisches Problem

Ein Bauer mchte mit einem Wolf, einer Ziege und einem Kohlkopf einen Fluss berqueren. Es steht ihm hierzu ein kleines Boot zur Verfgung, in dem aber nur 2 Platz haben. Weiters stellt sich das Problem, dass nur der Bauer rudern kann, und der Wolf mit der Ziege und die Ziege mit dem Kohlkopf nicht allein gelassen werden kann, da sonst der eine den anderen frisst. Es soll eine Transportfolge gefunden werden, dass alle ungefressen das andere Ufer erreichen.
Beliebigen Kreis im ungerichteten Graph finden

Von jedem Knoten Traversierung des Graphen starten. Kreis ist gefunden, falls man zu einem markierten Knoten kommt (man war schon einmal da).
Beliebigen Kreis im gerichteten Graph finden

Von jedem Knoten Traversierung des Graphen starten. Kreis ist gefunden, falls man zu einem markierten Knoten kommt. Wichtig: Gesetzte Markierungen mssen beim Zurcksteigen wieder gelscht werden.
E. Schikuta
447
448
Kodierung des Problems (1)

Das Problem wird durch einen Graphen dargestellt, wobei die Knoten die Positionen der zu Transportierenden und die Kanten die Bootsfahrten reprsentieren.
Eine Position (Knoten) definiert, wer auf welcher Seite des Flusses ist,
linkes Ufer Wolf Kohlkopf rechtes Ufer Bauer Ziege Bootsfahrt Wolf Kohlkopf R Fluss
Kodierung des Problems (2)

Eine Bootsfahrt (Kante) gibt an, wer im Boot bersetzt, d.h. fhrt eine Position in die nchste ber, d.h
linkes Ufer Position 1 L L R Wolf Kohlkopf Fluss rechtes Ufer Bauer Ziege
Dieses ist eine sichere Position, da niemand gefressen wird.

Eine Position kann in einem 4 elementigen Vektor kodiert werden, wobei jedem der 4 zu Transportierenden ein Vektorelement zugeordnet ist und L das linke Ufer bzw. R das rechte bezeichnet, d.h. der obigen Position entspricht der folgende Vektor
Bauer R
Bauer
Ziege
linkes Ufer Position 2 L L L R Bauer Wolf Kohlkopf Fluss
rechtes Ufer Ziege
Wolf L
Kohlkopf L
Ziege R
E. Schikuta
E. Schikuta
449
450
Problemreprsentation
Der gesamte Problembereich lsst sich somit durch einen Graphen darstellen, wobei die Positionen durch die Knoten und die Bootsfahrten durch die Kanten reprsentiert werden, z.B. (Ausschnitt)
L L L L R L L R R R R L R L R R L R L L L R R L L L L R R L L R R R L R R L L R R L R
Lsung Lsungsweg
L L L L Startposition Kodierung: (Bauer, Wolf, Kohlkopf, Ziege)
Die Lsung wird somit durch einen Weg bestimmt, der von der Anfangsposition (alle 4 auf dem linken Ufer = LLLL ) zu der Endposition (alle 4 auf dem rechten Ufer = RRRR ) fhrt. Dies lsst sich durch eine simple Traversierung des Graphen lsen.
Endposition R L R R L
E. Schikuta
451
452
C-Programm
Wir whlen einen bfs-Ansatz (iterativ, mit Hilfe einer Queue)
Die Position wird in einer integer Variable binr (stellenwertig) kodiert
Bauer 3. Bit, Wolf 2. Bit, Kohlkopf 1. Bit, Ziege 0.Bit, wobei 0 linkes Ufer und 1 rechtes Ufer bedeutet int int int int
Hilfsfunktionen
Bauer(int Ort) {return 0 != (Ort & 0x08);} Wolf(int Ort) {return 0 != (Ort & 0x04);} Ziege(int Ort) {return 0 != (Ort & 0x02);} Kohl(int Ort) {return 0 != (Ort & 0x01);}
Die Funktionen Bauer, Wolf, Kohl und Ziege liefern die aktuelle Position zurck. Die Funktion sicher bestimmt, ob eine Position sinnvoll ist, d.h. niemand wird gefressen. DruckeOrt dient zur verstndlichen Ausgabe der Positionen. In der Queue Zug werden die zu besuchenden Knoten vermerkt. Der beschrittene Weg (Traversierung) wird im Feld Weg gespeichert (max. 16 Positionen).
C-Spezialitten 0x08 ^ << Hexadezimaldarstellung einer Zahl bitweise exklusives Oder, XOR Linksshift Operator
int sicher(int Ort) { if((Ziege(Ort) == Kohl(Ort)) && (Ziege(Ort) != Bauer(Ort))) return 0; if((Wolf(Ort) == Ziege(Ort)) && (Wolf(Ort) != Bauer(Ort))) return 0; return 1; } void DruckeOrt(int Ort) { cout << ((Ort & 0x08) ? cout << ((Ort & 0x04) ? cout << ((Ort & 0x02) ? cout << ((Ort & 0x01) ? cout << endl; } "R "R "R "R " " " " : : : : "L "L "L "L "); "); "); ");
E. Schikuta
E. Schikuta
453
454
Traversierung
void main() { Queue<int> Zug; int Weg[16]; for(int i = 0; i < 16; i++) Weg[i] = -1; Zug.Enqueue(0x00); while(!Zug.IsEmpty()) { int Ort = Zug.Dequeue(); for (int Pers = 1; Pers <= 8; Pers <<= 1) { int nOrt = Ort ^ (0x08 | Pers); if(sicher(nOrt) && (Weg[nOrt] == -1)) {
6.6 Minimaler Spannender Baum

Den Kanten des Graphen G(V, E) ist ein Wert zugeordnet (Netzwerk). Ein Minimaler Spannender Baum MSB ist ist ein spannender Teilgraph, dessen Summe der Kantenwerte minimal ist.
Fr jede Kante [u, v] E existiert ein Gewicht w(u, v), welches die Kosten der Verbindung angibt Ziel: Finde eine azyklische Teilmenge T E, die alle Knoten verbindet und fr die gilt, w(T) = (u,v) T w(u, v) ist ein Minimum
Wie wird aus diesem bfs Ansatz ein dfs Ansatz?
Weg[nOrt] = Ort; Zug.Enqueue(nOrt);

} } } cout << "Weg:\n"; for(int Ort = 15; Ort > 0; Ort = Weg[Ort]) DruckeOrt(Ort); cout << '\n'; }
Beispiel:
Verdrahtungsproblem in einem elektronischen Schaltplan Alle Pins mssen untereinander verdrahtet werden, wobei die Drahtlnge minimal sein soll
d.h. V ist die Menge der Pins, E die Menge der mglichen Verbindungen zwischen Pin-Paaren, w(u,v) Drahtlnge zwischen Pin u und v
E. Schikuta
455
456
Beispiel: Minimaler Spannender Baum
Generischer MSB Algorithmus

Ansatz durch Greedy Algorithmus
B 4 11 7 8 H
8 2 I 6
7 C D 9
14
E 10
1. Algorithmus verwaltet eine Menge A von Kanten, die immer eine Teilmenge eines mglichen MSB sind 2. MSB wird schrittweise erzeugt, Kante fr Kante, wobei fr jede Kante berprft wird, ob sie zu A hinzugefgt werden kann, ohne Bedingung 1 zu verletzen So eine Kante heit sichere Kante (safe edge)
Generic-MSB(G, w) { eine sichere A = {}; Kante? while (A bildet keinen MSB) { finde eine Kante [u,v] die fr A "sicher" ist A = A { [u,v] } } }
Wie finde ich so
G 1 2
Gewicht des MSB: 37 MSB ist nicht eindeutig, Kante [B, C] knnte durch [A, H] ersetzt werden
E. Schikuta
457
458
6.6.1 Kruskal Algorithmus Grundidee: 1. Die Menge der Knoten reprsentiert einen Wald bestehend aus |V| Komponenten
an Beginn keine Kante
Kruskal Algorithmus (2)

MSB-Kruskal(G(V, E), w) { A = {}; for (jeden Knoten v V) make-set(v); sortiere die Kanten aus E nach aufsteigendem Gewicht w for(jede Kante [u,v]E in der Reihenfolge der Gewichte) if(find-set(u) != find-set(v)) { A = A { [u,v] } union(u, v) w enthlt die Gewichte zwischen den Knoten, z.B. } Gewicht zwischen u und v = w(u,v) return A; make-set(v) erzeugt eine Baum mit Knoten v find-set(v) liefert ein reprsentatives Element fr }
die Menge die v enthlt union vereinigt 2 Bume zu einem Baum
2. Die sichere Kante, die hinzugefgt wird, ist immer die Kante mit dem niedrigsten Gewicht, die zwei unterschiedliche Komponenten verbindet Greedy Ansatz
in jedem Schritt wird die Kante mit niedrigstem Gewicht zum Wald hinzugefgt
E. Schikuta
E. Schikuta
459
460
Beispiel: Kruskal Algorithmus

1
4 A 8 H 11 7 1 8 2 11 8 H 7 1 8 2 11 8 H 7 1 8 2 11 8 H 7 1 I 6 10 G 2 F 8 H 4 14 I 6 10 G C 7 2 F 8 H 4 14 I 6 10 G C 7 2 F 8 H 4 14 I 6 10 G C 7 2 F 8 H B 8 2 4 14 C 7 D 9 E A
Mengenoperationen fr Kruskal
make-set(x) { p[x] = x; rank[x] = 0; } link(x,y) { if (rank[x] > else { p[x] = y; if (rank[x] rank[y] = } } find-set(x) { if(x != p[x]) return p[x]; } union(x, y) { link(find-set(x), find-set(y)); } p[x] enthlt den Elternknoten von x (Vertreter der Teilmenge) rank[] ist eine obere Grenze der Hhe von x (Anzahl der Kanten zwischen x und einem Nachfolger-Blatt a find-set(v) sucht die Wurzel und trgt sie danach jedem Knoten als Elternknoten ein
5
4 11
8 2 I 7 1 8 2 6
D 9
9
4 E 10 A 8 11
8 2 I 7 6
D 9
14
14 10
G C 7
1 8 2
G C 7
2
4 A
D 9 E
6
4 A 11
D 9
10
4 E 10 A 8 11
D 9
rank[y]) p[y] = x;
I 7 1 8 2 6 G C
14
I 7 H 1 8 2 6
14 10
3
4 A
2 7
G C 7
D 9 E
7
4 A 11
D 9
11
4 E 10 A 8 11
D 9
= rank[y]) rank[y] + 1;
I 7 1 8 2 6 G C
14
I 7 H 1 8 2 6
14 10
2 7
G C 7
4
4 A
D 9 E
8
4 A 11
D 9
12
4 E 10 A 8 11
D 9
p[x] = find-set(p[x]);
I 7 1 6 G
14
I 7 H 1 6
14 10
E. Schikuta
E. Schikuta
461
462
6.6.2 Prim Algorithmus Grundidee: 1. Die Menge A bildet einen einzelnen Baum 2. Die sichere Kante, die hinzugefgt wird, ist immer die Kante mit dem niedrigsten Gewicht, die den Baum mit einem Knoten verbindet, der noch nicht im Baum ist Greedy Ansatz
Prim Algorithmus
MSB-Prim(G(V,E), w, r) { Q ist eine Priority Queue die alle Knoten Q = V; entsprechend ihres key Wertes speichert for(jeden Knoten u Q) key[v] ist das minimale Gewicht der key[u] = ; Kante die v mit einem Knoten im Baum key[r] = 0; verbindet pred[r] = NIL; r ist die Wurzel (Startknoten) des MSB while(Q != {}) { pred(v) speichert den Vorgnger von v u = Extract-Min(Q) for(jeden Knoten v adjazent zu u) if(v Q && w(u,v) < key[v]) { pred[v] = u; key[v] = w(u,v); } } }
E. Schikuta
463
464
Beispiel: Prim Algorithmus
Aufwand
Aufwand der Algorithmen stark abhngig von der Implementation der Mengenoperationen bzw. der Datenstrukturen fr die Mengenverwaltung (Priority Queue, ...) Kruskal: Im gnstigsten Fall O(E log E)
Initialisierung O(V) Kanten sortieren O(E log E) O(E) mal disjunkte Teilmengen finden O(E log E)
1
4 A 8 11
8 2 I 7 6
D 9
4
4 E 10 A 8 11
8 2 I 7 6
D 9
7
4 E 10 A 8 11
8 2 I 7 6
D 9
14
14
14 10
1 8 2
G C 7
1 8 2
G C 7
1 8 2
G C 7
2
4 A 8 11
D 9
5
4 E 10 A 8 11
D 9
8
4 E 10 A 8 11
D 9
I 7 H 1 8 2 6 G C
14
I 7 H 1 8 2 6 G C
14
I 7 H 1 8 2 6
14 10
3
4 A 8 11
2 7
2 7
G C 7
Prim: Im gnstigsten Fall O(E log V)

E
D 9
6
4 E 10 A 8 11
D 9
9
4 E 10 A 8 11
D 9
I 7 H 1 6 G
14
I 7 H 1 6 G
14
I 7 H 1 6
14 10
PQ als Heap, d.h. Aufbau O(V log V) while Schleife |V| mal, Extract-Min O(log V), d.h. O(V log V) For Schleife O(E) mal, key verndern in PQ O(log V), d.h. O(E log V) Summe beider Schleifen O(E log V + V log V) = O(E log V)
Lsst sich durch FibonacciHeap verbessern auf O(E + V log V)
E. Schikuta
E. Schikuta
465
466
6.7 Krzeste Wege Gewichte zwischen Knoten knnen als Weglngen oder Kosten angesehen werden Es ergibt sich oft die Fragestellung nach dem (der) krzesten Weg(e) zwischen Einem Knoten und allen anderen Knoten Zwei Knoten Zwischen allen Knoten Annahme: alle Kosten sind gespeichert in der Kostenmatrix C (C[u,v] enthlt Kosten von u nach v)
Beispiel: Streckennetz einer Fluglinie

Annahme: nur positive Kantenwerte Manche Algorithmen funktionieren nur mit positiven Werten
1 10 30 2 50 3 20 60 100 5
10 4
E. Schikuta
E. Schikuta
467
468
6.7.1 Dijkstra Algorithmus Single Source Shortest Paths

Algorithmus zur Suche des krzesten Weges von einem Startknoten zu allen anderen Knoten Idee
Ausgehend vom Startknoten werden beginnend mit dem krzesten Weg zu einem Knoten, die nchst-lngeren Wege zu allen anderen Knoten gesucht und die krzesten Wege fr die entsprechenden Knoten vermerkt.
hnlich Prims Algorithmus auf der Basis eines bfs mit Priorittsfunktion der Weglnge
Dijkstra Algorithmus
S = { 1 }; for ( i = 2; i <= |V|; i++ ) MinC[i] = C[1, i]; while ( | V \ S | ) > 1) { Akt = Knoten aus V \ S, soda MinC[Akt] = Minimum; S = S { Akt }; for (jeden Knoten v1 aus V \ S) MinC[ v1 ] = MIN (MinC[ v1 ], MinC[Akt] + w[Akt, v1]); } S Menge der bereits bearbeiteten Knoten Akt Knoten, der gerade bearbeitete wird C Kostenmatrix MinC bisher bekanntester krzester Weg
1
10
30
4
20 50 100
3
10
5 3
10 60
5
5
469
470
Berechnung
1 10 30 2 50 S {1} {1,2} {1,2,4} {1,2,3,4} Akt 2 4 3 MinC [/, 10, , 30, 100] [/, 10, 60, 30, 100] [/, 10, 50, 30, 90] [/, 10, 50, 30, 60] 3 20 60
6.7.2 All Pairs Shortest Paths Bevor wir die Fragestellung der krzesten Wege zwischen allen Knoten klren, wollen wir zuerst die (einfachere) Frage behandeln, zwischen welchen Knoten existieren berhaupt Wege Fhrt zu 2 Algorithmen
Warshall: welche Knoten sind durch Wege verbunden Floyd: alle krzesten Wege zwischen den Knoten
100 5
10 4
E. Schikuta
E. Schikuta
471
472
Transitive Hlle Fragestellung welche Knoten durch Wege verbunden (erreichbar) sind fhrt zur Frage nach der Transitiven Hlle Ein gerichteter Graph G(V, E) wird transitive (und reflexive) Hlle eines Graphen G(V, E) genannt, genau dann wenn: (v, w) E es existiert ein Pfad von v nach w in G Ausgangspunkt: Adjazenzmatrix von G Idee
Warshall Algorithmus
Iteratives Hinzufgen von Kanten im Graphen fr Pfade der Lnge 2

k 1. i d.h. Pfad (i,k) und (k,j) wird durch neue Kante (i,j) beschrieben k 2. i in weiterer Folge wird dann natrlich auch Pfad (i,j) und (j,a) als Pfad der k Lnge 2 gefunden (in Wirklichkeit 3. i klarerweise Pfad der Lnge 3), usw. Fhrt dazu, dass die neuen Kanten immer lngere Pfade beschreiben, bis alle mglichen Pfade gefunden sind j j j
a a a
Ansatz durch 3 verschachtelte Schleifen, hnlich der Matrizenmultiplikation
E. Schikuta
E. Schikuta
473
474
Warshall Algorithmus (2)

warshall (Matrix a) { a Adjazenzmatrix n = a.numberofRows(); bei a als Bit-Matrix for(int k = 0; k < n; k++) | binrer OR Operator for(int i = 0; i < n; i++) & binrer AND Operator for(int j = 0; j < n; j++) a[i,j] = a[i,j] | a[i,k] & a[k,j]; } Fgt Pfad als neue Kante (falls sie noch nicht existiert) in den Graphen ein
Beispiel: Warshall (1)
True (1), falls Weg zwischen i und j ber k existiert
0 1 2 3 4
0 0 0 0 0 0
1 0 0 0 1 0
2 0 0 0 0 1
3 0 0 1 0 0
4 1 0 0 0 0
0 1 2 3 4
0 0 0 0 0 0
1 1 0 1 1 1
2 1 0 0 0 1
3 1 0 1 0 1
4 1 0 0 0 0
E. Schikuta
E. Schikuta
475
476
Beispiel: Warshall (2)

Werte fr K (Durchlufe uere Schleife): 0: keine Kante, da a(?,0) nicht mglich 1: keine Kante, da a(1,?) nicht mglich 2: Kante a(4,2), a(2,3) a(4,3)
0 4 2 3 1
Floyd Algorithmus Berechnung der krzesten Wege zwischen allen Knoten ist simpel aus dem Warshall Algorithmus ableitbar
Wird wie Treesort Floyd zugeschrieben
3: a(2,3), a(3,1) a(2,1) a(4,3), a(3,1) a(4,1)

0 4 2 3 1
4: a(0,4), a(4,1) a(0,1) a(0,4), a(4,2) a(0,2) a(0,4), a(4,3) a(0,3)

0 4 2 3 1
Unterschied
Adjazenzmatrix speichert die Weglngen zwischen den Knoten (entspricht der Kostenmatrix)
0 0 1 2 3 4 0 0 0 0 0
1 0 0 0 1 0
2 0 0 0 0 1
3 0 0 1 0 1
4 1 0 0 0 0 0 1 2 3 4
0 0 0 0 0 0
1 0 0 1 1 1
2 0 0 0 0 1
3 0 0 1 0 1
4 1 0 0 0 0 0 1 2 3 4
0 0 0 0 0 0
1 1 0 1 1 1
2 1 0 0 0 1
3 1 0 1 0 1
4 1 0 0 0 0
E. Schikuta
Statt 0/1 Werte die Wegkosten
Beim Feststellen eines Pfades ber 2 Kanten einfache Berechnung der Weglnge dieser neuen Kante und Vergleich mit aktueller Weglnge (falls schon vorhanden)
Statt logisches AND die Berechnung der Kostensumme
477
478
Floyd Algorithmus (2)

floyd (Matrix a) { n = a.numberofRows(); for(int k = 0; k < n; k++) for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) { int newPathLength = a[i,k] + a[k,j]; if(newPathLength < a[i,j]) a[i,j] = newPathLength; Berechnung der } Weglnge ber } neuen Pfad Eintrag in die Kostenmatrix, falls neuer Weg krzer als mglicherweise vorhandener alter Weg
Beispiel: Floyd
8 0 3 5 1
0 1 2
E. Schikuta
0 0 3
1 8 0 2
2 5
0 1 2
0 0 3 5
1 7 0 2
2 5 8 0
E. Schikuta
479
480
Beispiel: Floyd (2)

Ausgangsposition
8 3 5
2
6.8 Genereller iterativer Ansatz Genereller iterativer Ansatz zur Traversierung eines Graphen mit Hilfe 2 (simpler) Listen
2 5 8 0
k: 0 Kanten: (1,0) (0,2) (1,2), Kosten: 8

0 1 8 0 2 2 5
0 1
0 3
8 3
2 8
1 8 0 2
2
0 1 2 0 3
OpenList
Speichert bekannte aber noch nicht besuchte Knoten
CloseList
Speichert alle schon besuchten Knoten
k: 1 (0,1) (1,2) (0,2): 16 (2,1) (1,0) (2,0): 5 (2,1) (1,2) (2,2):10

0 8 3 5
2 5 2 0
k: 2 (0,2) (2,0) (0,0): 10 (0,2) (2,1) (0,1): 7 (1,2) (2,0) (1,0): 13

0 1 8 0 2 5 8 0 1 0 3
Expandieren eines Knoten

Generieren der Nachfolger eines Knoten d.h. OpenList enthlt alle generierten (bekannten), aber noch nicht expandierten Knoten, CloseList alle expandierten Knoten
1 8
7 3
1 8 5 5
1 7 0 2
2 5 8 0
2
0 1 2 0 3 5
5
Ohne weitere Steuerung Traversierungsansatz unsystematisch

E. Schikuta
481
482
Unsystematische Traversierung
Search(Knoten v) { OpenList = [v]; CloseList = []; while (OpenList != []) { Akt = beliebigerKnotenAusOpenList; // ??? OpenList = OpenList \ [Akt]; CloseList = CloseList + [Akt]; process(Akt); // whatever to do for(alle zu Akt adjazente Knoten v1){ if (v1 OpenList && v1 CloseList) OpenList = OpenList + [v1]; } } }
Beispiel (F)
0 1 5 3
2
Es werden alle Knoten besucht, die vom Startknoten aus erreichbar sind. Unterschied gerichteter ungerichtetere Graph?
z.B.: Search(5) OpenList: 5|3,4|4,0|0,2,8|2,8|8| CloseList: 5,3,4,0,2,8 Akt: 5|3|4|0|2|8
E. Schikuta
483
484
6.8.1 Zusammenhangskomponente im ungerichteten Graphen Erweiterung von Search Feld zum Vermerken der Komponenten K[ |V| ]
int Vanz = |V|; int Knum = 0; for (int i = 0; i < Vanz; i++) if(K[i] == 0) { Knum = Knum + 1; SearchAndMark(i, Knum); } SearchAndMark(Knoten v; int Knum) { neue Version von Search wobei process(Akt); entspricht K[Akt] = Knum; }
Zusammenhangskomponente
SearchAndMark(Knoten v; int Knum) { OpenList = [v]; CloseList = []; while (OpenList != []) { Akt = beliebigerKnotenAusOpenList; OpenList = OpenList \ [Akt]; CloseList = CloseList + [Akt]; K[Akt] = Knum; for(alle zu Akt adjazente Knoten v1){ if (v1 OpenList && v1 CloseList) OpenList = OpenList + [v1]; } } }
485
486
Beispiel (F)
0 1 5 3
Systematisierung der Traversierung Systematische Traversierung schon bekannt

Tiefensuche dfs Breitensuche bfs
2 Frage: Was wre bei einem gerichteten Graphen? K

0 1 1 1 2 1 3 1 4 1 5 1 6 2 7 2 8 1
Unklarer Programmteil
beliebigerKnotenAusOpenList
Systematisierung durch Organisation der Auswahl

Aufbau der Liste
Position des einzufgenden Elements in der Liste bfs: OpenList = OpenList + [v1]; am Ende dfs: OpenList = [v1] + OpenList; am Anfang
OpenList: 5|1,3,4|3,4|4,0|0,2,8|2,8|2|6|7 CloseList: 5,1,3,4,0,2,8|6,7 Akt: 5|1|3|4|0|2|8|6|7
Zugriff auf die OpenList

Zugriff: First(OpenList); Zugriff immer auf das erste Element
E. Schikuta
487
488
Systematische Traversierung
Search(Knoten v) { OpenList = [v]; CloseList = []; while (OpenList != []) { Akt = First(OpenList); OpenList = OpenList \ [Akt]; CloseList = CloseList + [Akt]; process(Akt); for(alle zu Akt adjazente Knoten v1){ if (v1 OpenList && v1 CloseList) dfs: OpenList = [v1] + OpenList; bfs: OpenList = OpenList + [v1]; } } }
Beispiel (F)
0 1 5 3
z.B.: Search(5) mit dfs OpenList: 5|3,4|0,4|4|2,8|8| CloseList: 5,3,0,4,2,8 Akt: 5|3|0|4|2|8
z.B.: Search(5) mit bfs OpenList: 5|3,4|4,0|0,2,8|2,8|8| CloseList: 5,3,4,0,2,8 Akt: 5|3|4|0|2|8
E. Schikuta
489
490
Noch ein kleines Problem Systematisierung noch nicht ganz vollstndig Anweisung
for(alle zu Akt adjazente nicht besuchte Knoten v1){
6.8.2 Dijkstra Algorithmus mit OL/CL Krzester Weg von S nach Z

OpenList = [S]; CloseList = []; while (true) { if ( OpenList == [] ) return 1 // war nix! Akt = ElementAusOpenList, sodass Akt.c = min; if (Akt = Z) return Akt.c; OpenList = OpenList \ [Akt]; CloseList = CloseList + [Akt]; for (jeden Knoten v1 adjazent zu Akt) { if ( v1 OpenList && v1 CloseList ) { v1.c = Akt.c + C[Akt, v1]; OpenList = OpenList + [v1]; } else { v.c Speichert die Lnge if (v1 OpenList) des aktuell krzesten if (Akt.c + C[Akt,v1] < v1.c) Weges vom Startknoten v1.c = Akt.c + C[Akt,v1]; zum Knoten v } }
fhrt zu undefinierter Reihenfolge aller adjazenter Knoten bei der Weiterbearbeitung

Reihenfolge definiert durch die interne Graphenspeicherung
Adjazenzliste, Adjazenzmatrix
Annahme: adjazente Knoten werden aufsteigend sortiert eingetragen
E. Schikuta
491
492
Beispiel (F)
Gesucht: krzester Weg von 1 nach 5 OpenList: 1|2,4,5|5,3|5| CloseList: 1,2,4,3 Akt: 1|2|4|3|5 c: 1 2 3 4 0 1 10 30 2 50 3 20 60
Beweisskizze
Satz: Falls ein Knoten v bereits in der CloseList ist, kann es keinen gnstigeren Pfad vom Startknoten nach v geben als jenen, der bereits berechnet wurde
100 5
d.h. nochmals besucht Knoten, die schon in der CloseList sind, knnen einen Pfad nicht verkrzen
Annahme: K in CloseList und Akt.c + C(Akt, K) < K.c Akt In dem Schritt, als K aus der OpenList in die CloseList gebracht wurde, galt offenbar C(Akt,K) S K.c Akt.c K.c pred(Akt).c
pred(Akt) bezeichnet einen Vorgnger von Akt K
10 4
10 60 30 100 50 90 60
Es gilt aber auch pred(Akt).c < Akt.c, somit also K.c Akt.c K.c pred(Akt).c < Akt.c K.c Akt.c Widerspruch: es gibt keine positiven Akt.c, C(Akt, K), K.c, sodass diese Ungleichung gilt
493
Was nehmen wir mit? Graphen

Definitionen Gerichtete und ungerichtete Graphen
Topologisches Sortieren Traversierung

Bfs und dfs Bauer, Wolf, Ziege du Kohlkopf Problem
Spannende Bume Krzeste Wege Generell iterativer Ansatz


Algorithmen Und Datenstrukturen SS07

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Algorithmen Und Datenstrukturen SS07

Hochgeladen von

Copyright:

Verfügbare Formate

1

Algorithmen und Datenstrukturen (PI.ADS.AD.VO)

Ao. Univ.-Prof. Dipl.-Ing. Dr. Erich Schikuta

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

0.1 Was ist Informatik ?

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Modelle der Informatik

Beispiele fr Modelle Kochrezept als Folge von Anweisungen

Bedienungsanleitung Informatik Kochrezept

Beschreibung von Ursache-WirkungsZusammenhngen

Algorithmus - Eigenschaften (1)

Granularitt der Operationen

Paradigmen und Darstellung

Das logikbasierte Paradigma

ein Problem: Widersprche zwischen den Regeln

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Das funktionale Paradigma

Das prozedurale Paradigma

jedes Vorkommen von 'A' kann durch 'D' ersetzt werden

VO Algorithmen und Datenstrukturen

n>0 summe = summe + n n=n1 drucke summe

int summe = 0; while(n > 0) { summe += n; n--; } cout << summe;

VO Algorithmen und Datenstrukturen

Klassifikation von Programmiersprachen:

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

0.4 Programmstrukturen Elemente einer prozeduralen Programmiersprache

Satz (Bhm / Jacopini 1966):

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Eintrittsbedingung Anweisung(en), Schleifenblock

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Iteration oder Schleife

beide knnen ber Parameterliste Werte zurckliefern

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Berechnung der Fibonacci Zahlen

VO Algorithmen und Datenstrukturen

Direkte Rekursion, Beispiel Berechnung von 3!

Indirekte Rekursion Definition eines Ausdrucks (expression) in MODULA-2

Expr ::= SimpleExpr [RelOp SimpleExpr]

SimpleExpr ::= [SignOp] Term [AddOp Term]

Term ::= Factor {MulOp Factor}

return (3*2) 3*2*1*1

return (2*1) 2*1*1

Factor ::= ( Expr ) | NOT Factor | Value

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

indirekte Rekursion, Beispiel Ableitung des Ausdrucks: 3 * ( 4 + 5 )

Charakteristik rek. Lsungsanstze Eigenschaften

Factor Expr SimpleExpr + Term Value 5

Rekursiver Ansatz Drei Kriterien

Konstruktion des Endergebnisses

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

Was nehmen wir mit? Algorithmus Darstellung Programmstrukturen Rekursion

VO Algorithmen und Datenstrukturen

VO Algorithmen und Datenstrukturen

return (32) 3211

return (21) 21*1