pdf, 387 KB

Algorithmen und Datenstrukturen 

4. Semester Wirtschaftsinformatik 

SS 2010 

Prof. Dr. Heinrich Paessens 

0. Begriffe 

1. Einführung 

1.1 Beispiele für Algorithmen 

- Verschiedene Algorithmen für dasselbe Problem 

- Entwurfstechniken für Algorithmen 

1.2 Typen von Lösungsverfahren (Optimierungsprobleme) 

1.3 Algorithmenkomplexität 

1.4 Problemkomplexität 

2. Lineare Datenstrukturen 

2.1 Eindimensionale Felder 

2.2 Speicherung linearer Felder 

2.3 Stapel, Rekursionen und Schlangen 

2.4 Mehrdimensionale Felder 

3. Komplexe Datenstrukturen 

3.1 Graphen - Definitionen 

3.2 Darstellung von Problemen durch Graphen 

3.3 Speicherung von Graphen 

4. Graphenalgorithmen 

4.1 Kürzeste Wege Algorithmen 

4.1.1 Dijkstra-Algorithmus 

4.1.2 Ford-Algorithmus 

4.1.3 Tripel-Algorithmus 

4.1.4 Bellman-Algorithmus (Typ A) 

4.1.5 Topologisches Sortieren - Bellman-Algorithmus (Typ B) 

4.2 Bestimmung von Minimalgerüsten 

5. Bäume 

5.1 Binärbäume - Speicherung, Durchsuchen von Binärbäumen 

5.2 Binäre Suchbäume 

5.3 Heapsort 

6. Spezielle Algorithmen und praktische Anwendungsbeispiele 

Literatur: 

CORMEN,T.H.; LEISERSON,C.E.; RIVEST,R.; STEIN,C.: Algorithmen - Eine Einführung. 

Oldenbourg Verlag 

DOMSCHKE, W.: Logistik I. Transport. Oldenbourg Verlag 

DOMSCHKE, W.: Logistik II: Rundreisen und Touren. Oldenbourg Verlag 

HERRMANN, D.: Algorithmen Arbeitsbuch. Addison Wesley Verlag 

OTTMANN, T.; WIDMAYER, P.: Algorithmen und Datenstrukturen. Informatik Bd. 70, 

BI Wissenschaftsverlag 

SEDGEWICK, R.: Algorithmen. Addison Wesley Verlag 

Algorithmen + Datenstrukturen SS 2010 23.03.10 1 von 75

0. BEGRIFFE 

INFORMATION: 

Zweckgerichtetes, neues Wissen 

Darstellung von Informationen: 

- a, b, c... -> Text 

- 1, 2, 3... -> Zahlen 

- Bilder, Symbole, Farben, Worte, Ton 

DATEN: 

NACHRICHT: 

Informationen in einer Darstellung, die zur weiteren 

Verarbeitung geeignet ist 

Information zum Zwecke der Weitergabe 

früher: 

DV (Datenverarbeitung): Verarbeitung von Daten mit Hilfe von 

Algorithmen, Methoden etc. zu neuen Daten 

EDV: 

IV: 

heute: 

IT: 

Elektronische DV 

Informationsverarbeitung 

Informationstechnologie 

INFORMATIK (informatique, computer science): 

Wissenschaft, die sich mit der systematischen und automatischen Verarbeitung, 

Speicherung und Übertragung von Informationen befasst 

Vereinigungen: 

Deutschland: Gesellschaft für Informatik (GI) 

http://www.gi-ev.de 

USA: Association for Computing Machinery (ACM) 

http://www.acm.org (-> digitale Bibliothek) 


Gegenstände der Informatik 

Informatik 

Informationstechnik 

Informatik- 

Anwendungen 

Informatik- 

Auswirkungen 

Computer- 

Hardware 

Methoden der 

Software- 

Entwicklung 

Verfahren der 

Nachrichtentechnik 

Anwender Benutzer Betroffene 

Geoinformatik 

Ingenieurinformatik 

Wirtschaftsinformatik 

Rechts- Verwaltungs- Medizinische 

informatik informatik Informatik 

Bioinformatik 

Quelle: Gesellschaft für Informatik (1985) 


Die WIRTSCHAFTSINFORMATIK (WI) befasst sich mit der 

- Konzeption 

- Entwicklung 

- Einführung 

- Nutzung 

- Wartung 

von Anwendungssystemen der computergestützten Informationsverarbeitung 

im Unternehmen. 

Fendt FH FL: 

Erkenntnis- und Gestaltungsobjekt der WIRTSCHAFTSINFORMATIK 

sind Informations- und Kommunikationssysteme (IuK) in Wirtschaft 

und Verwaltung. 

PROBLEM: Gegeben ist ... 

Gesucht ist ... 

- Optimierungsprobleme 

- Min, Max Bestimmung 

Bsp. 

Kürzesten Weg bestimmen, 

Lineare Optimierung 

Maximum Subarray Problem 

- Nichtoptimierungsprobleme 

- Bestimmung einer zulässigen Lösung 

Bsp. Primzahlen berechnen, 

Sortieren von Zahlen, 


ALGORITHMUS: 

vollständige, endliche Beschreibung eines Verfahrens zur Lösung eines 

Problems 

- Verbalbeschreibung 

- Pseudocode (programmiernahe, detailliert, formalisiert) 

- Implementierung (Darstellung des Algorithmus in einer 

Programmiersprache) 

Strukturelemente eines Algorithmus: 

- Wertzuweisung(Aktion, Befehl), 

- Bedingte Anweisung (Auswahl, Selektion) 

- Laufanweisung (Wiederholung, Iteration, Schleife) 

- Folge (Sequenz) 

PSEUDO-CODE: 

Ein mit Hilfe eines Pseudo-Codes beschriebenes Verfahren besteht aus 

einer Folge von Anweisungen, die jeweils einzeln in einer Zeile 

geschrieben werden. Enthält eine Anweisung wiederum eine Folge von 

Anweisungen (Sequenz), so wird diese Anweisungsfolge nach rechts 

eingerückt. Die Abarbeitung der Anweisungen erfolgt von oben nach 

unten. 

In dieser Veranstaltung wird folgende Darstellung benutzt 

(Schlüsselworte sind fett, Platzhalter sind in spitzen Klammern 

angegeben): 

Wertzuweisung (Aktion, Befehl): 

← 

z.B. x ← x + 1 

Bedingte Anweisung (Auswahl, Selektion): 

falls dann 

andernfalls 

z.B. falls x > 5 dann y←0 

andernfalls y←1 


Laufanweisung (Wiederholung, Iteration, Schleife): 

für ← ,… , führe aus 

 

 

… 

Anmerkung: die Laufvariable erhält sukzessive (Inkrement jeweils 

+1) alle ganzzahligen Werte aus dem Intervall zwischen Startund 

Endwert zugewiesen. Falls der Startwert größer ist als der 

Endwert, wird Anweisung 1 , … nicht durchgeführt 

oder 

für ← ,… , (-1) führe aus 

 

 

… 

Anmerkung: die Laufvariable erhält sukzessive (Inkrement jeweils 

-1) alle ganzzahligen Werte aus dem Intervall zwischen Startund 

Endwert zugewiesen. Falls der Startwert kleiner ist als der 

Endwert, wird Anweisung 1 , … nicht durchgeführt 

oder 

solange führe aus 

 

 

… 

Anmerkung: die Anweisung(en) werden solange wiederholt 

ausgeführt, bis der boolesche Ausdruck den Wahrheitswert 

‚falsch’ liefert. 

oder 

wiederhole 

 

 

… 

bis 

Anmerkung: die Anweisung(en) werden solange wiederholt 

ausgeführt, bis der boolesche Ausdruck den Wahrheitswert 

‚wahr’ aufweist. 


Beispiel für einen Algorithmus: 

(1) Koche Wasser 

(2) Nehme Kaffeedose aus dem Schrank 

(3) Gib Kaffeepulver in die Tasse 

(4) Fülle Wasser in die Tasse 

oder detaillierter: 

(1) Koche Wasser 

(1.1) Fülle Wasserkessel mit Wasser 

(1.2) Stelle Wasserkessel auf Herdplatte 

(1.3) Schalte Herdplatte an 

(1.4) Warte, bis das Wasser kocht 

(1.5) Schalte Herdplatte aus 

(2) Nehme Kaffeedose aus dem Schrank 

(2.1) Falls Kaffeedose leer 

dann hole neue Dose 

(3) Gib Kaffeepulver in die Tasse 

(3.1) Öffne Kaffeedose 

(3.2) Entnehme einen Löffel Kaffee 

(3.3) Kippe Löffel über der Tasse 

(3.4) Schließe Kaffeedose 

(4) Fülle Wasser in die Tasse 

(4.1) Gieße Wasser aus dem Kessel in die 

Tasse, bis diese gefüllt ist 

DATENSTRUKTUR: 

Organisations- und Speicherform der im Algorithmus benötigten Daten 


1. EINFÜHRUNG 

1.1 BEISPIELE FÜR ALGORITHMEN 

Problem GGT Bestimmung des größten gemeinsamen Teilers 

Gegeben: 2 positive, ganze Zahlen x, y 

Gesucht: größte Integerzahl, durch die x und y 

ohne Rest dividiert werden können 

Algorithmus GGT-1: ,brute force‘-Methode (naive Methode) 

Verbalbeschreibung: 

S1: bestimme t: die kleinere Zahl von x und y 

falls x=y: x=y ist GGT -> ENDE 

S2: dividiere x und y durch t 

S3: falls Division x/t und y/t ohne Rest möglich: 

t = GGT von x, y -> ENDE 

falls Division x/t und y/t ohne Rest nicht möglich: 

setze t ← t-1 

gehe zu S2 

Pseudocode: falls x < y dann t ← x andernfalls t ← y 

solange (x MOD t < > 0) oder (y MOD t < > 0) 

führe aus 

t ← t-1 

GGT = t 


Algorithmus GGT-2: Euklidscher Algorithmus 


S1: Vermindere die größere Zahl um die kleinere Zahl, bis die 

‚größere Zahl‘ kleiner ist als die ‚kleinere Zahl‘; 

falls die ‚kleinere Zahl‘ gleich der ‚Größeren‘ ist, 

setze Kleinere = Größere = GGT -> ENDE 

S2: Vertausche die ‚kleinere‘ mit der ‚größeren Zahl‘, 

gehe zu S1 

Problem MSP Maximum Subarray Problem 

Gegeben: Folge X von n ganzen Zahlen 

Gesucht: zusammenhängende Teilfolge von X mit 

maximaler, nichtnegativer Summe 

Algorithmus MSP-1: ,brute force‘-Methode (naive Methode) 


S1: bestimme alle möglichen zusammenhängenden Teilfolgen 

von X 

S2: berechne ihre Summen 

S3: die Teilfolge mit der größten Summe ist die gesuchte 

Teilfolge -> ENDE 

Pseudocode: max_bis_jetzt ← 0 

für i ← 1, ..., n führe aus 

für j ← i, ..., n führe aus 

summe ← 0 

für k ← i, ..., j führe aus 

summe ← summe + X[k] 

max_bis_jetzt ← max(max_bis_jetzt, summe) 

{ max_bis_jetzt enthält den Wert der maximalen 

Summe} 


Algorithmus MSP-2: Divide and Conquer - Verfahren 

(teile und herrsche (bearbeite)) 

msp_2(X) 

Falls X nur 1 Element a enthält: 

falls a > 0 setze msp_2 ← a 

andernfalls setze msp_2 ← 0 

andernfalls 

S1: teile X in eine linke Teilfolge A und eine rechte Teilfolge 

B annähernd gleicher Größe 

S2: Bestimme die maximale Summe der Elemente einer 

zusammenhängenden Teilfolge, die beide Randelemente der 

Trennstelle enthält: 

a) Bestimme das rechte 'Randmaximum' maxRandA der 

linken Teilfolge A 

b) Bestimme das linke 'Randmaximum' maxRandB der 

rechten Teilfolge B 

c) Bestimme die Summe von a) und b) maxRandA/B 

S3: a) Bestimme die maximale Summe einer zusammenhängenden 

Teilfolge in A : 

max_in_A ← msp_2(A) 

b) Bestimme die maximale Summe einer zusammenhängenden 

Teilfolge in B : 

max_in_B ← msp_2(B) 

S4: msp_2 ← max (max_in_A, max_in_B, maxRandA/B) 

Algorithmus MSP-3: Inspektionsverfahren 

max_bis_jetzt ← 0 und maxRand ← 0 


maxRand ← maxRand + X[i] 

falls maxRand < 0 dann maxRand ← 0 

falls max_bis_jetzt < maxRand 

dann max_bis_jetzt ← maxRand 


1.2 TYPEN VON LÖSUNGSVERFAHREN (Optimierungsprobleme) 

EXAKTE VERFAHREN: die optimale Lösung wird nach endlich 

vielen Schritten erreicht 

HEURISTISCHE VERFAHREN: eine Lösung wird durch Anwendung 

eines plausiblen Lösungsansatzes nach strategischen 

Gesichtspunkten oder ‘Durchprobieren’ verschiedener 

Lösungsansätze erreicht. Die gefundene Lösung ist nicht 

notwendigerweise optimal. Die Güte eines heuristischen 

Verfahrens ist insbesondere danach zu beurteilen, wie weit 

die gefundene Lösung vom Optimum entfernt liegt. 

1.3 ALGORITHMENKOMPLEXITÄT 

Kriterien zur Beurteilung von Algorithmen: 

- Einfachheit 

- Verständlichkeit 

- Länge 

- Speicherplatzbedarf 

- Daten 

- Quellcode 

- intern 

- extern 

- Rechenzeitbedarf 

abhängig von 

- Rechnertyp 

- Betriebssystem 

- Programmiersprache 

- Compiler 

- Compileroptionen (on/off) 

- Implementierung 

- Problemgröße 

- Problemtyp 


angegeben in - 

- absolute Rechenzeit (z.B. in Sekunden) 

- Anzahl der Schlüsseloperationen 

- worst case 

- average case (Erwartungswert) 

- ‚big-O‘–Notation : Obergrenze der Größenordnung 

des Wachstums des Rechenzeitbedarfs 

Größenordnungen des Wachstums des Rechenzeitbedarfs (n: Problemgröße): 

O(...) n=10 n=100 n=1000 Bezeichnung 

des Wachstums 

O(1) z.B. 1 1 1 konstant 

O(log 2 n) z.B. 3.32 6.64 9.97 logarithmisch 

O(n) z.B. 10 100 1.000 linear 

O(n*log 2 n) z.B. 33.2 664.4 9965 überlogarithmisch 

O(n 2 ) z.B. 100 10.000 1.000.000 quadratisch 

O(n 3 ) z.B. 1.000 1.000.000 1.000.000.000 kubisch 

O(2 n ) z.B. 1024 10 30 10 301 exponentiell 

O(n!) z.B. 

3.628.800 

9*10 157 10 2567 faktoriell 

1.4 PROBLEMKOMPLEXITÄT 

P-PROBLEM: 

Problem, zu dem mindestens ein exaktes Verfahren 

existiert, dessen Rechenzeitverhalten in 

Abhängigkeit von der Größe des Problems 

durch ein Polynom darstellbar ist. 

NP-PROBLEM: Problem, zu dem kein exaktes Verfahren 

existiert, dessen Rechenzeitverhalten in Abhängigkeit 

von der Größe des Problems durch ein 

Polynom darstellbar ist 


VERGLEICH MAXIMUM SUBARRAY PROBLEM - ALGORITHMEN 

(Rechenzeiten in std:min:sek) 

O(...) 

n = 

1000 3.000 10.000 100.000 1.000.000 10.000.00 

0 

100.000.000 

MSP- 1a O(n 3 ) 00:05:08 02:15:72 

MSP- 1b O(n 2 ) 00:00:00 00:00:34 00:04:01 06:44:27 

MSP - 2 O(n log n) 00:00:00 00:00:00 00:00:02 00:00:23 00:02:47 00:27:54 05:04:77 

MSP- 3a O(n) 00:00:00 00:00:00 00:00:00 00:00:01 00:00:13 00:01:23 00:12:29 

MSP- 3b O(n) 00:00:00 00:00:00 00:00:00 00:00:01 00:00:04 00:00:43 00:04:29 

Dell, Latitude D410 

C# 2003 

Windows XP 

n : Anzahl Elemente 


2. LINEARE DATENSTRUKTUREN 

2.1 EINDIMENSIONALE FELDER / LINEARE FELDER 

Ein LINEARES FELD (lineare Liste, array) A ist eine Datenstruktur, die 

aus nmax KNOTEN (Elementen) desselben Datentyps besteht. Ein 

lineares Feld wird auch als 'strukturierter Datentyp' bezeichnet. 

Jeder Knoten mit Ausnahme des letzten Knotens hat genau einen 

Nachfolger. Jed48 

er Knoten mit Ausnahme des ersten Knotens hat genau einen Vorgänger. 

nmax ist die maximale Anzahl der Knoten von A und wird als GRÖßE 

oder LÄNGE des Feldes A bezeichnet. 

0 ≤ n ≤ nmax Knoten besitzen einen Informationsgehalt und werden als 

DATENKNOTEN, nmax - n Knoten besitzen keinen Informationsgehalt 

und werden als FREIE KNOTEN bezeichnet. 

A: 

10 15 8 25 

n 

nmax 

A: 

Index: 

10 15 8 25 

1 2 3 4 5 6 

Datenknoten 

Freie Knoten 

Standardmäßig sind die Knoten mit 1, ..., nmax, die Datenknoten mit 1, 

..., n und die freien Knoten mit n+1, ..., nmax durchnumeriert. Die Länge 

des Feldes A kann aus der Ober- und Untergrenze ermittelt werden: 

nmax = Obergrenze – Untergrenze + 1 

Der i-te Knoten wird mit Ai , A(i) bzw. A[i] oder als Knoten mit INDEX 

oder ADRESSE i bezeichnet. 


Problem PRIM Primzahlenbestimmung 

Gesucht: aufsteigend sortierte Speicherung und Ausgabe aller 

Primzahlen im Bereich 2,...,n sowie die Anzahl der 

Primzahlen im genannten Bereich. 

Primzahlen: alle Zahlen, die nur durch 1 oder sich selbst 

ohne Rest teilbar sind. 1 wird nicht als Primzahl bezeichnet. 

Alle Primzahlen außer 2 sind ungerade. (2,3,5,7,11,13,17,19,...) 

Algorithmus PRIM-1: Test aller ungeraden Zahlen p≥3 auf Division 

ohne Rest 

S1: 2 ist eine Primzahl. Markiere 2 als Primzahl. 

S2: Setze p ← 3. 

S3: Prüfe, ob p durch keine bisher gefundene Primzahl 

ohne Rest dividiert werden kann. Ist dies der Fall, ist p 

eine Primzahl und markiere sie als Primzahl. 

S4: Setze p ← p+2. 

S5: Fall p ≤ n gehe zu S3. 

S6: Gebe die markierten Primzahlen aus. ->ENDE. 

Algorithmus PRIM-2: Sieb des Eratosthenes 

S1: Markiere alle Werte 2 ,..., n als Primzahlen 

S2: Führe alle möglichen Multiplikationen i * j (i,j: ganze 

Zahlen; i,j ≥ 2) mit dem Ergebnis ≤ n durch und 

entferne bei den sich ergebenden Werten die 

Markierung. 

(alle sich bei der Multiplikation ergebenden Werte sind 

keine Primzahlen !) 

S3: Gebe alle noch markierten Werte aus dem Bereich 2,..,n 

aus. -> ENDE. 


2.2 SPEICHERUNG LINEARER FELDER 

Operationen in linearen Feldern: 

a) Durchsuchen und gegebenenfalls 'Bearbeitung' aller Datenknoten 

z.B. Ausgabe aller Datenknoten mit Wert > 7 

b) Suchen eines bestimmten Datenknotens 

b1) des i-ten Datenknotens 

b2) des Datenknotens mit Inhalt WERT 

c) Einfügen eines neuen Datenknotens mit Wert NEU vor/nach dem i- 

ten Datenknoten 

d) Entfernen des i-ten Datenknotens 

e) Umordnung eines Feldes nach bestimmten Kriterien 

z.B. aufsteigende Sortierung 

f) Vereinigung von Feldern 

2.2.1 Sequentielle Speicherung linearer Felder 

Die Datenknoten A[1], A[2], ..., A[n] eines linearen Feldes sind so 

angeordnet, dass der 

logische Nachfolger von A[i] in A[i+1] 

logische Vorgänger von A[i] in A[i-1] 

gespeichert ist, d.h. 

logische Reihenfolge ≅ physikalische Speicherreihenfolge 

Adresse, Index des i-ten Datenknotens in der logischen Reihenfolge: 

Untergrenze (Basisadresse) + i - 1 


Pseudocode der Operationen (Basisadresse: 1): 

a) für i ← 1, ..., n führe aus 

falls A[i] > 7 dann 'Ausgabe i und A[i]' 

b) b1) 'bearbeite' A[i] 

b2) index ← 0 


falls A[i] = WERT dann 

falls index=0 dann 'kein entsprechender 

Datenknoten gefunden' 

index←i 

'i ist der gesuchte Index' 

c) Einfügen nach dem i-ten Datenknoten in der logischen Reihenfolge: 

für j ← n, ..., i+1 (-1) führe aus 

A[j+1] ← A[j] 

A[i+1] ← NEU 

n ← n+1 

1 2 3 4 5 6 7 ... n 

i 

v e rsc h ie b e n 

e in fü g e n 

d) Entfernen des i-ten Datenknotens in der logischen Reihenfolge: 

für j ← i, ..., n-1 führe aus 

A[j] ← A[j+1] 

n ← n - 1 

1 2 3 4 5 6 7 . .. n 

i 

v e r s c h i e b e n 


e) z.B. folgende Umordnungsvorschrift: 

Anordnung der Datenknoten A[1], ..., A[n] derart, dass eine Folge 

A'[1], A'[2], ..., A'[s], A[1], A''[1], A''[2], ..., A''[t] 

(n=s+1+t) 

entsteht mit A'[i] < A[1] ≤ A''[j] 

(keine Benutzung eines zusätzlichen Feldes !) 

Beispiel: 

A: 

1 2 3 4 5 6 1 2 3 4 5 6 

7 8 5 9 10 1 5 1 17 

8 9 10 

1. Möglichkeit ('verschieben'): 

A: 7 8 5 9 10 1 A: 5 7 8 9 10 1 

A: 

5 1 7 8 9 10 

t ← 1 


falls A[i] < A[t], dann 

merke ← A[i] 

für j ← i, ... , t+1 (-1) führe aus 

A[j] ← A[j-1] 

A[t] ← merke 

t ← t + 1 


2. Möglichkeit ('tauschen'): 

A: 7 8 5 9 10 1 A: 5 7 8 9 10 1 

A: 

5 1 7 9 10 8 

t ← 1, merke ← A[1] 


falls A[i] < merke, dann 

A[t] ← A[i] 

A[i] ← A[t+1] 

A[t+1] ← merke 

t ← t + 1 

2.2.2 Verkettete Speicherung linearer Felder 

Lineares Feld: 

1 2 3 4 5 6 7 8 9 10 

A: 7 8 5 10 4 1 

nmax 

Sequentielle Speicherung: 

Knoten: a b 

a: Adresse, Index b: Dateninhalt (falls Datenknoten) 

A: 1 7 2 8 3 5 4 10 5 4 6 1 ... 

9 10 

nmax 


Verkettete Speicherung: 

Knoten: a b c 

a: Adresse, Index b: Dateninhalt (falls Datenknoten) 

c: Zeiger auf die Adresse des nächsten Knotens in der logischen 

Reihenfolge (c=nill: kein weiterer Knoten vorhanden) 

ANFANG: Zeiger auf die Adresse des 1. Datenknotens in der logischen 

Reihenfolge. 

ANFANG=nill: kein Datenknoten vorhanden, n=0 

FREI: 

Zeiger auf die Adresse des 1. freien Knotens. 

FREI=nill: kein freier Knoten vorhanden (n=nmax) 

Zeigerinhalt des letzten Datenknotens in der logischen Reihenfolge 

sowie Zeigerinhalt des letzten freien Knotens: nill 

ANFANG=1 FREI=7 

A: 1 7 2 2 8 3 3 5 4 

4 10 5 5 4 6 6 1 nill 

7 8 8 9 9 10 

10 nill 

oder z.B. 

ANFANG=2 

FREI=3 

A: 1 8 10 2 7 1 3 5 

4 4 6 5 7 6 1 nill 

7 9 8 10 4 9 nill 

10 5 8 


d.h. logische Reihenfolge muss nicht der physikalischen Speicherreihenfolge 

entsprechen 

Pseudocode der Operationen (Basisadresse: 1) 

a) pos ← anfang 

solange pos ≠ nill führe aus 

falls A[pos] > 7 dann 'Ausgabe A[pos]' 

pos ← zeiger[pos] 

b) b1) pos ← anfang 

für j ← 1,...,i-1 führe aus 

pos ← zeiger[pos] 

'bearbeite' A[pos] 

b2) log_position ← 0 

index ← 0 

pos ← anfang 

solange pos ≠ nill führe aus 

log_position ← log_position + 1 

falls A[pos] = WERT 

dann 

index ← pos 

pos ← nill 

andernfalls pos ← zeiger[pos] 

falls index=0 dann 'kein entsprechender Datenknoten 

gefunden' 

andernfalls 'der Datenknoten mit Inhalt 

WERT hat die Adresse index und 

steht an Stelle log_position in der 

logischen Reihenfolge' 

c) Einfügen nach dem Datenknoten mit Adresse i in der logischen 

Reihenfolge: 

falls frei=nill dann 'Meldung', ENDE 

A[frei] ← NEU 

Merke ← zeiger[frei] 

zeiger[frei] ← zeiger[i] 

zeiger[i] ← frei 

frei ← merke 

n ← n+1 


d) Entfernen des Datenknotens, der dem Datenknoten mit Adresse i in 

der logischen Reihenfolge folgt: 

merke ← zeiger[i] 

zeiger[i] ← zeiger[zeiger[i]] 

zeiger[merke] ← frei 


n ← n-1 

e) pos ← anfang 

w ← A[pos] 

solange zeiger[pos] ≠ nill führe aus 

falls A[zeiger[pos]] < w dann 

merke ← zeiger[pos] 

zeiger[pos] ← 

zeiger[zeiger[pos]] 

zeiger[merke] ← anfang 

anfang ← merke 

andernfalls pos ← zeiger[pos] 


Beispiel Patientenliste 

Bettnr. Patient Zeiger 

1 Kunze 7 anfang = 5 frei = 10 

2 6 

3 Dreher 11 

4 Müller 12 logische Reihenfolge 

5 Ahrens 3 = alphabetische Reihenfolge 

6 nill 

7 Meier 4 physikalische Speicherreihenfolge 

8 Grünlich 1 = Bettnummernreihenfolge 

9 Schmidt nill 

10 2 

11 Fischer 8 

12 Nelke 9 

Beispiel Vertriebsfirma 

Vertreter Anfang Kunde Zeiger 

1 Bauer 12 1 Vater 4 

2 Keller 3 2 5 

3 Haller nill 3 Jäger 14 

4 Neumann 9 4 Zaus nill 

5 7 

Frei = 2 6 Zedelmann nill 

7 11 

8 Ritter 15 

9 Abraham 10 

10 Eisen 19 

11 13 

12 Groß 17 

13 16 

14 Wung 6 

15 Wrege nill 

16 18 

17 Schmidt 1 

18 20 

19 Eismann 8 

20 nill 


FORMEN DER VERKETTUNG: 

a) einfach verkettet: jeder Knoten enthält die Adresse des 

nächsten Datenknotens (Nachfolger) in der logischen Reihenfolge 

b) doppelt verkettet: jeder Knoten besitzt 2 Zeiger 

Vorwärtszeiger : enthält die Adresse des nächsten 

Datenknotens (Nachfolger) in der logischen 

Reihenfolge 

Rückwärtszeiger : enthält die Adresse des vorangehenden 

Datenknotens (Vorgänger) in der logischen 

Reihenfolge 

ANFANG: 

enthält die Adresse des 1. Datenknotens in 

der logischen Reihenfolge. 

ENDE: 

enthält die Adresse des letzten Datenknotens 

in der logischen Reihenfolge 

a b c d a: Adresse, Index b: Dateninhalt 

c: Rückwärtszeiger d: Vorwärtszeiger 

z.B. ANFANG = 2 ENDE = 4 FREI = 3 

1 2 4 2 nill 1 3 nill nill 4 1 nill 

c) kreisförmig verkettet: der Zeiger des letzten Datenknotens 

in der logischen Reihenfolge zeigt auf den 1. Datenknoten in der 

logischen Reihenfolge, d.h. er enthält die Adressse ANFANG 

z.B. ANFANG = 2 FREI = 3 

1 4 2 1 3 nill 4 2 


2.3 STAPEL, REKURSION UND SCHLANGEN 

2.3.1 Stapel und Rekursion 

Stapel (Keller, Stack): Lineares Feld, bei dem die „Bearbeitung“ 

(Einfügen und Entfernen) nur am Anfang des 

Feldes vorgenommen werden kann 

(LIFO-Prinzip: last in, first out) 

z.B. Bücherstapel 

Sequentielle Speicherung: 

n 

nmax 

1 2 3 4 5 6 7 8 9 10 

A: xx yy zz 

↑ 

anfang=3 

Einfügen: anfang ← anfang + 1 

A[anfang] ← NEU 

n ← n + 1 

Entfernen: anfang ← anfang – 1 

n ← n - 1 

Verkettete Speicherung: anfang = 3 frei = 4 

1 yy 2 2 xx nill 3 zz 1 4 nill 

anfang ⇒ 3 zz 

2 yy 

1 xx 


Einfügen: 

Entfernen: 

falls frei = NILL dann 'Meldung', ENDE 

A[frei] ← NEU 

merke ← zeiger[frei] 

zeiger[frei] ← anfang 

anfang ← frei 


n ← n +1 

merke ← zeiger[anfang] 

zeiger[anfang] ← frei 

frei ← anfang 

anfang ← merke 

n ← n - 1 

Stapelanwendungen: 

1) Beispiel für eine rekursive Funktion 

Problem Ackermann Die Ackermann-Funktion A(n,x,y) ist für 

nichtnegative ganze Zahlen n, x, y durch 

⎧ x+1, falls n=0 

⎪ x, falls n=1 und y=0 

⎪ 0, falls n=2 und y=0 

A(n,x,y) = ⎨ 1, falls n=3 und y=0 

⎪ 2, falls n≥4 und y=0 

⎩ A(n-1, A(n,x,y-1), x), falls n≠0 und y≠0 

definiert. 

Beispiel: A(2, 3, 1) = A(1, A(2, 3, 0), 3) 

= A(1, 0, 3) 

= A(0, A(1, 0, 2), 0) 

= A(0, A(0, A(1, 0, 1), 0), 0) 

= A(0, A(0, A(0, A(1, 0, 0), 0), 0), 0) 

= A(0, A(0, A(0, 0, 0), 0), 0) 

= A(0, A(0, 1,0), 0) 

= A(0, 2, 0) 

= x + 1 

= 3 


2) Notationen von arithmetischen Ausdrücken 

INFIX-Notation: 

PRÄFIX-Notation: 

POSTFIX-Notation: 

Operator steht zwischen den Operanden 

(gegebenenfalls Klammerung notwendig !) 

Operator steht vor den Operanden 

Operator steht nach den Operanden 

INFIX PRÄFIX POSTFIX 

A + B +AB AB+ 

A + B * C A+[*BC] 

+A*BC 

A+[BC*] 

ABC*+ 

(A + B) * C [+AB]*C 

*+ABC 

[AB+]*C 

AB+C* 

(A + B) / (C – D) [+AB] / [-CD] 

/+AB-CD 

[AB+] / [CD-] 

AB+CD-/ 

Problem InfToPost 

Umwandlung eines INFIX-Ausdruckes Q in einen 

POSTFIX-Ausdruck P 

Algorithmus InfToPost: 

S1: ‘(‘ --> Stapel und ‘)’ an das Ende von Q anfügen 

S2: durchsuche Q von links nach rechts, bis der Stapel leer ist: 

a) falls OPERAND gefunden wird: --> P 

b) falls ÖFFNENDE KLAMMER gefunden wird: 

--> Stapel 

c) falls OPERATOR a gefunden wird: 

1) solange Operatoren vom Stapel entfernen und 

--> P, wie diese eine höhere oder dieselbe Priorität 

besitzen 

2) a --> Stapel 

d) falls SCHLIEßENDE KLAMMER gefunden wird: 

1) solange Operatoren vom Stapel entfernen und 

--> P, bis öffnende Klammer auftritt 

2) entferne öffnende Klammer aus dem Stapel, füge 

sie nicht zu P hinzu 


Beispiel: Q: A + (B * C - D / E * F * G) * H 

S1: Q: A + (B * C - D / E * F * G) * H) 

S2: 

/ * * 

* - - - 

( ( ( ( * 

+ + + + + 

( ( ( ( ( 

P: ABC*DE/F*G*-H*+ 

Problem WertPostfix 

Ermittlung des Wertes eines POSTFIX- 

Ausdrucks P 

Algorithmus WertPostfix: 

S1: markiere das Ende des Ausdrucks P mit einer Marke z.B. ‘)’ 

S2: durchsuche P von links nach rechts und wiederhole für jede 

Angabe von P bis die Markierung auftritt: 

a) falls OPERAND gefunden wird: --> Stapel 

b) falls OPERATOR a gefunden wird: 

1) entnehme dem Stapel den obersten Knoten 

X und den zweitobersten Knoten Y 

2) berechne Y a X 

3) Ergebnis von 2) --> Stapel 

S3: der Wert des Knotens im Stapel ist der Wert des Ausdrucks P 

Beispiel: P: 5, 6, 2, +, *, 12, 4, /, - 

2 ->X 4 ->X 

6 ->Y Y+X 8 ->X 12 ->Y Y/X 3 ->X 

5 5 ->Y Y*X 40 40 ->Y Y-X 37 


2.3.2 Schlange 

Schlange: 

Lineares Feld, bei dem nur am Anfang Knoten entfernt 

und nur am Ende Knoten eingefügt werden können. 

(FIFO-Prinzip: first in, first out) 

z.B. Warteschlange am Schalter 

Schalter 

1 2 3 4 5 6 

anfang 

ende 

Sequentielle Speicherung (Methoden A, B, C) 

Einfügen: 

A 

'verschieben' 

B 

'von vorne' 

mit Abfrage 

siehe A 

C 

'mit mod- 

Operator' 

siehe A 

(1) falls n=nmax, dann 

'Meldung' ENDE 

(2) falls n=0, dann siehe A siehe A 

anfang←1, 

ende←0 

(3) falls ende=nmax,dann falls 

ende←nmax+1 ende=nmax, 

- anfang dann 

für i←1 ..ende ende←0 

setze 

A[i] 

←A[i+anfang-1] 

anfang←1 

(4) ende←ende+1 siehe A ende← 

(ende mod nmax) 

+ 1 

(5) A[ende] ← NEU siehe A siehe A 

(6) n←n+1 siehe A siehe A 


Entfernen: 

(1) falls n=0, dann 

'Meldung', ENDE 

siehe A 

(2) anfang←anfang+1 falls 

anfang=nmax, 

dann 

anfang←1 

sonst 

anfang← 

anfang+1 

siehe A 

(3) n←n-1 siehe A siehe A 

anfang← 

(anfang mod 

nmax) +1 

2.4 MEHRDIMENSIONALE FELDER 

2.4.1 Zweidimensionale Felder / Matrizen 

a) nichtquadratische Matrizen (n m) 

n: Anzahl Zeilen 

m: Anzahl Spalten 

z.B. A (n = 3, m = 4) a 11 a 12 a 13 a 14 

mit a ij a 21 a 22 a 23 a 24 

i: Zeilenindex a 31 a 32 a 33 a 34 

j: Spaltenindex 

Speicherplatzbedarf: n*m Elemente 

Möglichkeiten bei eindimensionaler Speicherung: 

1) zeilenorientiert: 

a 11 , a 12 , a 13 , a 14 , a 21 , a 22 , a 23 , a 24 , a 31 , a 32 , a 33 , a 34 

2) spaltenorientiert: 

a 11 , a 21 , a 31 , a 12 , a 22 , a 32 , a 13 , a 23 , a 33 , a 14 , a 24 , a 34 


Problem: Welche Adresse IJ besitzt dann z.B. a 32 (a 11 -> Adresse 1) 

zeilenorientiert: IJ = Basisadresse + (i - 1) * m + j –1 

a 32 -> IJ = 10 

spaltenorientiert: IJ = Basisadresse + (j - 1) * n + i – 1 

a 32 -> IJ = 6 

b) quadratische Matrizen (n = m) 

z.B. n = m = 4 a 11 a 12 a 13 a 14 

a 21 a 22 a 23 a 24 

a 31 a 32 a 33 a 34 

a 41 a 42 a 43 a 44 

Speicherplatzbedarf: n x n Elemente 

bei symmetrischen Matrizen mit a ij = a ji (z.B. bei Entfernungsmatrizen) 

sind folgende Speicherungsformen möglich: 

1. Untere Dreiecksmatrix inklusive Hauptdiagonale (i >= j) 

a) zeilenweise 

( i −1) * i 

IJ = Basisadresse + + j −1 

2 

b) spaltenweise IJ= 

Speicherplatzbedarf: 

n * ( n + 1) 

2 

Elemente 

2. Untere Dreiecksmatrix ohne Hauptdiagonale (i > j) 


( i − 2) * ( i −1) 

IJ = Basisadresse + 

+ j −1 

2 

b) spaltenweise 

j * ( j + 1) 

IJ = Basisadresse + ( j −1) * n + i − −1 

2 


n * ( n + 1) 

- n Elemente 

2 


3. Obere Dreiecksmatrix ohne Hauptdiagonale (i < j) 


i * ( i + 1) 

IJ = Basisadresse + ( i −1) * n + j − −1 

2 

b) spaltenweise 

( j − 2) *( j −1) 

IJ = Basisadresse + 

+ i −1 

2 


n * ( n + 1) 

- n Elemente 

2 

2.4.2 Beliebige, mehrdimensionale Felder 

z.B. dreidimensional 

a ijk 

a 113 a 123 a 133 a 143 

a 213 a 223 a 233 a 243 

a 112 a 122 a 132 a 142 

a 212 a 222 a 232 a 242 

a 111 a 121 a 131 a 141 

a 211 a 221 a 231 a 241 

Möglichkeiten der eindimensionalen Speicherung: 

1) spaltenorientiert 

a 111 , a 211 , a 121 , a 221 , a 131 , a 231 , a 141 , a 241 , a 112 , a 212 , a 122 , ..., a 233 , a 143 , a 243 

1. Index wächst am schnellsten, 2. Index am zweitschnellsten, ... 

IJ = Basisadresse + (( ... ((E n *L n-1 +E n-1 ) L n-2 +E n-2 )...+E 3 ) L 2 + E 2 ) L 1 + E 1 

mit 

n: Anzahl Dimensionen 

L i : Obergrenze Dimension i - Untergrenze Dimension i + 1 

(Länge des Feldes in Dimension i; Anzahl der Feldelemente 

in Dimension i) 

E i : K i - Untergrenze Dimension i (K i : gegebener Index in 

Dimension i; Anzahl der Indizes, die vor Index K i in der 

Dimension i 'liegen') 


2) zeilenorientiert 

a 111 ,a 112 , a 113 , a 121 , a 122 , a 123 , ..., a 241 , a 242 , a 243 

letzter Index wächst am schnellsten, zweitletzter Index am 

zweitschnellsten, ... 

IJ = Basisadresse + ( ... ((E 1 * L 2 + E 2 ) L 3 + E 3 ) L 4 + ... + E n-1 ) L n + E n 

Beispiel: A [2 ... 8, -4 ... 1, 6 ... 10] 

L 1 = 8 - 2 + 1 = 7 

L 2 = 1 - (-4) + 1 = 6 

L 3 = 10 - 6 + 1 = 5 

Adresse von A[5, -1, 8] 

E 1 = 5 - 2 = 3 

E 2 = -1 - (-4) = 3 

E 3 = 8 - 6 = 2 

Basisadresse = 1 

IJ = 1 + ((E 1 * L 2 + E 2 ) * L 3 + E 3 ) 

= 1 + ((3 * 6 + 3) * 5 + 2) 

= 1 + 21 * 5 + 2 = 1 + 105 + 2 = 108 


3. KOMPLEXE DATENSTRUKTUREN 

3.1 GRAPHEN - DEFINITIONEN 

Definition1: 

Ein ungerichteter Graph G = (V,E) besteht aus einer Menge von Knoten 

V={1,2,...,n} und Kanten E={e 1 ,e 2 ,...,e m }. Die Anzahl der Knoten wird mit 

n, die Anzahl der Kanten mit m bezeichnet. 

Die einer Kante e zugeordneten Knoten i, j werden Endknoten von e 

genannt. Man schreibt e = (i, j) oder e = (j, i) und sagt, dass die Kante e 

die Knoten i, j "verbindet". Knoten i heißt Nachbar des Knotens j und 

umgekehrt, falls e = (i, j) eine Kante in G ist. 

Ein gerichteter Graph G = [V,E] besteht aus einer Menge von Knoten 

V={1,2,...,n} und Pfeilen E={e 1 ,e 2 ,...,e m }. Die Anzahl der Knoten wird 

wiederum mit n, die Anzahl der Pfeile mit m bezeichnet. Ein gerichteter 

Graph G = [V,E] wird auch Digraph D = [V,E] genannt. 

Ein Graph G = (V,E), der sowohl Pfeile wie auch Kanten enthält, heißt 

gemischter Graph. 

Für einen Pfeil e wird e = [i, j] geschrieben; i heißt Anfangsknoten und j 

Endknoten des Pfeiles e. Man sagt auch, dass der Pfeil e "vom Knoten i 

ausgeht" und "in den Knoten j einmündet". Knoten j wird (unmittelbarer) 

Nachfolger von Knoten i, Knoten i (unmittelbarer) Vorgänger von 

Knoten j genannt. Die Menge aller Nachfolger eines Knotens i wird mit 

S i und die Menge aller Vorgänger eines Knotens i mit P i bezeichnet. 

weitere Definitionen siehe Veranstaltung Operations Research SS 2010 

3.2 DARSTELLUNG VON PROBLEMEN DURCH GRAPHEN 

siehe Veranstaltung Operations Research SS 2010 


3.3 SPEICHERUNG VON GRAPHEN 

Bewerteter Digraph D1: 

2 

2 

e 1 

e 4 

e 5 

3 

e 

2 3 3 

1 

5 

e 1 1 

2 

e 7 

e 8 

e 6 

6 

2 

4 

3 

a) Adjazenzmatrix: A(D1) 

1 2 3 4 5 

1 0 1 1 0 0 

2 0 0 0 1 1 

3 0 0 0 1 1 

4 0 0 0 0 0 

5 0 1 1 0 0 

b) Bewertungsmatrix: C(D1) 

1 2 3 4 5 

1 0 3 2 ∞ ∞ 

2 ∞ 0 ∞ 6 2 

3 ∞ oo 0 2 1 

4 ∞ oo ∞ 0 ∞ 

5 ∞ 3 1 ∞ 0 


c) Vektorform d) Vektorform - pfeilsortiert 

anfk endk c alt neu anfk endk c 

e 1 1 2 3 e 1 e 1 1 2 3 

e 2 1 3 2 e 2 e 2 1 3 2 

e 3 5 2 3 e 4 e 3 2 5 2 

e 4 2 5 2 e 7 e 4 2 4 6 

e 5 5 3 1 e 6 e 5 3 5 1 

e 6 3 5 1 e 8 e 6 3 4 2 

e 7 2 4 6 e 3 e 7 5 2 3 

e 8 3 4 2 e 5 e 8 5 3 1 

Pfeilnummernvektor: 

1 1 

2 3 

3 5 

4 7 

5 7 

6 9 

PN 

Bestimmung der Nachfolger eines Knotens i bei vektororientierter 

Speicherung eines pfeilsortierten Digraphen D 

Algorithmus NACHFOLGER - PN_GEN 

Aufbau des Pfeilnummernvektors PN: 

S1: für k ← 1 .. n führe aus: setze PN[k] ← 0 

setze PN[n+1] ← m+1 

S2: für alle Pfeile e p in der Reihenfolge p ← 1 .. m führe aus: 

falls ein neuer Anfangsknoten i auftritt, setze PN[i] ← p 

S3: Überprüfung auf Senken und isolierte Knoten (alle Knoten i mit 

PN[i]=0 sind Senken oder isolierte Knoten): 

für alle PN[k] in der Reihenfolge k ← n, …, 1 (-1) führe aus: 

falls PN[k]=0, setze PN[k] ← PN[k+1] 

Bestimmung der Nachfolger eines Knoten k: 

für p ← PN[k], ..., PN[k+1] - 1 führe aus : 

der Endknoten des Pfeiles mit Pfeilnummer p ist Nachfolger von k 


Bestimmung der Vorgänger eines Knotens i bei vektororientierter 

Speicherung eines Digraphen D 

Algorithmus VORGÄNGER 

Benutzung folgender ganzzahliger linearer Felder: 

ANF_ZEIGER 

TEMP 

VORGÄNGER 

[1..n] 

[1..n] 

[1..m] 

Vorbereitungsschritt: 

S1: alle Datenknoten der Felder ANF_ZEIGER und VORGÄNGER 

auf Null setzen 

S2: Betrachtung der Endknoten aller Pfeile in der Reihenfolge e1, 

e2, ..., em : 

Fall 1: 

Fall 2: 

Endknoten k tritt zum ersten Male auf: 

sei p die Pfeilnummer des Pfeiles mit Endknoten k ; 

setze ANF_ZEIGER [k] ← TEMP [k] ← p 

Endknoten k tritt nicht erstmalig auf: 

die weiteren Pfeilnummern mit Endknoten k 

werden im Feld VORGÄNGER gespeichert; 

sei p die Pfeilnummer eines solchen Pfeiles, 

setze VORGÄNGER [TEMP [k] ] ← p 

TEMP [k] ← p 

Bestimmung der Vorgänger eines Knotens k: 

p ← ANF_ZEIGER [k] 

solange p 0 führe aus : 

der Anfangsknoten des Pfeiles mit Pfeilnummer p ist 

Vorgänger von k 

p ← VORGÄNGER [p] 


Speicherform 

Anzahl 

Speicherelemente 

Speicherbedarf 

Beispiel 

vollständiger 

Digraph 

n=100 

m=n*(n-1) 

= 9900 

p=1.0 

Beispiel 

Straßennetz 

SL FL 

n=800 

m=2800 

Beispiel 

Straßennetz 

BW 

n=8500 

m=25000 

p=0.004 p=0.0004 

Bewertungsmatrix 

C(D) n*n 10.000 640.000 72.250.000 

pfeilorientiert: 

Anfangsknotenvekt. 

Endknotenvektor 

Bewertungsvektor 

pfeilorientiert und 

pfeilsortiert: 

Endknotenvektor 

Bewertungsvektor 

Pfeilnummernvektor 

m 

m 

m 

∑=3*m 

m 

m 

n+1 

∑=2*m 

+n+1 

29.700 8.400 75.000 

19.901 6.401 58.501 

n: Anzahl Knoten SL FL: Landkreis 

m: Anzahl Pfeile Schleswig-Flensburg 

p: Pfeildichte: m/(n*(n-1)) BW: Baden-Württemberg 


4. GRAPHENALGORITHMEN 

4.1 KÜRZESTE WEGE ALGORITHMEN 

3 Problemstellungen: 

a) Kürzester Weg von Startknoten a nach Zielknoten b 

b) Kürzester Weg von Startknoten a zu allen anderen Knoten 

c) Kürzester Weg von jedem Knoten zu allen anderen 

(Entfernungsmatrix) 

Algorithmen: a) Nicholson 

b) Dijkstra, Ford, Desopo, Bellmann 

c) Tripel, Dantzig 

4.1.1 Dijkstra-Algorithmus 

2 1 4 

2 

4 

2 

7 

1 7 3 3 5 

1 

2 

1 

1 

6 3 7 

Startknoten a=1 

Schritt 0: R = {1} DIST(1) = 0 PRE(1) = 0 

DIST(i) = oo PRE(i) = 0 (i=2,3,4,5,6,7) 

Schritt 1: i = 1 j = 2, 3 

Schritt 2: DIST (2) > DIST (1) + C (1,2) ==> DIST (2) = DIST (1) + C (1,2) 

∞ > 0 + 2 = 2 


R = {1, 2, 3} DIST (2) < DIST (3) ==> i = 2, j = 3, 4 

R = {2, 3, 4} etc. ... 

...... 

...... 

Folgende Werte ergeben sich: 

Knoten KW_DIST PRE 

1 0 0 

2 2 1 

3 5 4 

4 3 2 

5 8 3 

6 7 3 

7 9 5 

==> Kürzester Weg von 1 nach 7: 1 --> 2 --> 4 --> 3 --> 5 --> 7 

Wurzelbaum mit Wurzel Knoten 1 (jeder Knoten mit Ausnahme der 

Wurzel hat nur einen Vorgänger): 

Verlauf des kürzesten Weges von Knoten 1 zu allen anderen Knoten 

2 1 4 

2 

2 

1 3 3 5 

2 

1 

6 7 


Bestimmung eines kürzesten Weges (Länge und Verlauf) von einem 

Startknoten a zu allen anderen Knoten in einem bewerteten 

Digraphen D = [V,E,c] mit dem 

Algorithmus von DIJKSTRA 

Eingabe: 

a: Startknoten 

c[i,j]: 

Bewertung (Länge) des Pfeiles von i nach j 

Ausgabe: 

kw_dist[i]: 

pre[i]: 

Voraussetzung: 

kürzeste Wegelänge von Startknoten a nach i 

Vorgänger von i auf dem kürzesten Weg von Startknoten 

a nach i 

D darf keine negativen Bewertungen enthalten 

S1: Initialisierung: 

Markiere Startknoten a: 

Setze für Knoten a: 

kw_dist[a] ← 0, 

pre[a] ← 0. 

Setze für alle anderen Knoten i (∀i ≠a): 

kw_dist[i] ← ∞, 

pre[i] ← 0. 

sei R die Menge der markierten 

Knoten, dann gilt a ∈ R (R={a}). 

S2: Falls ein oder mehrere Knoten markiert sind (R ≠ ∅): 

wähle einen Knoten aus mit MIN kw_dist[j], 

j ∈ R 

dieser Knoten sei i; 

sonst (R = ∅): ENDE Dijkstra-Algorithmus. 

S3: Für alle Nachfolger j ∈ S i , die noch nicht aus der Markierung 

entfernt worden sind, führe aus: 

falls kw_dist[i] + c[i,j] < kw_dist[j]: 

(1) setze kw_dist[j] ← kw_dist[i] + c[i,j], 

(2) setze pre[j] ← i, 

(3) markiere j (j ∈ R). 

Entferne die Markierung bei i (i ∉ R). 

Gehe zu S2. 


4.1.2 Ford-Algorithmus 

R = {1 2 3 4 5 6 3 7 5 6 7} Auswahlkriterium in S2: 

der Knoten, der am längsten in R ist 

Knoten KW_DIST PRE 

1 0 0 

2 oo 2 0 1 

3 oo 7 6 5 0 1 2 4 

4 oo 3 0 2 

5 oo 9 8 0 3 

6 oo 8 7 0 3 

7 oo 10 9 0 5 

Beispiel mit negativer Bewertung: 

1 

10 

2 

2 

2 

4 

3 

-2 

4 

3 

Dijkstra a=1 

Knoten 1 2 3 4 

PRE 0 0 1 0 2 0 1 2 

KW_DIST 0 oo 2 oo 5 oo 10 4 

R = {1, 2, 4} i = 1 

R = {2, 4, 3} i = 2 

R = {4, 3} i = 4 

R = {3} i = 3 

R = 0 

Ford a=1 

Knoten 1 2 3 4 

PRE 0 0 1 0 2 0 1 2 3 

KW_DIST 0 oo 2 oo 5 oo 10 4 3 

R = {1, 2, 4, 3, 4, 4} i = 1, i = 2, i = 4, i = 3, i = 4, i = 4 

R = 0 


Bestimmung eines kürzesten Weges (Länge und Verlauf) von einem 

Startknoten a zu allen anderen Knoten in einem bewerteten 

Digraphen D = [V,E,c] mit dem 

Algorithmus von FORD 

Eingabe: 

a: Startknoten 

c[i,j]: 

Bewertung (Länge) des Pfeiles von i nach j 

Ausgabe: 

kw_dist[i]: 

pre[i]: 


kürzeste Wegelänge von Startknoten a nach i 

Vorgänger von i auf dem kürzesten Weg von Startknoten 

a nach i 

D darf keine negativen Zyklen enthalten 

S1: Initialisierung: 

Markiere Startknoten a: 

Setze für Knoten a: 

kw_dist[a] ← 0, 

pre[a] ← 0. 

Setze für alle anderen Knoten i (∀i ≠a): 

kw_dist[i] ← ∞, 

pre[i] ← 0. 

sei R die Menge der markierten 

Knoten, dann gilt a ∈ R (R={a}). 

S2: Falls ein oder mehrere Knoten markiert sind (R ≠ ∅): 

wähle den Knoten aus, der am längsten (kürzesten) in R 

enthalten ist. 

dieser Knoten sei i; 

sonst (R = ∅): ENDE Ford-Algorithmus. 

S3: Für alle Nachfolger j ∈ S i führe aus: 

falls kw_dist[i] + c[i,j] < kw_dist[j]: 

(1) setze kw_dist[j] ← kw_dist[i] + c[i,j], 

(2) setze pre[j] ← i, 

(3) markiere j (j ∈ R). 

Entferne die Markierung bei i (i ∉ R). 

Gehe zu S2. 


4.1.3 Tripel-Algorithmus 

P(D) = Vorgängermatrix 

C(D) = Bewertungsmatrix 

D = 

1 

1 2 

0 

3 

3 

1 

C(D) 

2 1 4 

5 

P(D) 

1 2 3 4 1 2 3 4 

1 0 1 0 oo 1 1 1 1 0 

2 2 0 oo 5 2 2 2 0 2 

3 oo 3 0 1 3 0 3 3 3 

4 oo 1 oo 0 4 0 4 0 4 

Z = 1: 

Die Hauptdiagonale sowie Spalte 1 und Zeile 1 lassen sich nicht 

verbessern. Eine Verbesserungsmöglichkeit besteht nur bei den anderen 

Elementen. Tatsächlich trifft dies nur in (Zeile 2, Spalte 3) zu 

(Verbesserungen sind 'dunkel' gekennzeichnet). 

C(D) 

P(D) 

1 2 3 4 1 2 3 4 

1 0 1 0 oo 1 1 1 1 0 

2 2 0 2 5 2 2 2 1 2 

3 oo 3 0 1 3 0 3 3 3 

4 oo 1 oo 0 4 0 4 0 4 

Z = 2: C(D) P(D) 

1 2 3 4 1 2 3 4 

1 0 1 0 6 1 1 1 1 2 

2 2 0 2 5 2 2 2 1 2 

3 5 3 0 1 3 2 3 3 3 

4 3 1 3 0 4 2 4 1 4 

Z = 3: C(D) P(D) 

1 2 3 4 1 2 3 4 

1 0 1 0 1 1 1 1 1 3 

2 2 0 2 3 2 2 2 1 3 

3 5 3 0 1 3 2 3 3 3 

4 3 1 3 0 4 2 4 1 4 


Z = 4: C(D) P(D) 

1 2 3 4 1 2 3 4 

1 0 1 0 1 1 1 1 1 3 

2 2 0 2 3 2 2 2 1 3 

3 4 2 0 1 3 2 4 3 3 

4 3 1 3 0 4 2 4 1 4 

aus C(D) -->Entfernungsmatrix 

K(D) 

Bestimmung eines kürzesten Weges von jedem Knoten zu allen 

anderen Knoten eines bewerteten Digraphen D = [V,E,c], d,h. 

Erstellung der Entfernungsmatrix K(D) mit dem 

TRIPEL-Algorithmus 

Eingabe: C(D): Bewertungsmatrix 

P(D): Vorgängermatrix 

Ausgabe: K(D): Entfernungsmatrix (entstanden aus C(D)) 

P(D): pij: Vorgänger des Knotens j auf dem 

kürzesten Weg von i nach j 


D darf keine negativen Zyklen enthalten 

Schritte 1,...,n: 

Berechne im z-ten (z←1,..,n) Schritt für alle 

Elemente cij, die nicht Element der z-ten Zeile, 

der z-ten Spalte oder der Hauptdiagonalen sind: 

neu alt alt alt 

cij ← MIN (cij , ciz + czj ) 

sowie 

⎧ alt neu alt 

neu ⎪ pzj , falls cij < cij 

pij ← ⎨ 

⎪ alt 

⎩ pij , sonst 

nach n Schritten: ENDE Tripel-Algorithmus 


4.1.4 Bellmann Algorithmus – Typ A 

2 

6 

1 

4 

4 

1 

1 

6 

3 

5 

1 1 6 1 5 

a = 2 

Knoten 1 2 3 4 5 6 

PRE 0 2 4 3 0 0 4 0 2 0 3 6 0 1 1 1 

KW_DIST oo 6 5 3 0 oo 2 oo 1 oo 7 5 oo 7 6 4 

4.1.5 Topologisches Sortieren – Bellmann Algorithmus – Typ B 

1 

2 

6 

1 

4 

2 

4 

1 

1 

6 

3 

5 

3 

4 

5 

1 1 6 1 5 

6 

i δ - i 

L R = {1, 2 ,3 ,4 ,5 ,6} 

1 3 2 1 0 4 k = 1, 2, 3, 4, 5, 6 i = 2, 4, 3, 1, 6, 5 

2 0 1 

3 1 0 3 

4 1 0 2 

5 2 1 0 6 

6 2 1 0 5 

1 

6 

1 

4 

2 

1 

1 

6 

3 

5 

4 1 5 1 6 

a = 1 

Knoten 1 2 3 4 5 6 

PRE 0 0 1 0 2 0 3 0 4 0 5 

KW_DIST 0 oo 1 oo 2 oo 3 oo 4 oo 5 


Bestimmung eines kürzesten Weges von einem Startknoten a zu allen 

anderen Knoten eines bewerteten Digraphen D = [V,E,c] mit dem 

Algorithmus von BELLMANN 

Eingabe: a : Startknoten 

c[i,j] : Bewertung des Pfeiles [i,j] 

Ausgabe: kw_dist[i] : Länge des kürzesten Weges von 

Startknoten a nach i 

pre[i] : Vorgänger des Knotens i auf dem 

kürzesten Weg von 

Startknoten a nach i 

VERSION a : 

D darf keine negativen Zyklen enthalten. 

Schritt 0: kw_dist[a] ← 0. 

kw_dist[i] ← ∞, ∀ i ≠ a. 

pre[i] ← 0 , ∀ i. 

Schritt 1: Durchführung für ∀ i ε V\{a} : 

falls kw_dist[i] > kw_dist[j]+c[j,i], (j ε P(i)) 

setze kw_dist[i] ← kw_dist[j] + c[j,i], 

setze pre[i] ← j 

Schritt 2: 

Wiederholung von Schritt 1, bis kein kw_dist- 

Wert mehr verbessert werden kann. 

VERSION b : 

Schritt 0 : 

Schritt 1 : 

D ist topologisch sortiert. 

siehe Version a 

für i ← a+1,...,n führe aus: 

falls kw_dist[i] > kw_dist[j]+c[j,i], (j ε P(i)) 

setze kw_dist[i] ← kw_dist[j] + c[j,i], 

setze pre[i] ← j 


Topologische Sortierung 

eines zyklenfreien Digraphen D = [V,E] . 

Algorithmus TOPSORT 

Eingabe: 

Ausgabe: 

D = [V,E] 

L(i): 'neue' Knotennummer des Knotens i 

Schritt 0: 

R ← {1,...,n} = V 

k ← 1 

(zu vergebende aktuelle Knotennummer) 

Bestimme δ- j ∀ j ∈ R 

Schritt 1: Suche ein i ∈ R mit δ- i = 0 

Schritt 2: k ← k + 1 

R ← R \ { i } 

Existiert kein solches i -> ENDE des Algorithmus: 

D ist nicht zyklenfrei 

L(i) ← k 

Falls k = n-> ENDE des Algorithmus: 

D ist topologisch sortiert 

Bestimme für ∀ j ∈ Si: δ- j ← δ- j - 1 

Gehe zu Schritt 1 


4.2 MINIMALGERÜSTE 

Problemstellung: 

Gegeben ist der zusammenhängende Graph G = (V,E,c). Gesucht ist ein 

Minimalgerüst G' = (V,E',c') zu G. 

Bestimmung eines Minimalgerüstes G' zu einem 

zusammenhängenden, bewerteten Graphen G = (V, E, c) 

Algorithmus MINGERÜST 

S1: Der Graph G' besteht aus der Knotenmenge V und der 

Kantenmenge E' = ∅ 

S2: Wähle die Kante in G mit der geringsten Bewertung aus und füge 

sie zu G' hinzu, wenn dadurch kein Zyklus in G' entsteht. 

Existiert keine Kante in G mehr -> ENDE 

S3: Entferne die ausgewählte Kante aus G. 

S4: Gehe zu S2. 


5. BÄUME 

Baum: - zyklenfreier Digraph 

- jeder Knoten (Ausnahme Wurzel) hat genau einen Vorgänger 

3 

1 2 4 

Wurzel 

innerer 

Knoten 

5 

Blatt (Endknoten) 

5.1 BINÄRBÄUME 

Zusatzbedingung: jeder Knoten hat maximal 2 Nachfolger 

A 

B 

E 

C D F 

linker Teilbaum 

Endknoten 

G 

H 

Darstellung von arithmetischen Ausdrücken: 

Operatoren = innere Knoten 

Operanden = Teilbäume oder Endknoten 

z.B. (a - b) / ((c * d) + e) f - (g - h) f - g - h 

/ 

- 

- 

- 

+ 

f - 

- 

h 

a 

b 

* 

e 

g 

h 

f 

g 

c 

d 


Speicherung von binären Bäumen: 

Verkettet 

Zeiger LT 

INFO 

A 

Zeiger RT 

B 

NIL 

C 

NIL 

D 

E 

NIL NIL NIL NIL NIL 

F 

Sequentiell 

45 

22 

77 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 

11 

30 

90 

A 

45 22 77 11 30 90 15 25 99 

15 25 

99 

Wurzel --> 1. Element -> A[ 1 ] z.B. 90 -> RN von 77 

Linker Nachfolger von A[ I ] -> A[ 2 * I ] ==> 2 * 3 + 1 = 7 

Rechter Nachfolger von A[ I ] -> A[ 2 * I + 1 ] 

Vorgänger von A[ I ] -> A[ I / 2 ] 

max. Anzahl Speicherelemente: 2 t - 1 

(t: 'Tiefe' des Baumes) 

Durchsuchen von binären Bäumen 

A 

B 

C 

HR: 

A B D E F C G H I L K 

D 

E 

G 

H 

SR: 

D B F E A G C L I H K 

NR: 

D F E B G L I K H C A 

F 

I 

K 

LT / RT = Linker / Rechter Teilbaum 

L 


1. Hauptreihenfolge / HR (Präordnung) S1: Bearbeite Wurzel 

S2: Bearbeite LT in HR 

(Rekursion) 

S3: Bearbeite RT in HR 

2. Symmetrische Reihenfolge / SR (Inordnung): 

S1: Bearbeite LT in SR 

S2: Bearbeite Wurzel 

S3: Bearbeite RT in SR 

3. Nebenreihenfolge / NR (Postordnung): 

S1: Bearbeite LT in NR 

S2: Bearbeite RT in NR 

S3: Bearbeite Wurzel 

5.2 BINÄRE SUCHBÄUME 

Ein binärer Suchbaum liegt dann vor, wenn gilt: 

A) alle Werte der Knoten der linken Nachfolgermenge (linker Teilbaum) 

eines Knotens i sind ≤ dem Wert des Knotens i und 

B) alle Werte der Knoten der rechten Nachfolgermenge (rechter Teilbaum) 

eines Knotens i sind ≥ dem Wert des Knotens i 

30 

20 60 

10 40 70 

50 

55 

51 


Änderungen in binären Suchbäumen 

a) Knoten i einfügen: i als Endknoten (Blatt) unter Berücksichtigung 

der Bedingungen A) und B) ‘anhängen’ 

b) Knoten i entfernen: 

b1) i hat keinen Nachfolger: i ‘abhängen’ 

b2) i hat genau 1 Nachfolger: i ‘überbrücken’, d.h. 

entsprechenden Zeigerinhalt des Vorgängers von i durch 

die Adresse des Nachfolgers von i ersetzen 

b3) i hat 2 Nachfolger: 

i ersetzen durch den Knoten mit dem größten Wert im 

linken Teilbaum von i oder durch den Knoten mit dem 

kleinsten Wert im rechten Teilbaum von i. Das Entfernen 

des Ersatzknotens geschieht nach b1) bzw. b2) 


5.3 HEAPSORT 

HEAP: Binärer Baum mit der Eigenschaft: 

Wert des Knotens i >= Wert jedes Nachfolgerknotens von i 

(-> der größte Wert steht in der Wurzel) 

SORTIERPROBLEM: 

GEGEBEN: lineares Feld A mit n Knoten, sequentiell gespeichert 

GESUCHT: absteigend sortierte Reihenfolge der Werte von A 

absteigende Sortierung eines linearen, sequentiell gespeicherten 

Feldes A 

Algorithmus HEAPSORT 

S1: der Heap besteht aus A[1] 

S2: für i← 2,...,n führe aus 

füge Knoten A[i] so in den bisherigen Heap ein, dass die 

Heapeigenschaft erhalten bleibt 

(-> Feld A besitzt jetzt die Heapeigenschaft) 

S3: a) in der Wurzel A[1] steht das größte Element. Gebe den 

Wert aus. 

b) entferne die Wurzel A[1] aus dem Feld A 

c) füge als Ersatzknoten den letzten Knoten von A in die Wurzel 

ein; 

falls kein Knoten von A mehr vorhanden ist -> ENDE: 

die ausgegeben Werte stellen die sortierte Reihenfolge dar. 

d) lasse diesen Knoten so absinken, dass die Heapeigenschaft 

wiederhergestellt ist: 

Vergleich mit den Nachfolgern; gegebenenfalls Tausch mit 

dem größten Nachfolger 

e) wiederhole S3 


Beispiel Heapsort: 

1 2 3 4 5 6 7 8 

A: 44 30 50 22 60 55 77 55 

1 2 3 4 5 6 7 8 

S1: 44 

S2: 

1 2 3 4 5 6 7 8 

i=2: 44 30 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

i=3: 44 30 50 50 30 44 

1 2 3 4 5 6 7 8 

i=4: 50 30 44 22 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

i=5: 50 30 44 22 60 50 60 44 22 30 

1 2 3 4 5 6 7 8 

60 50 44 22 30 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

i=6: 60 50 44 22 30 55 60 50 55 22 30 44 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

i=7: 60 50 55 22 30 44 77 60 50 77 22 30 44 55 

1 2 3 4 5 6 7 8 

77 50 60 22 30 44 55 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

i=8: 77 50 60 22 30 44 55 55 77 50 60 55 30 44 55 22 

1 2 3 4 5 6 7 8 

77 55 60 50 30 44 55 22 


S3: 

1 2 3 4 5 6 7 8 

77 55 60 50 30 44 55 22 

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

77

6. SPEZIELLE ALGORITHMEN 

UND 

PRAKTISCHE ANWENDUNGSBEISPIELE 

6.1 Kalender-Algorithmen 

6.1.1 Bestimmung des Wochentages eines Datums 

Algorithmus BASISTAG 

S1: der 01.01.1900 war ein Montag. Zu jedem beliebigen späteren 

Datum kann dann der Wochentag berechnet werden. 

S2: für jedes folgende, volle Jahr nach dem 01.01.1900 verschiebt sich 

der Wochentag um 1 Tag, in Schaltjahren um 2 Tage. 

S3: für das angebrochene Jahr sind die bereits vergangenen Tage zu 

berücksichtigen. Der Wochentag verschiebt sich entsprechend. 

Anmerkung: Schaltjahre sind die Jahre, die ohne Rest durch 4 teilbar 

sind, jedoch nicht die vollen Jahrhunderte, bei denen die 

Division durch 400 ohne Rest nicht möglich ist. 

Algorithmus ZELLER (1877) 

Die Wochentagsnumerierung w 

(w=0: Sa, w=1: So, w=2: Mo, ..., w=6: Fr) kann wie folgt berechnet 

werden: 

S1: es seien t, m und j das Tages-, Monats- bzw. Jahresdatum 

S2: falls m

6.1.2 Bestimmung des Ostersonntag: 

(und damit aller beweglichen Feiertage für ein bestimmtes 

Jahr) 

Wann ist Ostersonntag 

Das Datum des Ostersonntag für jedes Jahr des 21. Jahrhunderts (2000- 

2099) kann wie folgt mit der Gauss'schen Regel zur Berechnung des 

Osterdatums ermittelt werden. Sie lautet: 

Algorithmus Ostersonntag 

Man dividiere die Jahreszahl 

durch 19 und nenne den Rest a, 

durch 4 und nenne den Rest b, 

durch 7 und nenne den Rest c. 

Die Division "(19a + 24) durch 30" ergebe den Rest d, 

die Division "(2b+4c+6d+5) durch 7" ergebe den Rest e. 

Der Ostersonntag liegt dann (d+e) Tage nach dem 22. März. Zu beachten 

sind die beiden Sonderfälle (Beschluss des Konzils von Nicäa (325)) : 

statt des 26. Aprils wird immer der 19. April gewählt; statt des 25. Aprils 

wird immer der 18. April gewählt, falls d=28 und a>10 gilt. 


6.2 Erzeugung aller Permutationen (ohne Wiederholung) 

Gegeben sind n Elemente. Jede Anordnung der n Elemente heißt 

Permutation dieser Elemente. Sind alle Elemente verschiedenartig, so 

handelt es sich um Permutationen ohne Wiederholung. Sind nicht alle 

Elemente verschiedenartig, so spricht man von Permutationen mit 

Wiederholung. 

Anzahl der Permutationen ohne Wiederholung von n Elementen: 

n 

Π i = 1 * 2 * .... * (n-1) * n = n! 

i=1 

n! wird 'n-Fakultät' genannt. Es gilt 0! = 1. 

Beispiel: 

alle möglichen Permutationen (alle möglichen Anordnungen) der Zahlen 

1 2 3 (n=3): 1 2 3, 1 3 2, 2 1 3, 2 3 1, 3 1 2, 3 2 1 

Anzahl der Permutationen: n! = 3! = 1*2*3 = 6 

Bestimmung aller möglichen Permutationen (ohne Wiederholung) 

der Zahlen 1, ... , n 

Algorithmus PERMUTAT (rekursiv) 

Anfangswerte: info[1], ..., info[n] ← 0 

Aufruf: permutat (nr) mit nr ← 1 

Ausgabe: alle Permutationen werden im array info 

nacheinander generiert und ausgegeben (Zeile 6) 

permutat (nr) 

für i ← 1, …, n führe aus 

falls info[i] = 0 dann 

info[i] ← nr 

falls nr = n 

info[i] ← 0 

dann 

gebe info[1], …, info[n] aus 

// Ausgabe 1 Permutation 

andernfalls permutat (nr+1) 


Aufgabe 1: 

Erstellen Sie ein C#-Programm (Konsolenanwendung), das 

a) eine n*n Matrix A (3

c) eine Methode GGT_2b wie b) jedoch rekursiv 

d) eine Methode GGT_2c unter Benutzung des Algorithmus GGT 2 

(Euklidische Methode mit MOD-Operator) 

e) eine Methode GGT_2d wie d) jedoch rekursiv 

Benutzen Sie als Testdaten z.B. GGT(31, 2.134.556) = 1, GGT(4.565.467, 

467.456.655) = 1, GGT(461.952, 116.298) = 18, GGT(31,103.333.323) = 31. 

Aufgabe 4: 

Erstellen Sie ein C#-Programm zum Problem MSP (Maximum Subarray 

Problem): 

a) Generierung eines Arrays X mit 1

Übung 2: 

In der folgenden Tabelle sind Rechenzeiten in Sekunden für verschiedene 

Algorithmen in Abhängigkeit von der Problemgröße n eingetragen. 

Vervollständigen Sie diese Tabelle. 

Algorithmus O( ) n = 100 n = 200 n = 1000 

Alg. A O(1) 13,5 

Alg. B O(n) 5 

Alg. C O(n 2 ) 8 

Alg. D O(n 3 ) 1000 

Aufgabe 5: 

Erstellen Sie ein C#-Programm zum Problem PRIM. Es sollen alle 

Primzahlen aus dem Zahlenbereich [1, ... ,n] und ihre Anzahl bestimmt 

werden. Die Primzahlen sollen in aufsteigender Reihenfolge gespeichert 

und ausgegeben werden. n ist einzulesen (1

Aufgabe 7: 

Erstellen Sie ein C#-Programm zu Operationen in sequentiell 

gespeicherten linearen Feldern. Zur Durchführung der Operationen soll 

kein weiteres Array benutzt werden. Besondere Beachtung sollen die 

'Sonderfälle' finden : 

- es existieren keine Datenknoten, d.h. n=0 

- es existiert genau ein Datenknoten, d.h. n=1 

- es gilt n=nmax 

a) als Testdaten sollen n (1

Aufgabe 8: 

Wie Aufgabe 7, jedoch bei verkettet gespeicherten linearen Feldern. 

a) als Testdaten sollen n (1

Aufgabe 10 (Josephusproblem): 

Das Josephusproblem kann wie folgt beschrieben werden: 

n Personen P 1 ,...,P n stehen im Kreise. Es wird 'durchgezählt', bei der 

Startperson beginnend. Die m-te Person soll jeweils aus dem Kreis 

ausscheiden. Es wird solange 'durchgezählt', bis keine Person mehr im 

Kreise vorhanden ist. 

Beispiel: 

n=14, m=2, Startperson=1 

P3 

P4 

P5 

P6 

P2 

P1 

P14 

P7 

P9 

P8 

P13 

P12 

P11 

P10 

Die Reihenfolge, in der die Personen aus dem Kreise ausscheiden, lautet: 

2, 4, 6, 8, 10, 12, 14, 3, 7, 11, 1, 9, 5 und schließlich 13. 

Erstellen Sie ein C#-Programm, das das Josephusproblem simuliert. n, m 

und die Nummer der Startperson sind einzulesen. Die jeweils 

ausscheidende Person, insbesondere die zuletzt ausscheidende, ist auf 

dem Bildschirm auszugeben. Zur Simulation soll ein kreisförmig 

verkettetes Feld ohne freie Knoten generiert werden. Die Personen P 1 , ..., 

P n können durch die Zahlen 1, ..., n in den Datenknoten dargestellt 

werden. Die logische Reihenfolge soll dabei der physikalischen 

Speicherreihenfolge entsprechen: 

z.B. n = 4 ANFANG = 1 

1 P 1 2 2 P 2 3 3 P 3 4 4 P 4 1 


Aufgabe 11 (Ackermannfunktion): 

a) Erstellen Sie eine rekursive C#-Methode, die den Wert der 

Ackermann-Funktion für (n,x,y) berechnet. 

b) Erstellen Sie eine nichtrekursive, d.h. iterative C#-Methode, die den 

Wert der Ackermann-Funktion für (n,x,y) berechnet. Die 

Berechnung rekursiver Funktionen kann mit Hilfe eines Stapels geschehen. 

Bei der Berechnung der Ackermann-Funktion kann dabei 

wie folgt vorgegangen werden: 

S1: der Stapel besteht aus dem Knoten mit den Werten (n,x,y), 

S2: falls n=0 oder y=0 

dann setze t ← A(n,x,y), 

entferne den obersten Knoten vom Stapel, 

falls Stapel leer 

dann: ENDE: t ist der gesuchte Wert, 

andernfalls: ersetze den Wert des obersten 

Knotens (n,x,y) durch (n-1,t,x) , 

andernfalls (falls n≠0 und y≠0) führe aus: 

füge neuen Knoten mit dem Wert (n,x,y-1) zum Stapel 

hinzu, 

S3: wiederhole S2. 

Beispiel A(2,3,1): 

(1,0,0) t←0 

(1,0,1) (0,0,0) t←1 

(2,3,0) t←0 (1,0,2) (1,0,2) (0,1,0) t←2 

(2,3,1) (1,0,3) (1,0,3) (1,0,3) (0,2,0) t←3 

Anmerkung zur Ergebniskontrolle: 

es gilt für die Ackermannfunktion : 

A(0, x, y) = x + 1 

A(1, x, y) = x + y 

A(2, x, y) = x * y 

A(3, x, y) = x y 


Aufgabe 12 (Infix to Postfix): 

Erstellen Sie ein C#-Programm, das einen INFIX-Ausdruck Q mit 

einstelligen Operanden und den Operatoren +, -, *, / in einen POSTFIX- 

Ausdruck P mit Hilfe des Algorithmus INFTOPOST umwandelt. 

Hinweis: vereinbaren Sie Q,P vom Typ string, den Stapel als ein array 

vom Typ char []. Erstellen Sie dabei Methoden für das Einfügen in den 

bzw. Entfernen aus dem Stapel. 

Aufgabe 13 (Wert Postfix-Ausdruck): 

Erstellen Sie ein C#-Programm, das den Wert eines POSTFIX-Ausdrucks 

P mit Hilfe des Algorithmus WERTPOSTFIX berechnet. Der Stapel ist als 

ein array vom Typ double [], P vom Typ string, zu vereinbaren. P enthält 

nur einstellige Operanden und die Operatoren +, -, *, / . 

Aufgabe 14: 

Erstellen Sie ein C#-Programm zu folgendem Problem: 

zu simulieren ist das Verhalten einer Kundenwarteschlange an einem 

Bedienungsschalter. n ist die Anzahl der Kunden in der Warteschlange 

bei der Ausgangssituation. n ist einzulesen. Die Kunden sind durch ihre 

Kundennummer gekennzeichnet. Die Kundennummern A[i] 

(1

Aufgabe 15: 

Gegeben ist folgende symmetrische Entfernungstabelle (Angaben in km): 

Berlin Hamburg Frankfurt München 

Berlin 0 294 555 589 

Hamburg 0 495 782 

Frankfurt 0 460 

München 0 

Erstellen Sie ein C#-Programm, das 

a) die Informationen der Entfernungstabelle einliest und mit 

minimalem Speicheraufwand speichert, 

b) eine Erweiterung der Tabelle um: 

Flensburg --> Berlin 450 

Flensburg --> Hamburg 161 

Flensburg --> Frankfurt 656 

Flensburg --> München 943 ermöglicht, 

c) die Entfernungstabelle ausgibt, 

d) eine Abfrage der Entfernung von ... nach ... ermöglicht. 

Aufgabe 16: 

Gegeben sind die beiden mehrdimensionalen Felder 

A [-2..2, 2..22] 

B [1990..2010, -5..5, -10..5] 

Erstellen Sie ein C#-Programm, das 

a) die Anzahl der Feldelemente von A und B berechnet und ausgibt. 

(die Anzahl der Dimensionen n sowie die Unter- und Obergrenzen 

der einzelnen Dimensionen sind einzulesen) 

b) die Speicheradressen bei spalten- und zeilenweiser eindimensionaler 

Speicherung für ein Element a[i,j] bzw. b[i,j,k] berechnet 

und ausgibt. i,j bzw. i,j,k und die Basisadresse sind einzulesen. 


Aufgabe 17: 

Gegeben ist ein bewerteter Digraph D2 = [V,E,c] mit V = {1,2,...,7} und E 

= e1,e2,...,e12} (siehe Datei a17_d2.net ): 

2 

e6 

1 

4 

1 

e1 

2 

e2 

7 

4 

e4 

3 

e10 

2 

e7 

3 

7 

5 

e11 

e3 

1 

2 

e5 

e8 

1 

1 

e12 

6 

3 

e9 

7 

Erstellen Sie ein C#-Programm: 

a) Speichern Sie den Digraphen D2 in einer Bewertungsmatrix C(D) 

und geben Sie die Bewertungsmatrix C(D) aus. 

b) Speichern Sie den Digraphen D2 in Vektorform (pfeilsortiert) und 

geben Sie die einzelnen Vektoren aus. 

c) Bestimmen Sie die Nachfolger z.B. der Knoten 1,6,7 in beiden Speicherungsformen. 

d) Bestimmen Sie die Vorgänger z.B. der Knoten 1,3,5 in beiden Speicherungsformen. 

e) Führen Sie die Aufgaben a) - d) ebenfalls für den folgenden Digraphen 

D3 durch (siehe Datei a17_d3.net ) 

1 4 

2 e2 

3 

e3 

3 

1 

4 

2 

e1 e4 

5 


Anmerkungen: 

1) Verwenden Sie auch zukünftig folgende Direktiven, Konstanten, 

Datentypen und Variablen : 

using AD_Bibliothek 

// Zeitmessung, Sortierung, Einlesen … 

const int nmax = 8600; // maximale Anzahl der Konten n 

const int nmax_plus_1 = nmax + 1; 

const int mmax = 25000; // maximale Anzahl der Pfeile m 

const int unendlich = 999999; 

int n; // Anzahl Knoten aktueller Digraph 

int m; // Anzahl Pfeile aktueller Digraph 

int[,] c = new int [nmax+1,nmax+1]; // Bewertungsmatrix 

int[] anfknoten = new int [mmax+1]; //Anfangsknotennumernvektor 

int[] endknoten = new int [mmax+1];// Endknotennummernvektor 

int[] cbewertung = new int [mmax+1];// Bewertungsvektor 

int[] pn = new int [nmax_plus_1+1]; // Pfeilnummernvektor 

int[] anf_zeiger = new int [nmax+1]; // siehe Alg. VORGAENGER 

int[] temp = new int [nmax+1]; // siehe Alg. VORGAENGER 

int[] vorgaenger = new int [mmax+1];// siehe Alg. VORGAENGER 

string datei_name; 

// z.B. a17_d2.net 

2) Verwenden Sie zum Einlesen der Digraphen (*.net-Dateien) die 

Einlesemethode LesenDatei.lesenNetDatei (datei_name, anfknoten, 

endknoten, cbewertung, ref n, ref m) (siehe AD_Bibliothek). 

3) Verwenden Sie zur Pfeilsortierung der Digraphen die Sortiermethode 

Quickersort.sort (anfknoten, endknoten, cbewertung, l, m) 

(siehe AD_Bibliothek) . Der Sortierschlüssel ist der 1. Parameter 

(hier: anfknoten). Sortiert wird von l, …, m. Die Elemente der 

Arrays endknoten und cbewertung werden entsprechend umsortiert. 


Aufgabe 18: 

Implementieren Sie den DIJKSTRA-Algorithmus in C# 

a) in Matrixform mit der Methode 

public static void dmat 

(int[] pre, // pre[i]: Vorgänger von Knoten i 

int[] kw_dist, // kw_dist[i]: Länge KW von a 

nach i 

int[,] c, // Bewertungsmatrix C(D) 

int n, 

// Anzahl Knoten n von D 

int a 

// Startknoten 

) 

b) in Pfeilform mit der Methode 

public static void dpfeil 

(int[] pre, int[] kw_dist, int[] endknoten, 

int[] cbewertung, int[] pn, int n, int a) 

Verwenden Sie als Testdaten A17_d2.net (n=7, m=12). Ferner können 

als Daten die Straßennetze 

- angeln.net (n= 46, m= 168) 

- dh.net (n= 70, m= 226) 

- segeberg.net (n= 172, m= 572) 

- brd.net (n= 584, m= 2.218) 

- bw.net (n= 8.494, m= 24.844) 

- usa_hn.net (n= 128.111, m= 324.834) 

verwendet werden. 

Das Programm soll Länge und Verlauf des kürzesten Weges von 

Startknoten a zu einem einzugebenden Knoten k ausgeben. Falls Sie die 

Ortsnamen der Knoten (*.kdn-Dateien; bw.kdn und usa_hn.kdn nicht 

vorhanden) auch ausgeben möchten, so verwenden Sie zum Einlesen der 

Ortsnamen die Einlesemethode LesenDatei.lesenKdnDatei (datei_name, 

ort) (ort mit der Deklaration: string[] ort = new 

string[nmax+1]; (siehe AD_Bibliothek). 

Aufgabe 19: 

Implementieren Sie analog zu Aufgabe 18 den FORD-Algorithmus in 

C# jeweils als Methode in Pfeilform, wobei 

a) R als Stapel 

b) R als Schlange 

organisiert ist. 


Aufgabe 20: 

Implementieren Sie den TRIPEL-Algorithmus in C# mit folgendem 

Methodenkopf: 

public static void tripel 

(int [,] c, // Bewertungsmatrix C(D) 

int [,] p, // Vorgängermatrix P(D) (nxn-Matrix) 

int n // Anzahl der Knoten n von D 

) 

Aufgabe 21: 

Implementieren Sie den BELLMANN-Algorithmus in den Versionen a 

und b jeweils als Methode in Pfeilform mit folgendem Methodenkopf: 

public static void bellmannPfeilA bzw. 

public static void bellmannPfeilB 

(int [] pre, int [] kw_dist, int [] anfknoten, int [] 

cbewertung, 

int []vorgaenger, int [] anf_zeiger, 

int n, int a) 

Da der Bellmann-Algorithmus in der Version b topologisch sortierte 

Digraphen voraussetzt, benötigen wir zum Erzeugen derartiger 

Digraphen einen Graphengenerator. Erstellen Sie dazu eine Methode 

public static void 

generiereTopologischSortiertenDigraph 

(int [] pn ,int [] endknoten, int [] cbewertung, 

int n, ref int m) 

die einen topologisch sortierten Digraphen (also auch zyklenfreien) ohne 

parallele Pfeile mit genau einer Quelle (Knoten 1) und genau einer Senke 

(Knoten n) generiert. Dabei kann wie folgt vorgegangen werden: 

Für alle Knoten i in der Reihenfolge 1,...,n-1 werden Pfeile zu Knoten mit 

höheren Knotennummern (mit der Methode Random.Next) generiert, 

wodurch der generierte Digraph zyklenfrei und topologisch sortiert ist. 

Die Anzahl der Pfeile, die von einem Knoten ausgehen, soll maximal 5 

betragen. 

Zur topologischen Sortierung und zur Überprüfung, ob der Digraph 

topologisch sortiert werden kann (zyklenfrei ist), erstellen Sie die 

Methode 


public static bool sortiereDigraphTopologisch 

(int []pn, int [] endknoten, 

int [] l 

//l[i] = neue Knoten-Nr. 

int n) 

die nur dann den Wert ‚true‘ liefert, wenn D topologisch sortiert werden 

konnte (also zyklenfrei ist). 

Aufgabe 22: 

Modifizieren Sie die Algorithmen von FORD und BELLMANN zur 

Bestimmung von kürzesten Wegen derart, dass sie zur Bestimmung von 

längsten Wegen benutzt werden können. Generieren Sie als Testdaten 

Digraphen mit der Methode generiereTopologischSortiertenDigraph (......) 

(siehe Aufgabe 21) oder benutzen Sie zum Testen die bekannten 

Straßennetze (Achtung: Bewertungen mit –1 multiplizieren !). 

Aufgabe 23: 

Implementieren Sie den Algorithmus MINGERUEST für ungerichtete 

Graphen G als Methode 

public static void mingeruest 

(int [] endknoten1, 

int [] endknoten2, 

int [] cbewertung, 

bool [] minimalgeruest, 

int 

int n, m, 

) 

kosten_minimalgeruest, 

mit minmalgeruest[i] = true(false): Kante i ist (nicht) im Gerüst 

kosten_minimalgeruest : Kosten des Minimalgerüstes 

Benutzen Sie die Methoden LesenDatei.lesenNetDatei (datei_name, 

endknoten1, endknoten2, cbewertung, ref n, ref m) zum Einlesen z.B. der 

Beispielgraphen a23a.net, a23b.net oder der Straßennetze und die 

Methode Quickersort.sort (cbewertung, endknoten1, endknoten2, 1, m) zur 

aufsteigenden Sortierung der Bewertungen. (siehe AD_Bibliothek). 

Sortierschlüssel ist dabei der 1. Parameter cbewertung. 


Übung 3: 

Stellen Sie folgenden arithmetischen Ausdruck als binären Baum dar: 

(a+b-c)/(d*(e-(f-g))*(h-i-j))+k 

Übung 4: 

Gegeben sind die Haupt- (HR) und die Symmetrische (SR) Reihenfolge: 

HR: A B D E F C G H I L K SR: D B F E A G C L I H K 

Geben Sie den binären Baum an, der beiden Reihenfolgen entspricht. 

Übung 5: 

Gegeben ist folgender binäre Suchbaum: 

30 

20 60 

10 40 70 

50 

55 

51 

a) Geben Sie die symmetrische Reihenfolge an. 

b) Fügen Sie die Knoten mit den Werten 25 und 35 in den Baum ein. 

c) Entfernen Sie die Knoten mit den Werten 10, 55 und 30. 

Aufgabe 24: 

Implementieren Sie den Algorithmus HEAPSORT zur aufsteigenden 

Sortierung eines sequentiell gespeicherten linearen Feldes A. Es soll 

dabei 'in situ' ('vor Ort' im Array A), d.h. ohne Benutzung eines 

zusätzlichen Arrays, eine Methode 

public static void heapsort (int [] a, int n) 

erstellt werden. Generieren Sie das zu sortierende Array A mit n 

Elementen mit der Methode Random.Next(). Die Dateninhalte der 

Datenknoten von A sollen dabei Werte aus dem Wertebereich [0,...,99] 

annehmen. n ist einzulesen. 


Aufgabe 25: 

Erstellen Sie ein C#-Programm, das für ein einzulesendes Datum in der 

Form tt mm jjjj den Wochentag nach der Basistag-Methode und der 

Methode von ZELLER bestimmt. Das Datum soll aus dem 20. oder den 

folgenden Jahrhunderten sein. 

Aufgabe 26: 

Erstellen Sie ein C#-Programm, das das Osterdatum für alle Jahre des 21. 

Jahrhunderts nach der Gauss'schen Regel berechnet und wie folgt auf 

dem Bildschirm ausgibt: 

Ostersonntag 2000 ist am 23. April Ostersonntag 2001 ist am 15. April 

... 

Ostersonntag 2008 ist am 23. März Ostersonntag 2009 ist am 12. April 

... 

Ostersonntag 2038 ist am 25. April ... 

... ... 

... Ostersonntag 2049 ist am 18. April 

... ... 

Ostersonntag 2076 ist am 19. April ... 

... ... 

Ostersonntag 2098 ist am 20. April Ostersonntag 2099 ist am 12. April 

Aufgabe 27: 

Bestimmen Sie eine minimale Rundreise, die jeden Knoten des Graphen 

mindestens einmal enthält 

a) mit dem heuristischen Verfahren des ‚Besten Nachfolgers‘. Erstellen 

Sie dazu eine Methode 

static void rundreise_bn 

(int[,] entfernung, 

//Entfernungsmatrix 

int n, 

//Anzahl Knoten 

int a, 

//Ausgangsknoten 

ref int[] min_route, 

//Routenverlauf 

ref int min_routenlaenge) //Routenlaenge 

b) mit einem exakten Verfahren mit Hilfe des Algorithmus 

PERMUTAT (siehe S. 59 Skript AD). Erstellen Sie dazu eine 

Methode 

static void rundreise_exakt 

(int[,] entfernung, 

//Entfernungsmatrix 

int n, 

//Anzahl Knoten 

ref int[] min_route, 

//Routenverlauf 

ref int min_routenlaenge, //Routenlaenge 

ref long anzahl_permutationen) //Anzahl Permutat.

pdf, 387 KB

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?