Einleitung

Algorithmen im Alltag

Bedienungsanleitungen
Gebrauchsanleitungen
Bauanleitungen
Kochrezepte
Berechnungsvorschriften (z.B. Berechnung der Fakultät)

Intuitive Begriffserklärung Algorithmus

„Ein Algorithmus ist eine präzise (d.h. In einer festgelegten Sprache formulierten), endliche Beschreibung eines allgemeinen Verfahrens unter Verwendung ausführbarer elementarer Verarbeitungsschritte.“

Definitionen

Algorithmus

„systematische Verarbeitung“
Eine eindeutige Beschreibung eines in mehreren Schritten durchgeführten Bearbeitungsvorgangs
Ein Algorithmus ist ein allgemeines Verfahren zur Lösung eines Problems ohne Bezug auf einen konkreten Prozessor.

Programm

Ein Programm ist eine konkrete Formulierung eines Algorithmus für eine konkrete Klasse von Prozessoren.

Prozessor

Ein Prozessor ist etwas, das die Fähigkeit hat, Programme auszuführen.

Datenstrukturen

„Ordnungsschema“
Eine Struktur zur Verwaltung von Daten
Darstellung von Informationen in maschinenverarbeitbarer Form
Charakterisieren Daten und mögliche Operationen auf Daten

Transformationelle Probleme

Ein Algorithmus definiert eine Transformation auf dem gesamten, durch die Eingaben definierten Zustand, aus dem als Bedeutung dann die Werte der Ausgabevariablen ausgelesen werden. Das heißt, ein Algorithmus benutzt kein weiteres Wissen neben der Eingabe und hat keine Seiteneffekte!

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 2.1 zu finden.

Eigenschaften von Algorithmen

Ein Algorithmus heißt …

terminierend, wenn er für alle zulässigen Schrittfolgen stets nach endlich vielen Schritten endet
deterministisch, wenn in der Auswahl der Verarbeitungsschritte keine Freiheit besteht
determiniert, wenn das Resultat eindeutig bestimmt ist
sequenziell, wenn die Schritte stets hintereinander ausgeführt werden
parallel oder neben läufig, wenn gewisse Verarbeitungsschritte nebeneinander (im Prinzip gleichzeitig) ausgeführt werden
korrekt, wenn das Resultat stets korrekt ist
effizient, wenn das Resultat in „annehmbarer“ Zeit geliefert wird

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 2.1.1 zu finden.

Algorithmenentwurf

Dieses Kapitel behandelt die Vorgehensweise zum Algorithmenentwurf.

Vom Algorithmus zur Programmausführung

Der Algorithmus wird unabhängig von Programmiersprache und Rechnerhardware entworfen
Der Algorithmus wird in einer höheren Programmiersprache, z.B. Java, programmiert
Das Programm wird in Maschinensprache übersetzt
Die CPU interpretiert den Maschinencode und das Programm wird ausgeführt

Vom Algorithmus zum Programm

Vorgehensweise Algorithmus-Entwurf

Hintergrundwissen erwerben: Derjenige der ein Problem beschreibt ist oft nicht derjenige, der den Algorithmus entwirft, dadurch kommt es zu unklaren Aufgabenstellungen, unterschiedlichem Vorwissen und verschiedenen Annahmen.
Problem definieren: Erfordert Hintergrundwissen und Übung in der Definition von Problemen
Algorithmus entwerfen: Erfordert Wissen zu Algorithmen und Datenstrukturen
Programm erstellen: Erfordert Wissen über Programmiersprache (Java) und Programmierung
Lösung überprüfen: Erfordert methodisches Wissen zu Termination, Korrektheit und Effizienz

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 2 und 8.1 zu finden.

Größter gemeinsamer Teiler

In diesem Kapitel wird die im vorherigen Kapitel vorgestellte Vorgehensweise zum Algorithmenentwurf am Beispiel des größten gemeinsamer Teilers gezeigt.

Hintergrundwissen

Gegeben zwei positive natürliche Zahlen a und b, welche ist die größte positive natürliche Zahl x, so dass x sowohl a also auch b teilt und es keine positive natürliche Zahl x’ gibt, so dass x’ > x und x’ teilt sowohl a als auch b.

Alle Variablen bezeichnen natürliche Zahlen größer 0
$x|a\iff \exists \alpha :a=\alpha \land x(x~teilt~a)$
$x=ggT(a,b)\iff x|a\wedge x|b\wedge \forall y:(y|a\wedge y|b\Rightarrow y|x)$
Anwendungsbeispiel Kürzen: 52/32 hat 4 als ggT, mit 4 gekürzt ergibt sich 13/8

Problem definieren

Wir betrachten (i. Allg.) hier transformationelle Probleme

Problem: ggT-Berechnung
Eingabe: zwei Zahlen a,b ∈ N 
Ausgabe: der größte gemeinsame Teiler von a und b

Algorithmus definiert also eine Transformation auf dem gesamten, durch die Eingaben definierten Zustand, aus dem als Bedeutung dann die Werte der Ausgabevariablen ausgelesen werden.

Algorithmus entwerfen

Verfahren von Euklid (300 v. Chr.) für natürliche Zahlen:

$b|a\Rightarrow b=ggT(a,b)$
$\lnot (b|a)\Rightarrow ggT(a,b)=ggT(b,a\%b)$

"%" ist die Modulo Funktion: $r=a\%b\iff 0\leq r\leq b\land \exists \alpha :a=\alpha *b+r$

ggT(46,18) = ggT(18,10)    (α=2, b=18, r=10) 
           = ggT(10,8)     (α=1, b=10, r=8)
           = ggT(8,2) = 2  (α=1, b=8, r=2)

In Worten erklärt:

Wie oft passt 18 in 46? → 2 mal (α)
2*18 ist 36, zur 46 fehlen somit noch 10 (r)
Wie oft passt 10 in 18? → 1 mal (α)
1*10 ist 10, zur 18 fehlen somit noch 8 (r)
Wie oft passt 8 in 10? → 1 mal (α)
1*8 ist 8, zur 10 fehlen somit noch 2 (r)
8 passt 0 mal in die 2, somit ist der ggT die 2

Idee: Führe die Berechnung von ggT(a,b) auf die Berechnung von ggT(b, a % b) zurück (falls b|a, ansonsten ist das Ergebnis b).

Vorbedingung: Eine Bedingung zur Ausführung des ggT(a,b) ist, dass a,b>0

Wie kann man dies sicherstellen?

Optimistische Strategie
- Man geht vom Erfüllt sein der Bedingung aus
  - z.B. Clients bekannt und zuverlässig, z.B. bei Rekursion
Pessimistische Strategie
- Man überprüft die Bedingung bei jedem Aufruf
  - z.B. Öffentliche APIs
Möglichkeiten bei nicht erfüllten Vorbedingungen
- Ausnahmen werfen
- Parameter auf Defaultwerte setzen (mit Meldung)
- Programm nicht ausführen und Defaultwert zurückgeben

Programm erstellen

Pseudocode

Algorithmus euklid
Eingabe: Ganze Zahlen a,b
Ausgabe: Ganze Zahl c=ggT(a,b)
  Setze r = a % b;
  Falls r = 0 gib b zurück;
    Ansonsten gib euklid(b,r) zurück;

Rekursiv, optimistisch

public int ggT(int a, int b){
   int r = a % b;
   if (r == 0)!
           return b;
   else
          return ggT(b,r);
}

Iterativ, pessimistisch – Version 1

public int ggT(int a, int b){
    if (a<=0 || b<=0)
          throw new ArithmeticError(“negative Daten bei ggT(“+a+“,“+b+“)“);
    else { 
          int r = a % b; 
          while (r!=0) { 
                  a = b;
                  b = r;
                  r = a % b;
          }
          return b;
     }
}

Iterativ, pessimistisch – Version 2

public int ggT(int a, int b){
    if (a<=0 || b<=0)
          then throw new ArithmeticError(“negative Daten bei ggT(“+a+“,“+b+“)“);
    else { 
          do{
             int r = a % b;
             a=b;
             b=r;
         } while (r!=0);
return a;
 }
}

Algorithmenanalyse

Ist unser ein Algorithmus ein guter Algorithmus?

Wichtige Fragen:

–  Terminiert der Algorithmus?

–  Ist der Algorithmus korrekt?

–  Welche Laufzeit hat der Algorithmus?

1. Theorem:

Für positive natürliche Zahlen a und b mit a > b, terminiert der Algorithmus Euklid nach endlich vielen Schritten.

Beweis:

(a) Falls b|a terminiert der Algorithmus in einem Schritt. (b) Andernfalls wird ein Parameter der Algorithmus um mindestens den Wert 1 verringert und der Algorithmus rekursiv aufgerufen. Spätestens wenn ein Parameter den Wert 1 erreicht tritt Fall (a) ein und der Algorithmus terminiert. Für endliche Eingaben bedeutet dies eine endliche Laufzeit. Was ist mit anderen Eingaben?

2. Theorem:

Der Algorithmus Euklid löst das Problem ggT.

Beweis:

Wir haben bereits festgestellt, dass für zwei positive natürliche Zahlen a, b gilt, dass ggT(a,b)=b (falls b|a) und ggT(a,b)=ggT(a%b) (falls b|a nicht gilt). Der Algorithmus Euklid vollzieht genau diese Fallunterscheidung nach.

3. Theorem: Für positive natürliche Zahlen a und b mit a>b, benötigt der Algorithmus Euklid maximal max{a,b} viele rekursive Aufrufe.

Beweis:

Wir haben bereits festgestellt, dass Euklid stets terminiert, dass bei jedem Aufruf ein Parameter um mindestens den Wert 1 verringert wird und dass wenn der zweite (stets kleinere) Parameter den Wert 1 hat die Rekursion spätestens endet. Damit kann es maximal max{a,b} viele rekursive Aufrufe geben.

Anmerkung:

Die obige Laufzeit ist nur eine grobe obere Abschätzung. Die tatsächliche Worst‐case‐Laufzeit ist O(log(ab)) (mehr zur O‐Notation später)

Fazit

Welche Strategie (optimistisch, pessimistisch) und welches Verhalten man bei nicht‐erfüllten Vorbedingungen zeigt, hängt von vielen Faktoren ab:

–  Bei unkritischen oft aufzurufenden Algorithmen könnte die Überprüfung der Zulässigkeit zu viel Aufwand sein

–  Bei zeitintensiven Algorithmen kann durch eine Überprüfung Zeit gespart werden

Man sollte das Verhalten seines Algorithmus im Fehlerfall aber stets gut dokumentieren!

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 8 zu finden.

Berechenbarkeitsbegriff

Ein Problem (z.B. eine mathematische Funktion) heißt berechenbar, falls dafür ein Algorithmus existiert.

Berechenbar: Algorithmus stoppt nach endlich vielen Schritten
  Funktion f: W → V ist
- partiell: Def(f) ⊆ W (Beispiel: f: ℝ → ℝ, f(x)= 1/x)
- total: Def(f) = W

Ausgangssituation: Wir entwerfen und programmieren einen Algorithmus und wir haben eine Vorstellung was berechenbar ist (intuitiver Berechenbarkeitsbegriff). Das Problem ist nun, wie man diese Berechenbarkeit nachweisen kann. Dazu bringen wir die intuitive Form in eine mathematische Form und können diese mit mathematischen Beweisen belegen.

Formale Definitionen des Berechenbarkeitsbegriff: Turing berechenbare Funktionen, while-Programme, µ-rekursive Funktionen

Church-Turing-These

Die Klasse der Turing-berechenbaren Funktionen ist genau die Klasse der intuitiv berechenbaren Funktionen. Wobei "intuitiv" nicht exakt formalisierbar ist.

Die durchführbaren Algorithmen sind eine Teilmenge der berechenbaren Funktionen, welche wiederum eine Teilmenge aller existierenden Funktionen sind.

Beispiele

Durchführbare Algorithmen

ggT, Matrizenmultiplikation, Zinsberechnung,…

Berechenbare Funktionen, die nicht durchführbar sind

Harte Optimierungsprobleme mit Millionen von Variablen
Vollständige Eigenwertberechnung auf dem Facebook-Graphen

Nicht berechenbare Funktionen

Haltefunktion (gibt zu einem beliebigen Programm an, ob es hält)
Äquivalenzfunktion (gibt zu zwei beliebigen Programmen an, ob sie das gleiche Verhalten haben)
…

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 6.4 und 7.1 zu finden.

Überblick Theoretische Grundlagen

In diesem Kapitel geben wir einen Überblick über die Theoretischen Grundlagen.

Ein Algorithmenentwurf ist eine kreative Disziplin. Es gibt keine allgemeingültige Anleitung zum Entwerfen und Analysieren von Algorithmen. Wir werden uns in dieser Vorlesung mit vielen Beispielen beschäftigen, die als Inspiration und Werkzeug dienen, weitere Algorithmen zu entwerfen. Einige theoretische Grundlagen sind allerdings notwendig. In diesem Kapitel beschäftigen wir uns näher mit

1. Programmierparadigmen

Was für Möglichkeiten gibt es Algorithmen zu entwickeln und zu implementieren?

2. Laufzeitanalysen

Wie kann man die Laufzeit eines Algorithmus analytisch ableiten und einordnen?

3. Entwurfsmuster

Was sind generelle Prinzipien für das Design eines Algorithmus?

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3 zu finden.

Paradigmenbegriff

In diesem Kapitel erläutern wir den Paradigmenbegriff.

Definition

„Unter einem Paradigma versteht man unter anderem in der Wissenschaftstheorie ein `Denkmuster, welches das wissenschaftliche Weltbild eine Zeit prägt´ - ein Algorithmenparadigma sollte daher ein Denkmuster darstellen, das die Formulierung und den Entwurf von Algorithmen und damit letztendlich von Programmiersprachen grundlegend prägt.“

Oder etwas kürzer: Ein Muster für den Entwurf und die Formulierung von Algorithmen.

Paradigmen zur Algorithmenkonstruktion

Funktional: Verallgemeinerung der Funktionsauswertung. Rekursion spielt eine wesentliche Rolle.

f(x) := 2 g(x) + h(x)
h(x) := 1 + h(x-1)

Logisch: basierend auf logischen Aussagen und Schlussfolgerungen

„wenn a verwandt mit b und b verwandt mit c, dann ist a verwandt mit c“

Imperativ: basierend auf einem einfachen Maschinenmodell mit gespeicherten und änderbaren Werten. Primär werden Schleifen und Alternativen als Kontrollbausteine eingesetzt.

„erst: erhöhe a, dann multipliziere b mit c, dann subtrahiere a mit c,….“

Objektorientiert: basierend auf Nachrichtenaustausch zwischen Objekten und Vererbung von Klassen

Beispiel Java: objektorientiert, imperativ, Elemente von funktional

Paradigmen und Programmiersprachen

Funktional

Haskell, ML, Lisp (Datenauswertung,Datenbank)

Logisch

Prolog (Datenbank)

Imperativ

C, Pascal (maschinenorientiert )

Objektorientiert

Smalltalk, Eiffel („Simulation“ verteilter Systeme), python

Mischungen

C++, C#, Java

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3 zu finden.

Funktionale Algorithmen

In diesem Kapitel wird die funktionale Programmierung behandelt.

Grundidee

Definition zusammengesetzter Funktionen durch Terme mit Unbestimmten.

Ein Beispiel einer einfachen Funktionsdefinition ist $f(x)=5x+1$ .

Erinnerung Definition Term :
*Variable ist ein Term 
*Konstanten-Symbol ist ein Term 
*Sind  $t_{1},...,t_{n}$  Terme und f ein n-stelliges Funktionssymbol, so ist  $f(t_{1},...,t_{n})$  ein Term

Beispiele für Terme

Unbestimmte (Symbole)

$x,y,z$ … vom Typ int
q,p,r … vom Typ bool

Terme mit Bestimmten

1+1, 3*2, ...

Terme mit Unbestimmten

Terme vom Typ int
- x, x-2, 2x+1, (x+1)(y-1)

Terme vom Typ bool

$p,p\wedge true,(p\lor true)\Rightarrow (q\lor false)$

Definition

Ein funktionaler Algorithmus ist eine Menge von Funktionsdefinitionen $f_{1}$ bis $f_{m}$ mit:

 $f_{1}(v_{1},_{1},...,v_{1},_{n_{1}}):=t_{1}(v_{1},_{1},...,v_{1},_{n_{1}}),$ 
...
 $f_{m}(v_{m},_{1},...,v_{m},_{n_{m}}):=t_{m}(v_{m},_{1},...,v_{m},_{n_{m}}).$

Die erste Funktion $f_{1}$ wird wie beschrieben ausgewertet und ist die Bedeutung (=Semantik) des Algorithmus.

$f_{1}$ ist die zustands-bestimmende Eingabe aus der die Werte der Ausgabe abgelesen werden.

Funktionale Algorithmen sind die Grundlage einer Reihe von universellen Programmiersprachen, z.B. APL und Lisp. Diese Programmiersprachen werden als funktionale Programmiersprachen bezeichnet.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2 zu finden.

Funktionsdefinition und Signatur

In diesem Kapitel wird die Funktionsdefinition und Signatur von funktionalen Algorithmen behandelt.

Funktionsdefinition

Eine Funktion f ist eine Relation zwischen einer Eingabemenge X und einer Ausgabemenge $Y(f\subseteq X*Y)$ mit der Eigenschaft:

Für alle x ∈ X, y,y‘ ∈ Y mit (x,y),(x,y‘) ∈ f gilt y=y‘

Wir schreiben dann üblicherweise f(x)=y anstatt(x,y)∈ f und deklarieren eine Funktion durch $f:X\to Y$ . Ist $f:X\to Y$ eine Funktion so heißt X Eingabemenge und Y Ausgabemenge. In der funktionalen Programmierung sind Ein‐ und Ausgabemengen üblicherweise Terme eines bestimmten Typs.

Termdefinition

Sei T ein Typ, $V_{T}$ eine Menge von Variablen vom Typ T und $C_{T}$ eine Menge von Konstanten vom Typ T. Dann ist jedes $X\in V_{T}$ ist ein Term vom Typ T, jedes $a\in C_{T}$ ein Term vom Typ T und ist $f:T^{k}\to T$ eine Funktion und $t_{1},...,t_{k}$ sind Terme vom Typ T, so ist $f(t_{1},...,t_{k})$ ein Term vom Typ T.

Beispiel Terme natürlicher Zahlen

Sei int der Typ der natürlichen Zahlen, $V_{int}$ eine Menge von Variablen vom Typ $T_{int}$ und $C_{int}=\mathbb {N} ={1,2,3...}$ . Mögliche Funktionen auf natürliche Zahlen sind

$+:int$ x $int\to int$
$*:int$ x $int\to int$

3+4, (8+9)*10, X*4+1 sind dann Terme natürlicher Zahlen.

Beispiel Bool´sche Terme

Sei bool der Typ der Bool´sche Terme, $V_{bool}$ eine Menge von Variablen vom Typ $T_{bool}$ und $C_{bool}={true,false}$ . Mögliche Funktionen auf Bool´sche Termes sind

$\bigwedge :bool$ x $bool\to bool$
$\neg :bool\to bool$

true $\bigwedge$ und $\neg Y\bigwedge X$ sind dann Bool´sche Terme.

Sind $v_{1},...,v_{n}$ Unbestimmte vom Typ $T_{1},...,T_{n}$ (bool oder int) und ist $t(v_{1},...,v_{n})$ ein Term, so heißt $f(v_{1},...,v_{n}):=t(v_{1},...,v_{n})$ eine Funktionsdefinition vom Typ T.

T ist dabei der Typ des Terms ( ${}v_{1},\ldots ,v_{n}$ ).
f: ist der Funktionsname
$v_{1},...,v_{n}$ ist ein formaler Parameter
$t(v_{1},...,v_{n})$ : ist ein Funktionsausdruck

Beispiel

$f(p,q,x,y):=if~(p\lor q)~then~2x+1~else~3y-1$
$g(x):=~if~even(x)~then~x/2~else~3x-1$
$h(p,q):=~if~p~then~q~else~false$

Jede Funktionsdefinition hat das Schema Funktionsname(formale Parameter):= Funktionsausdruck

Signatur einer Funktion

Eine Funktion f hat die folgende Funktionsdefinition:

$f(v_{1},...,v_{n}):=t(v_{1},...,v_{n})$

mit $v_{1},...,v_{n}$ sind vom Typ $T_{1},...,T_{n}$

$t(v_{1},...,v_{n})$ ist vom Typ T

Die Signatur von f ist: $f:T_{1}*...*T_{n}\to T$ mit der Struktur

Name mit Stelligkeit: Parameter mit Typ * ... * Parameter mit Typ → Typ des Rückgabewertes

Beispiel einer Funktionsdefinition

f(p,q,x,y) := if (p ∨ q) then 2x + 1 else 3y ‐1

g(x) := if even(x) then x / 2 else 3x ‐1

h(p,q) := if p then q else false, mit h als Funktionsname, (p,q) als formalen Parameter und dem darauffolgenden Funktionsausdruck.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.2 zu finden.

Auswertung von Funktionen

In diesem Kapitel wird die Auswertung funktionaler Algorithmen behandelt.

Definierte Funktionen können mit konkreten Werten aufgerufen werden.
Wir wissen, dass eine definierte Funktion folgende Struktur hat $f:T_{1}*...*T_{n}\to T$
Sind nun $a_{1},...,a_{n}$ konkrete Werte vom Typ $T_{1},...,T_{n}$ , so ersetzt man in $f(a_{1},...,a_{n})$ jedes Vorkommen der Unbestimmten $v_{1}$ mit $a_{1}(i=1,...,n)$ . Somit kann der entstehende Term ausgewertet werden.
Dabei heißen die konkreten Werte $a_{1},...,a_{n}$ aktuelle Parameter.
Ausdruck $f(a_{1},...,a_{n})$ heißt Funktionsaufruf.

Beispiel

$f(p,q,x,y):=~if~(p\lor q)~then~2x+1~else~3y-1$ $f(p,q,x,y):=~if~(p\lor q)~then~2x+1~else~3y-1$
- $Signatur:~f:~bool~x~bool~x~int~x~int~\to ~int$
- $Aufruf:~f(true,true,3,4)~wird~zu~7$

$g(x):=~if~even(x)~then~x/2~else~3x-1$ $g(x):=~if~even(x)~then~x/2~else~3x-1$
- $Signatur:~g:~int~\to ~int$
- $Aufruf:~g(2)~wird~zu~1,~g(9)~wird~zu~26~ausgewertet$

$h(p,q):=~if~p~then~q~else~false$ $h(p,q):=~if~p~then~q~else~false$
- $Signatur:~h:bool~x~bool~\to ~bool$
- $Aufruf:~h(false,false)~wird~ausgewertet~zu~false$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.3 zu finden.

Auswertung von Funktionen

In diesem Kapitel wird die Auswertung funktionaler Algorithmen behandelt.

Definierte Funktionen können mit konkreten Werten aufgerufen werden.
Wir wissen, dass eine definierte Funktion folgende Struktur hat $f:T_{1}*...*T_{n}\to T$
Sind nun $a_{1},...,a_{n}$ konkrete Werte vom Typ $T_{1},...,T_{n}$ , so ersetzt man in $f(a_{1},...,a_{n})$ jedes Vorkommen der Unbestimmten $v_{1}$ mit $a_{1}(i=1,...,n)$ . Somit kann der entstehende Term ausgewertet werden.
Dabei heißen die konkreten Werte $a_{1},...,a_{n}$ aktuelle Parameter.
Ausdruck $f(a_{1},...,a_{n})$ heißt Funktionsaufruf.

Beispiel

$f(p,q,x,y):=~if~(p\lor q)~then~2x+1~else~3y-1$ $f(p,q,x,y):=~if~(p\lor q)~then~2x+1~else~3y-1$
- $Signatur:~f:~bool~x~bool~x~int~x~int~\to ~int$
- $Aufruf:~f(true,true,3,4)~wird~zu~7$

$g(x):=~if~even(x)~then~x/2~else~3x-1$ $g(x):=~if~even(x)~then~x/2~else~3x-1$
- $Signatur:~g:~int~\to ~int$
- $Aufruf:~g(2)~wird~zu~1,~g(9)~wird~zu~26~ausgewertet$

$h(p,q):=~if~p~then~q~else~false$ $h(p,q):=~if~p~then~q~else~false$
- $Signatur:~h:bool~x~bool~\to ~bool$
- $Aufruf:~h(false,false)~wird~ausgewertet~zu~false$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.3 zu finden.

Auswertung rekursiver Funktionen

In diesem Kapitel wird die Auswertung rekursiver Funktionen behandelt.

Erweiterung der Funktionsdefinition

Erweiterung der Definition von Termen
Neu: Aufrufe definierter Funktionen sind Terme
Eine Funktionsdefinition f heißt rekursiv, wenn direkt oder indirekt (über andere Funktionen) ein Funktionsaufruf f(...)in ihrer Definition auftritt.

Gegeben ist die folgende Funktion:

$f(x,y):=~if~g(x,y)~then~h(x+y)~else~h(x-y)$

$g(x,y)~:=~(x==y)~\lor ~odd(y)$

$h(x)~:=~j(x+1)*j(x-1)$

$j(x)~:=~2x-3$

Die Auswertung dieser Funktion lautet:

$f(1,2)~\to ~if~g(1,2)~then~h(1+2)~else~h(1-2)$

\to ~if~1==2~\lor ~odd(2)~then~h(1+2)~else~h(1-2)

\to ~if~1==2~\lor ~false~then~h(1+2)~else~h(1-2)

\to ~if~false~\lor ~false~then~h(1+2)~else~h(1-2)

\to ~if~false~then~h(1+2)~else~h(1-2)

\to ~h(1-2)

\to ~h(-1)

\to ~j(-1+1)*j(-1-1)

\to ~j(0)*j(-1-1)

\to ~j(0)*j(-2)

\to ~(2*0-3)*j(-2)

\to ~(-3)*(-7)

\to ~21

Auswertung rekursive Funktionsdefinition

Gegeben ist folgende rekursive Funktion:

$f(x,y):=if~x=0~then~y~else($

if~x>0~then~f(x-1,y)+1

else~-f(-x,-y))

Die Auswertung dieser Funktion lautet:

$f(0,y)\to y~fuer~alle~y$ Hier greift die erste Zeile der Funktionsdefinition. Da x=0 ist nehmen wir y

$f(1,y)\to f(0,y)+1\to y+1$ Hier greift die zweite Zeile der Funktionsdefinition. Da x>0 ist haben wir f(1-1,y)+1. Da x nach diesem Schritt null ist, greift nun die erste Zeile und wir erhalten y+1.

$f(2,y)\to f(1,y)+1\to (y+1)+1\to y+2$ Hier greift ebenfalls die zweite Zeile der Funktionsdefinition. Da x>0 ist haben wir f(2-1,y)+1. Anschließend wenden wir noch einmal die zweite Zeile an, da x immer noch größer ist als null und wir erhalten f(1-1,y+1)+1. Da x nun null ist greift die erste Zeile der Funktionsdefinition und wir erhalten y+2.

...

Hier lässt sich bereits abschätzen, dass das Ergebnis der Funktion immer weiter hochgezählt wird und es lässt sich allgemein sagen:

$f(n,y)\to y+n~fuer~alle~n\in int,~n>0$

Ist unser x negativ, entwickelt sich die Auswertung wie folgt:

$f(-1,y)\to -f(1,-y)\to -(-y+1)\to y-1$ Hier greift die dritte Zeile der Funktionsdefinition. Da x<0 ist werden die Vorzeichen umgekehrt. Nun, da x=1 ist, greift die zweite Zeile und wir erhalten -f(1-1,-y)+1. Da x nun null ist greift wieder die erste Zeile und wir erhalten y-1.

$f(-2,y)\to -f(2,-y)\to -f(1,-y)+1\to -(-y+2)\to y-2$

...

Auch hier lässt sich bereits abschätzen, wie sich die Funktion einwickelt und es lässt sich allgemein sagen:

$f(x,y)\to x+y~fuer~alle~x,y\in int$

Definiertheit

Gegeben ist folgender Algorithmus:

f(x):=if~x==0~then~0~else~f(x-1)

Auf welchen Eingaben ist der Algorithmus definiert?

Auswertung:

f(0)\to 0

f(1)\to f(0)\to 0

f(2)\to f(1)\to f(0)\to 0

f(x)\to 0\forall x\in int,x>0

f(-1)\to f(-2)\to ...

Diese Auswertung terminiert nicht!

Somit gilt:

f(x):=\left\{{\begin{array}{ll}0&falls~x\geq 0\\\bot &sonst\end{array}}\right.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.4 zu finden.

Definiertheit der Fakultätsfunktion

Im folgenden Beispiel wird die Definiertheit anhand des Beispiels der Fakultät gezeigt.

$x!:=x*(x-1)*(x-2)...2*1~fuer~x>0$

Es ist bekannt, dass $0!:=1$ und

x!:=x*(x-1)!

.

Für negative Werte sind Fakultäten nicht definiert.

1.Lösung

fac(x):=if~(x==0)~then~1~else~x*fac(x-1)

Das bedeutet:

fac(x):=\left\{{\begin{array}{ll}x!&falls~x\geq 0\\\bot &sonst\end{array}}\right.

2.Lösung

fac(x):=if~(x\leq 0)~then~1~else~x*fac(x-1)

Das bedeutet:

fac(x):=\left\{{\begin{array}{ll}x!&falls~x\geq 0\\1&sonst\end{array}}\right.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.6 zu finden.

Größter gemeinsamer Teiler - funktional

In folgendem Beispiel werden wir den größten gemeinsamen Teiler mit Hilfe eines funktionalen Algorithmus berechnen.

Hintergrundwissen

 $Fuer~x,y>0~gilt:$ 
 $ggT(x,y):=x$ 
 $ggT(x,y):=ggT(y,x)$ 
 $ggT(x,y):=ggT(x,y-x)~fuer~x\leq y$

Wir haben folgende funktionale Spezifikationen:

$ggt(x,y):=\left\{{\begin{array}{ll}if(x\leq 0)\lor (y\leq 0)&then~ggT(x,y)~else\\if~x==y&then~x~else\\if~x>y&then~ggT(y,x)~else\\&ggT(x,y-x)\end{array}}\right.$

Auswertung

Eine beispielhafte Auswertung sieht wie folgt aus:

$ggT(39,15)\to ggT(15,39)\to (15,24)$

\to ggT(15,9)~~\to (9,15)

\to ggT(9,6)~~~\to (6,9)

\to ggT(6,3)~~~\to (3,3)

\to 3

Abbruchbedingungen und Rekursion

Der ggT lässt sich nur korrekt berechnen, wenn positive Eingaben gemacht werden. Bei negativen Eingaben ist der ggT undefiniert und der Algorithmus terminiert nicht.

Abbruchbedingungen:

x\leq 0

y\leq 0

x==y

Im Fall des Abbruchs wird eine Evaluierung oder Ausnahme angegeben.

Bedingungen für rekursive Verwendung der Funktion, "einfachste" Rekursion zuerst

$x,y>0,~x\geq y$
$x,y>0,~y<x$

Im Fall der Rekursion wird eine Evaluierung angegeben.

Programm

public static int ggT(int x, int y)
{
     if  ((x <= 0) || (y <= 0))
         throw new ArithmeticError(“negative Daten bei ggt“));
     else   if  (x==y)  then return x;
               else   
                         if x > y  then return ggT(y,x);
                         else return ggT(x,y-x);
}

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.6 zu finden.

Fibonacci Zahlen - funktional

In folgendem Beispiel werden wir die Fibonacci-Zahlen mit Hilfe eines funktionalen Algorithmus berechnen.

Hintergrundwissen

Bei den Fibonacci Zahlen handelt es sich um eine unendliche Zahlenreihe. Ursprünglich wurde die Fibonacci-Folge zur Beschreibung des Wachstums einer Kaninchenpopulation verwendet. Diese erfolgt progressiv. Am Anfang gibt es ein Kaninchenpaar, dieses wird im zweiten Monat zeugungsfähig und zeugt jeden Monat ein weiteres Paar Kaninchen. Keins der Kaninchen stirbt. Das heißt, die Summe der benachbarten Zahlen ergibt die nächste Zahl ( 0,1,1,2,3,5,8,...).

$f_{0}=0$

$f_{1}=1$

$f_{2}=1=f_{0}+f_{1}$

$f_{3}=2=f_{1}+f_{2}$

$f_{4}=3=f_{2}+f_{3}$

...

$fib(x):=\left\{{\begin{array}{ll}x-te~Fibonacci-Zahl&fals~x\geq 0\\\bot &sonst\end{array}}\right.$

Programm

fib(x)  :=  if (x==0) then 0 
        else if (x==1)  then  1
                else  fib(x-1) + fib(x-2)

Literatur

Da die Vorlesungsinhalte auf dem Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.2.6 zu finden.

{{:Kurs:Algorithmen und Datenstrukturen/Vorlesung/Weiteres Beispiel}

Logische Algorithmen

Bei den logischen Algorithmen handelt es sich um ein deklaratives Programmierparadigma. Die logische Programmierung ist ähnlich wie die funktionale Programmierung. Es gibt keine schrittweise (=imperative) Abhandlung von Schritten. Logische Zusammenhänge werden in Form von Klauseln aufgestellt. Die logische Programmierung basiert auf Prädikatenlogik erster Stufe, im speziellen auf Hornlogik, auf welche in späteren Kapiteln genauer eingegangen wird. Die logische Programmierung wird in den Programmiersprachen Prolog und Answer Set Programming genutzt. In diesem Kurs betrachten wir die Programmiersprache Prolog.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.4 zu finden.

Prädikatenlogik und Hornlogik

In diesem Kapitel werden die Grundlagen der Prädikatenlogik und Hornlogik erläutert.

Grundlagen

Sei U eine Menge von Konstanten, V eine Menge von Variablen, und P eine Menge von Prädikatsymbolen.

Ein Term ist entweder eine Konstante oder eine Variable (prinzipiell sind auch Funktionsterme möglich, werden hier aber ignoriert)
X,Y,... sind Variablen (und Terme)
anna, bob, dave,... sind Konstanten (und Terme)
Ein Atom ist ein n-stelliges Prädikat, gefolgt von n Termen
parent(bob,anna) ist ein Atom
sibling(anna, X) ist ein Atom
Eine atomare Konjunktion ist eine Menge von Atomen
parent(X,anna) ∧ sibling(anna,Y) ∧ parent (anna,tina)
Bei logischer Programmierung wird oft das Komma für die Konjunktion verwendet: parent (X,anna), sibling(anna,Y), parent(anna,tina)
Eine Hornklausel ist eine Implikation einer atomaren Konjunktion zu einem Atom
grandparent(X,Y) ⇐ parent(X,Z) ∧ parent(Z,Y)
In Prolog: grandparent(X,Y) :- parent(X,Z), parent(Z,Y).
Anmerkung: Ein Hornklausel ist eigentlich definiert als eine Disjunktion mit maximal einem positiven Atom

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.4.1 zu finden.

Prolog

Ein Prolog-Programm ist eine Menge von Hornklauseln und Fakten (=Atome ohne Variablen)

Beispiel 1

grandparent(X,Y) :- parent(X,Z), parent(Z,Y).

brother(X,Y) :- male(X), male(Y), parent(Z,X), parent(Z,Y).

hasUncle(X) :- parent(Y,X), brother(Y,_).

parent(bob, anna).

parent(carl, bob).

male(bob).

Anmerkung: „_“ ist eine beliebige (unbenannte) Variable

Beispiel 2

s(X,Y) :- r(X,Y), t(Y).

r(a,b). r(a,e). r(c,d).

t(b). t(d).

Anfragen

Prolog ist eine Anfrage-basierte Programmiersprache. Das bedeutet jede Ausführung eines Prolog-Programms muss mit einer Anfrage parametrisiert werden.

Die Anfragen zu oben gezeigten Prolog Programm aus Beispiel 1 lauten:

?grandparent(carl,anna) → Antwort YES
?male(anna) → Antwort NO (Closed World Assumption)

Anfragen können aber auch Variablen enthalten, so wie in Beispiel 2.

?s(a,X) → Antwort X=b
?r(a,X) → Antwort X=b, X=e

Die Semantik logischer Programme leitet sich direkt von der klassisch logischen Semantik der Prädikatenlogik ab (siehe Logik-Vorlesung).

Techniken:

Grundierung des Programms (ersetze Variablen durch alle Kombinationen von Konstanten) und aussagenlogische Verarbeitung
Unifikation des Anfrageterms und Backtracking

Beispiel

Problem: Wegfindung in gerichteten Graphen

Gegeben ein Graph mit Knoten $a_{1},...,a_{n}$
Gibt es einen Weg zwischen Knoten $a_{i}~und~a_{j}$ (für beliebige i,j)?

Lösung als Prolog-Programm:

path(X,Y) :- edge(X,Y).
path(X,Y) :- path(Z,Y), edge (X,Z).
edge(a1,a2). edge(a2,a3). edge(a2,a4). edge(a5,a1).

Anfragen:

?path(a1,a3) → Antwort YES
?path(a5,X) → Antwort X=a1, X=a2, X=a3, X=a4 (alle von a5 erreichbare Knoten)

Logische vs. Funktionale Programmierung

Hornklauseln sind Funktionen im Sinne von atomaren Operationen. Sie haben gemeinsam, dass sie die Rekursion als zentrales Paradigma haben und eine mathematische Basis. Zu den Unterschieden zählt, dass sie Atome entweder wahr oder falsch sind und dass die Funktionswerte beliebige Typen haben können.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.4.1 zu finden.

Liste

Eine Liste ist entweder die leere Liste oder ein Term gefolgt von einer Liste.

Definition in Prolog

list([]).
list([X|Y]) :- list(Y).

Der |-Operator trennt den Kopf (Head=erstes Element)einer Liste vom Rumpf (Tail=Restliste) ab

Beispiele

Liste von Zahlen:

[1|[2|[3]]] = [1,2,3]

Liste von beliebigen Termen:

[male(bob), female(anna),male(carl)]

Listenmanipulation

Aneinanderreihung:

append(X,Y,Z): X ist die Liste, die entsteht, wenn Z an Y angehängt wird

append(X,X,[]).
append([Y|X], [Y|Z],L) :- append(X,Z,L).

Invertierung:

invert(X,Y): X ist die Invertierung von Y

invert([],[]).
invert([X|Y],L) :- invert(Y,Z), append(L,Z,[X]).

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.4.1 zu finden.

Imperative Algorithmen

Die imperative Vorgehensweise ist eine verbreitete Art, um Algorithmen für Computer zu formulieren. Sie basiert auf den Konzepten Anweisung und Variablen und wird durch Programmiersprachen wie Java, C, PASCAL, FORTRAN, COBOL, Maschinencode, … realisiert. Das Prinzip ist ein abstraktes Rechnermodell. Werte werden gespeichert und anschließend schrittweise bearbeitet. Imperative Algorithmen sind nicht so elegant, verständlich und wartbar wie funktionale, objektorientierte oder logische Algorithmen.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3 zu finden.

Variablen

Eine Variable besteht aus einem Namen (z.B. X), einem veränderlichen Wert und einem Typ. Bei Variablen handelt es sich um Speicherplätze für Werte. Ist t ein Term ohne Variablen und w(t) sein Wert, dann heißt das Paar X:=t eine Wertzuweisung. Ihre Bedeutung ist festgelegt durch

Nach Ausführung von X:=t gilt  X=w(t)
Vor Ausführung der ersten Wertzuweisung gilt X=?(undefiniert)

Beispiel

$X:=7$

$X:=(3-7)*9)$

$F:={\text{true}}$

$Q:=\neg ({\text{true}}~\lor ~{\text{false}})\lor ~\neg \neg ~{\text{true}}$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.1 zu finden.

Zustände

Ist ${\underline {X}}={X_{1},X_{2},...}$ eine Menge von Variablen (-namen) von denen alle nur Werte aus der Wertemenge W haben können (alle Variablen vom gleichen Typ), dann ist der Zustand Z eine partielle Abbildung.

 $Z:{\underline {X}}\to W$  (Zuordnung des momentanen Wertes)

Beispiel in einem gewissen Zustand

Z(X_{1})=42

Z(X_{2})=17

Z(X_{3})=23

Nach $X_{1}:=29$ folgt:

Z(X_{1})=29

Z(X_{2})=17

Z(X_{3})=23

Ist $Z:{\underline {X}}\to W$ ein Zustand und wählt man eine Variable X und einen Wert w aus dem Wertebereich W, so ist der transformierte Zustand wie folgt definiert:

 $Z(X\leftarrow ~w):{\underline {X}}~\to ~W~mit$

 $Z_{(X\leftarrow ~W)}~(Y)~\to ~\left\{{\begin{array}{ll}w&falls~X=Y\\Z(Y)&sonst\end{array}}\right.$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.1 zu finden.

Anweisungen

In diesem Kapitel behandelt wir das Thema Anweisungen.

Arten von Anweisungen

Dabei unterscheiden wir in zwei verschiedene Anweisungsarten. Zum einen die elementaren Anweisungen wie Wertezuweisungen und zum anderen die komplexen Anweisungen.

Semantik einer Anweisung

Funktion, die einen Zustand in einen neuen Zustand überführt. $[\![\alpha ]\!](z)$

Allgemein gesagt ist es die Wirkungsweise von $\alpha$ auf den Zustand Z

Beispiele Zuweisung als Anweisung

Beispiel 1

Ein Beispiel ist die Wertezuweisung:

 $\alpha _{1}=(X:=2\cdot Y+1)$

$\alpha _{1}$ ist eine elementare Anweisung

Diese Wertezuweisung transformiert in eine Funktion auf Zustände sieht wie folgt aus:

 $[\![\alpha _{1}]\!](Z)=Z\langle X\leftarrow 2\cdot Z(Y)+1\rangle$

Die Zuweisung berechnet den neuen Zustand.

Der alte Zustand ist $Z$ und der neue Zustand ist $[\![\alpha _{1}]\!](Z)$

Beispiel 2

Ein weiteres Beispiel ist die Zuweisung mit gleichen Variablen auf beiden Seiten.

 $\alpha _{1}=\langle X:=2\cdot X+1\rangle$

Die Transformation in eine Funktion auf Zustände lautet:

 $[\![\alpha _{1}]\!](Z)=Z\langle X\leftarrow 2\cdot Z(X)+1\rangle$

Bei der letzten Anweisung handelt es sich nicht um eine rekursive Gleichung! An dieser Stelle sei vermerkt, dass Wertezuweisungen die einzigen elementaren Anweisungen sind.

Komplexe Anweisungen

Bisher haben wir elementare Anweisungen (Wertzuweisungen) als Funktionen auf Zustände verstanden. Komplexe Anweisungen nehmen Konstrukte bzw. Bausteine von imperativen Algorithmen. Diese Bausteine sind

Sequenz
Auswahl/Selektion
Iteration

Die Semantik wird wiederum durch Konstruktion von Funktionen definiert. Iteration ist das Gegenstück zu rekursiven Funktionsaufrufen bei funktionalen Algorithmen

Sequenz

Sequenzen, oder auch Folgen, sind $\alpha _{1}$ und $\alpha _{2}$ Anweisungen, so ist $\alpha _{1};\alpha _{2};$ auch eine Anweisung. Die Zustandstransformation beschreibt die Semantik der Sequenz.

 $[\![\alpha _{1};\alpha _{2}]\!](Z)=[\![\alpha _{2}]\!]([\![\alpha _{1}]\!](Z))$

Die Semantik ist das Schachteln der Funktionsaufrufe und das daraus folgende hintereinander ausführen der beiden Funktionen.

Selektion

Eine Selektion, bzw. eine Auswahl, liegt beispielsweise vor, wenn $\alpha _{1}$ und $\alpha _{2}$ Anweisungen sind und B ein boolescher Ausdruck ist, dann ist auch

 $if~B~then~\alpha _{1}~else~\alpha _{2}$

eine Anweisung.

Die zugehörige Zustandstransformation ist: $[\![if~B~then~\alpha _{1}~else~\alpha _{2}]\!](Z)=\left\{{\begin{array}{ll}[\![\alpha _{1}]\!](Z)&\quad falls~Z(B)=true\\\,[\![\alpha _{2}]\!](Z)&\quad falls~Z(B)=false\end{array}}\right.$

Voraussetzung ist, dass Z(B) definiert ist, sonst ist die Bedeutung der Auswahlanweisung undefiniert.

Iteration

Wiederholung (Iteration, Schleife):

Ist α eine Anweisung und B ein boolescher Ausdruck, so ist:
while B do α
auch eine Anweisung

Zustandstransformation: $[\![while~B~do~\alpha ]\!](Z)=\left\{{\begin{array}{ll}Z&falls~Z(B)=false\\\,[\![while~B~do~\alpha ]\!]([\![\alpha ]\!](Z))&sonst\end{array}}\right.$

Ist Z(B) undefiniert, so ist die Bedeutung dieser Anweisung ebenfalls undefiniert.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.1 und 3.3.2 zu finden.

Syntax und Semantik

In diesem Kapitel wird die Syntax und Semantik von imperativen Algorithmen behandelt.

Umsetzung in Programmiersprachen

In realen imperativen Programmiersprachen gibt es fast immer diese Anweisungen, da imperative Algorithmen die Grundbausteine imperativer Programmiersprachen sind. While-Schleifen sind rekursiv definiert, ihre rekursive Auswertung braucht nicht zu terminieren. Bereits Programmiersprachen mit diesen Sprachelementen sind universell. Wir werden uns hier zunächst auf die Datentypen bool und int beschränken und können nun die Syntax imperativer Algorithmen festlegen.

Syntax

<Programmname>:
var X,Y,...:int; P,Q,...:bool; (Variablen Deklaration)
input  $X_{1},...,X_{n};$  (Eingabe Variablen)
 $\alpha$    (Anweisungen)
output  $Y_{1},...,Y_{m}$  (Ausgabe-Variablen)

Semantik

Die Festlegung der formalen Bedeutung ist hier etwas komplexer als bei den funktionalen Algorithmen. Das Ziel ist aber das gleiche: Die Funktion zur Semantikfestlegung.

Die Bedeutung (Semantik) eines imperativen Algorithmus ist eine partielle Funktion:

$[\![PROG]\!]W_{1}\cdot ...\cdot W_{n}\to V_{1}\cdot ...\cdot V_{m}$

$[\![PROG]\!](w_{1},...,w_{n})=(Z(Y_{1}),...,Z(Y_{m}))$

wobei~Z=[\![\alpha ]\!](Z_{0}),

Z_{o}(X_{i})=w_{i},~i=1,..,n

und~Z_{0}(Y)=\bot ,~fuer~Variablen~Y\neq X_{i}(i=1,...,n)

Es gilt:

 $PROG$  Programme
 $W_{1},...,W_{n}$  Wertebereich der Typen von  $X_{1},...,X_{n}$ 
 $V_{1},...,V_{m}$  Wertebereich der Typen von  $Y_{1},...,Y_{m}$

Das bedeutet, dass der Algorithmus eine Transformation auf den gesamten initialen Zustand (geg. durch die Eingabe)definiert. Die Bedeutung gibt die Werte der Ausgabevariablen an.

$[\![PROG]\!](w_{1},...,w_{n})=Z(Y_{1},...,Z(Y_{m}))$

wobei~Z=[\![\alpha ]\!](Z_{0}),

Z_{o}(X_{i})=w_{i},~i=1,..,n

und~Z_{0}(Y)=\bot ,~fuer~Variablen~Y\neq X_{i}(i=1,...,n)

Die Funktion Z ist nicht definiert, falls die Auswertung von $\alpha$ nicht terminiert.

Charakterisierung

Die Algorithmenausführung imperativer Algorithmen besteht aus einer Folge von Basisschritten, oder genauer gesagt Wertzuweisungen. Diese Folge wird mittels Selektion und Iteration basierend auf booleschen Tests über dem Zustand konstruiert. Jeder Basisschritt definiert eine Transformation des Zustands. Die Semantik des Algorithmus ist durch die Kombination all dieser Zustandstransformationen zu einer Gesamttransformation festgelegt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.2 zu finden.

Fakultätsfunktion als imperativer Algorithmus

Im Folgenden werden wir die Fakultätsfunktion als imperativen Algorithmus entwerfen.

Hintergrundwissen

Fakultätsfunktion: $0!=1,x!=x\cdot (x-1)!~{\text{für}}~x>0$

$FAC~var~X,Y:int;$

inputX;

Y:=1

while~X>1~do~Y:=Y\cdot X;~X:=X-1

output~Y

Es ist:

 $[\![FAC]\!](x)=\left\{{\begin{array}{ll}x!&{\text{für}}~x~\geq 0\\1&sonst\end{array}}\right.$

Falls die Bedingung der while-Schleife $x\neq 0$ lautet, dann ist:

 $[\![FAC]\!](x)=\left\{{\begin{array}{ll}x!&{\text{für}}~x~\geq 0\\\bot &sonst\end{array}}\right.$

Gesucht ist das Ergebnis des Aufrufs FAC(3).

Die Abkürzung der while $\beta$ für die Zeile ist

 $while~X>1~do~Y:=Y\cdot ~X;X:=X-1$

Die Signatur der Semantikfunktion ist

 $[\![FAC]\!]:int\to int$

Die Funktion ist durch Lesen von Y im Endzustand Z definiert

 $[\![FAC]\!](w)=Z(Y)$

Der Endzustand ist definiert durch

 $Z=[\![\alpha ]\!](Z_{0})$ , wobei  $\alpha$  die Folge aller Anweisungen des Algorithmus ist.

Der initiale Zustand $Z_{0}$ ist definiert als

 $Z_{0}=(X=w,Y=\bot )$

Die Zustände abkürzend ohne Variablennamen sind

 $Z_{0}=(w,\bot )$

Die Auswertung

$Z=[\![\alpha ]\!](Z_{0})$

=[\![\alpha ]\!](3,\bot )

=[\![Y:=1;while~\beta ]\!](3,\bot )

=[\![while~\beta ]\!]([\![Y:=1]\!](3,\bot ))

=[\![while~\beta ]\!](3,\bot )Y\leftarrow 1

=[\![while~\beta ]\!](3,1)

=\left\{{\begin{array}{ll}Z&falls~Z(B)=false\\\,[\![while~B~do~\alpha ']\!]([\![\alpha ']\!](Z))&sonst\end{array}}\right.

=\left\{{\begin{array}{ll}(3,1)&falls~Z(X>1)=(3>1)=false\\\,[\![while~\beta ]\!]~([\![Y:=Y\cdot X;~x:=X-1]\!](Z))&sonst\end{array}}\right.

=[\![while~\beta ]\!]([\![Y:=Y\cdot X;~X:=X-1]\!](3,1))

=[\![while~\beta ]\!]([\![X:=X-1]\!]([\![Y:=Y\cdot X]\!](3,1)))

=[\![while~\beta ]\!]([\![X:=X-1]\!](3,3))

=[\![while~\beta ]\!](2,3)

=\left\{{\begin{array}{ll}(2,3)&falls~Z(X>1)=(2>1)=false\\\,[\![(while~\beta )]\!]~([\![Y:=Y\cdot X;~X:=X-1]\!](Z))&sonst\end{array}}\right.

=[\![while~\beta ]\!]([\![Y:=Y\cdot X;~X:=X-1]\!](2,3))

=[\![while~\beta ]\!]([\![X:=X-1]\!]([\![Y:=Y\cdot X]\!](2,3)))

=[\![while~\beta ]\!]([\![X:=X-1]\!](2,6))

=[\![while~\beta ]\!](1,6)

=\left\{{\begin{array}{ll}(1,6)&falls~Z(X>1)=(1>1)=false\\\,[\![(while~\beta )]\!]~([\![Y:=Y\cdot X;~X:=X-1]\!](Z))&sonst\end{array}}\right.

=(1,6)

Schlussfolgerung

Das bedeutet $Z=[\![\alpha ]\!](Z_{0})$

=[\![\alpha ]\!](3,\bot )

...

=(1,6)

Damit gilt

 $[\![FAC]\!](3)=Z(Y)=6$

Beobachtungen

Der Übergang von der 3. auf die 4. Zeile folgt der Definition der Sequenz, indem der Sequenzoperator in einen geschachtelten Funktionsaufruf umgesetzt wird. Nur in der 5. Zeile wurde eine Wertzuweisung formal umgesetzt,später sind sie einfach verkürzt direkt ausgerechnet. In der 7. Zeile haben wir die Originaldefinition der Iteration eingesetzt (nur mit Kürzel α' statt α, da α bereits verwendet wurde). Dies entspricht im Beispiel α' = {Y:= Y · X; X:= X - 1}. Das Z in der 7. und 8. Zeile steht für den Zustand (3,1). (In späteren Zeilen analog für den jeweils aktuellen Zustand.)Bei diesem Beispiel sieht man folgendes sehr deutlich: Die Ausführung einer while-Schleife erfolgt analog zur rekursiven Funktionsdefinition!

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.3 zu finden.

Fibonacci Zahlen: Funktional vs. Imperativ

In diesem Kapitel werden wir den funktionalen Algorithmus der Fibonacci-Zahlen mit dem imperativen Algorithmus vergleichen.

Funktionale Umsetzung

fib(x)  :=  if (x==0) then 0
       else if (x==1)  then  1 
                else  fib(x-1) + fib(x-2)

Imperative Umsetzung

FIB var X,A,B,C: int;
                  input X; 
                  A := 0; B:=1; C:=1;
                  while  X > 0 { 
                           C :=  A+B;
                           A := B; 
                           B := C;
                           X := X-1; 
                  }
                  output A;

Für beliebige X gibt die Auswertung das Ergebnis von FIB(X). Wir erkennen, der imperative Algorithmus FIB berechnet folgende Funktion:

$[\![FIB]\!](x)=\left\{{\begin{array}{ll}x-te~Fib.~Zahl&falls~x\geq 0\\0&sonst\end{array}}\right.$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.3 zu finden.

ggT: Funktional vs. Imperativ

In diesem Kapitel werden wir den funktionalen Algorithmus des größten gemeinsamen Teilers mit dem imperativen Algorithmus vergleichen.

Version 1

GGT1 var X,Y: int;
                  input X,Y;
                  while  X ≠ Y {
                         while  X > Y   { X :=  X-Y; }
                         while  X < Y   { Y :=  Y-X; }
                   }
                  output X;

Die Auswertung für X=19 und Y=5 lautet:

X	Y
19	5
14	5
9	5
4	5
4	1
3	1
2	1
1	1

Die Berechnung erfolgt durch die Subtraktion der jeweils kleineren Zahl. Es ist zu Beobachten, dass der ggT mittels Subtraktion nicht effizient berechnet werden kann.

Version 2

GGT2 var X,Y,R: int;
                  input X,Y;
                  R := 1
                  while  R ≠ 0 {
                      R := X % Y;  X := Y;  Y := R;
                  }
                  output X;

Die Auswertung für X=19 und Y=5 lautet:

X	Y	R
19	5	1
5	4	4
4	1	1
1	0	0

Die Auswertung für X=2 und Y=1000 lautet:

X	Y	R
2	1000	2
2	0	0

Die Berechnung erfolgt hier durch die Modulo Funktion. Falls X<Y sein sollte, werden X und Y erst vertauscht, wie in der zweiten Auswertung.

Dieser Algorithmus ist folgendermaßen definiert:

$[\![GGT2]\!](x,y)=\left\{{\begin{array}{ll}ggT(x,y)&falls~x,y>0\\y&falls~x=y~\neq 0~oder~x=0,y\neq 0\\\bot &falls~y=0\\ggT(|x|,|y|)&falls~x<0~und~y>0\\-ggT(|x|,|y|)&falls~y<0\end{array}}\right.$

Vergleich

Intuitiv ist GGT2 schneller als GGT1, was man durch die Komplexität von Algorithmen zeigen kann.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 3.3.3 zu finden.

Komplexität

Auf dieser Seite wird das Thema Komplexität behandelt. Gegeben ist ein zu lösendes Problem. Es ist wünschenswert, dass der Algorithmus zur Berechnung der Lösung einen möglichst geringen Aufwand hat. Daher wird der Aufwand des Algorithmus (Komplexität) abgeschätzt . Zur Lösung von Problemen einer bestimmten Klasse gibt es einen Mindestaufwand.

Motivierendes Beispiel

Als Beispiel nutzen wir die sequentielle Suche in Folgen. Gegeben ist die Zahl b und n Zahlen, z.B. mit A[0...n-1] mit n>0, wobei die Zahlen verschieden sind. Gesucht ist ein Index $i\in \{0,...,n-1\}~mit~b=A[i]$ , falls der Index existiert, sonst ist i = n. Die Lösung für das Problem ist:

i = 0; 
  while (i < n  &&  b != A[i]) 
    i++;

Der Aufwand der Suche hängt nun von der Eingabe ab, d.h vom gewählten Wert n, den Zahlen A[0],...,A[n] und von b. Es gibt zwei Möglichkeiten, eine erfolgreiche oder eine erfolglose Suche. Eine erfolgreiche Suche haben wir, wenn b=A[i] dann ist S=i+1 Schritte. Ist die Suche jedoch erfolglos, dann ist S=n+1 Schritte. Das Problem ist, dass die Aussage von zu vielen Parametern abhängt und unser Ziel ist eine globale Aussage zu finden, die nur von einer einfachen Größe abhängt, z.B. der Länge n der Folge.

Analyse erfolgreiche Suche

Im schlechtesten Fall wird b erst im letzten Schritt gefunden, d.h. b=A[n-1]. Dann wäre S=n. Im Mittel wird die Anwendung mit verschiedenen Eingaben wiederholt. Wenn man beobachtet wie oft b an erster, zweiter,..., letzter Stelle gefunden wird, hat man eine Annahme über die Häufigkeit. Läuft der Algorithmus k mal (k>1), so wird b gleich oft an erster, zweiter,....,letzter Stelle gefunden und somit k/n mal an jeder Stelle. Die Anzahl der Schritte insgesamt für k Suchvorgänge lässt sich folgendermaßen berechnen:

$M={\frac {k}{n}}\cdot 1+{\frac {k}{n}}\cdot 2+...+{\frac {k}{n}}\cdot n$

={\frac {k}{n}}\cdot (1+2+...+n)

={\frac {k}{n}}\cdot {\frac {n\cdot (n+1)}{2}}

=k\cdot {\frac {n+1}{2}}

Für eine Suche benötigt man $S={\frac {M}{k}}$ Schritte Daraus folgt, dass im Mittel ( bei einer Gleichverteilung) $S={\frac {n+1}{2}}$

Asymptotische Analyse

Zur Analyse der Komplexität geben wir eine Funktion als Maß für den Aufwand an. $f:\mathbb {N} \to \mathbb {N}$ . Das bedeutet f(n)=a bei Problemen der Größe n beträgt der Aufwand a. Die Problemgröße ist der Umfang der Eingabe, wie z.B. die Anzahl der zu sortierenden oder zu durchsuchenden Elemente. Der Aufwand ist die Rechenzeit( Abschätzung der Anzahl der Operationen, wie z.B. Vergleiche) und der Speicherplatz.

Aufwand für Schleifen

Wie oft wird die Wertezuweisung x=x+1 in folgenden Anweisungen ausgeführt?

 x = x +1

1-mal

  for (i = 1; i <= n; i++)   
    x = x + 1;

n-mal

  for (i = 1; i <= n; i++)
   for (j = 1; j <= n; j++) 
         x = x + 1;

$n^{2}$ -mal

Aufwandsfunktion

Die Aufwandsfunktion $f:\mathbb {N} \to \mathbb {N}$ ist meist nicht exakt bestimmbar. Daher wird der Aufwand im schlechtesten Fall und im mittleren Fall abgeschätzt und die Größenordnung ungefähr errechnet.

Vergleich Größenordnung

Funktion	n=100	n=10.000	n=100.000
log n	4,6	9,2	11,5
$n^{2}$	10.000	100.000.000	10.000.000.000
$n^{3}$	1.000.000	$10^{12}$	$10^{15}$

Problemstellung

Wie können wir das Wachstum von Funktionen abschätzen und wie verhalten sich die Funktionen zueinander? Das Ziel ist, die Funktion $t_{i}(n)$ zu wählen, die $f(n)$ nach oben beschränkt.

$f(n)={\frac {1}{3}}~n^{2}$

$t_{1}(n)={\frac {1}{4}}~n^{2}$

$t_{2}(n)=n$

$t_{3}(n)={\frac {1}{3}}~n^{2}+2$

$t_{4}(n)=2^{n}$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.3 zu finden.

O-Notation

Auf dieser Seite wird die O-Notation behandelt. Bei der O-Notation werden die asymptotischen oberen Schranke für Aufwandsfunktion angegeben. Das heißt deren Wachstumsgeschwindigkeit bzw. Größenordnung. Eine Asymptote ist eine Gerade, der sich eine Kurve bei immer größer werdender Entfernung vom Koordinatenursprung unbegrenzt nähert. Eine einfache Vergleichsfunktion ist $f(n)\in O(g(n))$ für Aufwandsfunktionen mit $g:\mathbb {N} \to \mathbb {N}$

Definition

Für eine Funktion $f:\mathbb {N} \to \mathbb {N}$ ist die Menge $O(f(n))$ wie folgt definiert:

$O(f(n))=\{g:\mathbb {N} \to \mathbb {N} |\exists c\in \mathbb {R} ^{>0},\exists n_{o}\in \mathbb {N} \ \forall n\geq n_{0}:g(n)\leq c\cdot f(n)\}$

Anschaulich formuliert bedeutet das, dass O(f(n)) die Menge aller durch f nach oben beschränkter Funktionen ist und somit die asymptotische obere Schranke ist.

Die Definition veranschaulichst sieht folgendermaßen aus:

$g(n)\in O(f(n))\Leftrightarrow \exists c>0,\exists n_{0}\forall n\geq n_{0}:g(n)\leq c\cdot f(n)$

Das heißt g wächst nicht schneller als f. Das bedeutet wiederrum ${\frac {g(n)}{f(n)}}$ ist für genügend große n durch eine Konstante c nach oben beschränkt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.3.2 zu finden.

$\Omega$ -Notation

Für eine Funktion $f:\mathbb {N} \to \mathbb {N}$ ist die Menge $\Omega (f(n))$ wie folgt definiert:

$\Omega (f(n))=\{g:\mathbb {N} \to \mathbb {N} |\exists c\in \mathbb {R} ^{>0},\exists n_{o}\in \mathbb {N} \ \forall n\geq n_{0}:g(n)\geq c\cdot f(n)\}$

Anschaulich formuliert bedeutet das, dass $\Omega (f(n))$ die Menge aller durch f nach unten beschränkter Funktionen ist und somit die asymptotische untere Schranke ist.

$\Theta$ -Notation

Die exakte Ordnung $\Theta$ von f(n) ist definiert als:

$\Theta (f(n))=\{g:\mathbb {N} \to \mathbb {N} |\exists c_{1}\in \mathbb {R} ^{>0},\exists c_{2}\in \mathbb {R} ^{>0},\exists n_{o}\in \mathbb {N} \ \forall n\geq n_{0}:c_{1}\cdot f(n)\geq g(n)\geq c_{2}\cdot f(n)\}$

Oder etwas kompakter:

$\Theta (f(n))=O(f(n))\bigcap \Omega (f(n))$

Anschaulich formuliert bedeutet das, dass $\Theta$ die Menge aller durch f nach unten und oben beschränkter Funktionen und somit die asymptotische untere und obere Schranke ist.

Beweis

Zu zeigen: $\Theta (f(n))\subseteq O(f(n))\cap \Omega (f(n))~und~\Theta (f(n))\supseteq O(f(n))\cap \Omega (f(n))$

$\Theta (f(n))\subseteq O(f(n))\cap \Omega (f(n)):$

Zeige $g(n)\in \Theta (f(n))\Rightarrow g(n)\in O(f(n))\cap \Omega (f(n)).$

$g(n)\in \Theta (f(n))\Rightarrow \exists c_{1},c_{2},n_{0}:\forall n\geq n_{0}:c_{1}f(n)\geq g(n)\geq c_{2}f(n)$

$\Rightarrow \exists c_{1},n_{0}:\forall n\geq n_{0}:c_{1}f(n)\geq g(n)~und~\exists c_{2},n_{0}:\forall n\geq n_{0}:c_{1}f(n)\geq g(n)\geq c_{2}f(n)$

$\Rightarrow g(n)\in O(f(n))~und~g(n)\in \Omega (f(n))$

$\Rightarrow g(n)\in O(f(n))\cap \Omega (f(n))$

Beispiel 1

Wir stellen uns die Frage, ob $n^{2}\in O(n^{3})$ bzw. ob $n^{3}$ eine obere Schranke für $n^{2}$ ist. Die Antwort ist ja. Die Begründung dazu lautet folgendermaßen:

$n_{0}=1,c=1$

$\Rightarrow n^{2}\leq n^{3}$

$\Rightarrow 1\leq n\ {\text{für}}\ n\geq 1$

Beispiel 2

Wir stellen uns die Frage, ob $n^{3}\in O(n^{2})$ bzw. ob $n^{2}$ eine obere Schranke für $n^{3}$ ist. Die Antwort ist nein. Beweisen kann man das durch Widerspruch. Unsere Annahme ist: $\exists c,n_{0}\in \mathbb {N} :n^{3}\leq c\cdot n^{2},{\text{für alle }}n>n_{0}$

$n^{3}\leq c\cdot n^{2},{\text{für alle }}n>n_{0}$

$\Rightarrow n\leq c,{\text{für alle }}n>n_{0}$

Wähle $n=c+n_{0}\Rightarrow c+n_{0}\leq c$ Widerspruch!!

Lemma

Für beliebige Funktionen f,g gilt:
 $O(f(n)+g(n))=O(max(f(n),g(n))$

Beweis in beide Richtungen

$t(n)\in O(f(n)+g(n))\Rightarrow t(n)\in O(max(f(n),g(n)))$

$t(n)\in O(f(n)+g(n))\Leftarrow t(n)\in O(max(f(n),g(n)))$

Als erstes machen wir den Beweis nach rechts ( $\Rightarrow$ )

$\exists c,n_{0}\in \mathbb {N} :t(n)\leq c\cdot (f(n)+g(n))\ \forall n>n_{o}$

$\Rightarrow t(n)\leq 2\cdot c\cdot max(f(n),g(n))\ \forall n>n_{0}$

$\Rightarrow t(n)\in O(max(f(n)),g(n)))$

nun der Beweis nach links ( $\Leftarrow$ )

$\exists c,n_{0}\in \mathbb {N} :t(n)\leq c\cdot (max(f(n),g(n)))\ \forall n>n_{0}$

$\Rightarrow t(n)\leq c\cdot (f(n)+g(n))\ \forall n>n_{0}$

$\Rightarrow t(n)\in O(f(n),g(n))$

Beispiel

$O(n^{4}+n^{2})=O(n^{4})$

$O(n^{4}+4\cdot n^{3})=O(n^{4})$

$O(n^{4}+2^{n})=O(2^{n})$

Lemma

1.  $O(f(n))\subseteq O(g(n))\ {\text{genau dann wenn }}f(n)\in O(g(n))$ 
2.  $O(f(n))=O(g(n))\ {\text{genau dann wenn }}f(n)\in O(g(n))\land g(n)\in O(f(n))$ 
3.  $O(f(n))\subset O(g(n))\ {\text{genau dann wenn }}f(n)\in O(g(n))\land g(n)\notin O(f(n))$

Beweis in beide Richtungen

Beweis zu 1. nach rechts ( $\Rightarrow$ )

$O(f(n))\subseteq O(g(n))\Rightarrow f(n)\in O(g(n))$

$f(n)\in O(f(n))\subseteq O(g(n))\Rightarrow f(n)\in O(g(n))$

Beweis zu 1. nach links ( $\Leftarrow$ )

$O(f(n))\subseteq O(g(n))\Leftarrow f(n)\in O(g(n))$

$f(n)\in O(g(n))\Rightarrow \exists c_{0},n_{0}\in \mathbb {N} :f(n)\leq c_{0}\cdot g(n)\ \forall n>n_{0}$ (siehe Definition)

und sei t(n) ein beliebiges Element der Menge O(f(n))

$t(n)\in O(f(n))\Rightarrow \exists c_{1},n_{1}\in \mathbb {N} :t(n)\leq c_{1}\cdot f(n)\ \forall n>n_{1}$ (siehe Definition)

$\Rightarrow t(n)\leq c_{1}\cdot f(n)\leq c_{1}\cdot c_{0}\cdot g(n)\ \forall n>max(n_{0},n_{1})$

$t(n)\in O(f(n))\Rightarrow t(n)\in O(g(n))$

$O(f(n))\subseteq O(g(n))$ (Definition der Teilmenge, da t(n) ein beliebiges Element ist)

Beispiele

$O(n^{2})=\{n^{2},2n^{2}-6,3n^{2}+5,{\frac {1}{2}}n^{2}+8,...\}$

Damit ist

$(3n^{2}+5)\in O(n^{2})$

$O(3n^{2}+5)\subseteq O(n^{2})$

$O(3n^{2}+5)=\{n^{2},2n^{2}-6,3n^{2}+5,{\frac {1}{2}}n^{2}+8,...\}$

Damit ist

$n^{2}\in O(3n^{2}+5)$

$O(n^{2})\subseteq O(3n^{2}+5)$

Damit ist

$O(n^{2})=O(3n^{2}+5)$

Lemma

Falls  $f(n)\in O(g(n))~und~g(n)\in O(h(n))$ , dann ist auch  $f(n)\in O(h(n))$ .

Beweis

$f(n)\leq c_{0}\cdot g(n)\ \forall n>n_{0}~und$

$g(n)\leq c_{1}\cdot h(n)\ \forall n>n_{1}~und$

$\Rightarrow f(n)\leq c_{0}\cdot g(n)\leq c_{0}\cdot c_{1}\cdot h(n)\ \forall n\geq max(n_{0},n_{1})$

Dabei ist $c_{0}\cdot c_{1}$ eine Konstante.

Beispiel

$O(n^{2})=O(3n^{2})=O({\frac {1}{2}}n^{2})$

$O(n^{2})\subseteq O(3n^{2})\subseteq O({\frac {1}{2}}n^{2})$

$O(n^{2})\subseteq O(n^{2,5})\subseteq O(n^{3})$

$O(n^{2})\subset O(n^{2,5})\subset O(n^{3})$

Lemma

1.  $lim_{n\to \infty }(f(n)/g(n))=c,c>0\Rightarrow O(f(n))=O(g(n))$ 
2.  $lim_{n\to \infty }(f(n)/g(n))=0\Rightarrow O(f(n))\subset O(g(n))$

Ein häufiges Problem sind Grenzwerte der Art ${\frac {\infty }{\infty }}$ oder ${\frac {0}{0}}$ Bei diesem Problem kann man als Ansatz die Regel von de l'Hospital verwenden.

Satz(Regel von de L'Hospital)  $x\to \infty$ 
Seien f und g auf dem Intervall  $[\alpha ,\infty )$  differenzierbar.
Es gelte  $lim_{x\to \infty }f(x)=lim_{x\to \infty }g(x)=0(bzw.=\infty )$  
und es existiere  $lim_{x\to \infty }{\frac {f'(x)}{g'(x)}}$ .
Dann existiert auch  $lim_{x\to \infty }{\frac {f(x)}{g(x)}}$  und es gilt:
 $lim_{x\to \infty }{\frac {f'(x)}{g'(x)}}=lim_{x\to \infty }{\frac {f(x)}{g(x)}}$

Beispiel

1. $f(n)=3n+5,g(n)=n$

lim_{n\to \infty }{\frac {3n+5}{n}}\Rightarrow lim_{n\to \infty }{\frac {3}{1}}=3>0\Rightarrow O(3n+5)=O(n)

2. $f(n)=n^{2}+5,g(n)=n^{3}$

lim_{n\to \infty }{\frac {n^{2}+5}{n^{3}}}\Rightarrow lim_{n\to \infty }{\frac {2n}{3n^{2}}}\Rightarrow lim_{n\to \infty }{\frac {2}{6n}}=0\Rightarrow O(n^{2}+5)\subset O(n^{3})

Beim zweiten Beispiel musste die Regel von de l'Hospital wiederholt angewandt werden.

Lemma

Gibt es immer eine Ordnung zwischen den Funktionen? Es gibt Funktionen f und g mit $f(n)\notin O(g(n))~und~g(n)\notin O(f(n))$ . Ein Beispiel sind die Funktionen sin(n) und cos(n).

Für alle  $m\in \mathbb {N} ~gilt:O(n^{m})\subseteq O(n^{m+1})$

Beweis durch Widerspruch

Wir nehmen an, dass $s(n)\in O(n^{k})$ ,

das heißt $\exists c,n_{0},\forall n>n_{0}:s(n)\leq c\cdot n^{k}$ .

Aber es muss auch $s(n)\notin O(n^{k+1})$ gelten,

das heißt $\exists n>n_{0}:s(n)>c\cdot n^{k+1}$

$\Rightarrow \exists n>n_{0}:und~n<1$

Komplexitätsklassen

Auf dieser Seite werden die Komplexitätsklassen behandelt.

Wir sagen sei $f(n)=a_{m}\cdot n^{m}+a_{m-1}\cdot n^{m-1}+...+a_{1}\cdot n+a_{0},~wobei~a_{i}\in \mathbb {R} ^{+}{\text{für}}~0\leq i\leq m.~Dann~gilt~f(n)\in O(n^{m}).$ Und wir sagen, ein Algorithmus mit Komplexität f(n) benötigt höchstens polynomielle Rechenzeit, falls es ein Polynom p(n) gibt, mit $f(n)\in O(p(n))$ . Des weiteren sagen wir, dass ein Algorithmus höchstens exponentielle Rechenzeit benötigt, falls es eine Konstante $a\in \mathbb {R} ^{+}$ gibt, mit $f(n)\in O(a^{n})$ .

Die Komplexitätsklassen sind:

$O(1)$	der konstante Aufwand, das bedeutet der Aufwand ist nicht abhängig von der Eingabe
$O(log~n)$	der logarithmische Aufwand
$O(n)$	der lineare Aufwand
$O(n\cdot log~n)$
$O(n^{2})$	der quadratische Aufwand
$O(n^{k})\ {\text{für}}\ k\geq 0$	der polynomiale Aufwand
$O(2^{n})$	der exponentielle Aufwand

Wachstum

f(n)	n=2	$2^{4}=16$	$2^{8}=256$	$2^{10}=1024$	$2^{20}=1048576$
ldn	1	4	8	10	20
n	2	16	256	1024	1048576
$n\cdot ldn$	2	64	2048	10240	20971520
$n^{2}$	4	256	65536	1048576	$\approx 10^{12}$
$n^{3}$	8	4096	16777200	$\approx 10^{9}$	$\approx 10^{18}$
$2^{n}$	4	65536	$\approx 10^{77}$	$\approx 10^{308}$	$\approx 10^{315653}$

Zeitaufwand

Nun stellen wir uns die Frage, wie groß bezüglich der Rechenschritte darf, oder kann ein Problem sein, je nach Komplexitätsklasse, wenn die Zeit T begrenzt ist? Wir nehmen an, dass wir pro Schritt eine Rechenzeit von $1\mu s=(10^{-6}s)$ brauchen. In der folgenden Tabelle steht T für die Zeitbegrenzung und G für die maximale Problemgröße.

G	T=1Min.	1 Std.	1 Tag	1 Woche	1 Jahr
n	$6\cdot 10^{7}$	$3,6\cdot 10^{9}$	$8,6\cdot 10^{10}$	$6\cdot 10^{11}$	$3\cdot 10^{13}$
$n^{2}$	7750	$6\cdot 10^{4}$	$2,9\cdot 10^{5}$	$7,8\cdot 10^{5}$	$5,6\cdot 10^{6}$
$n^{3}$	391	1530	4420	8450	31600
$2^{n}$	25	31	36	39	44

Ein Beispiel ist für T=1 Min. : $1000\cdot 1000\cdot 60=6\cdot 10^{7}\mu s~(10^{7}~Schritte)$

Typische Problemklassen

Aufwand	Problemklasse
$O(1)$	für einige Suchverfahren für Tabellen (Hashing)
$O(log~n)$	für allgemeine Suchverfahren für Tabellen (Baum-Suchverfahren)
$O(n)$	für sequenzielle Suche, Suche in Texten, syntaktische Analyse von Programmen (bei "guter" Grammatik)
$O(n\cdot log~n)$	für Sortieren
$O(n^{2})$	für einige dynamische Optimierungsverfahren (z.B. optimale Suchbäume), einfache Multiplikation von Matrix-Vektor
$O(n^{3})$	für einfache Matrizen Multiplikationen
$O(2^{n})$	für viele Optimierungsprobleme (z.B. optimale Schaltwerke), automatisches Beweisen (im Prädikatenkalkül 1.Stufe)

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.3.3 zu finden.

Aufwandsanalyse von iterativen Algorithmen

Auf dieser Seite wird der Aufwand von iterativen Algorithmen analysiert. Als Aufwand wird die Anzahl der durchlaufenen Operationen zur Lösung des Problems bezeichnet ( Zuweisungen, Vergleiche...). Häufig ist der Aufwand abhängig vom Eingabeparameter (Problemgröße). Die Aufwandsklasse sagt, wie der Aufwand in Abhängigkeit von der Problemgröße wächst. Doch wie kann man nun bei beliebigem Java Code die Aufwandsklasse bestimmen?

Aufwand von Programmen ablesen

void alg1(int n){
     int m = 2;
     int i;
     int k = n;
     while (n > 0){
         i = k;
         while (i > 0) {
               m = m + i;
               i = i / 2;
         }
         n = n - 1;
    }
}

Die Aufwandsklasse ist $O(n\cdot log~n)$ . Die äußere Schleife wird n-mal durchlaufen und die Innere Schleife log n-mal.

void alg1(int n) {
      int m = 1;
      int i = 0;
      while (m < n) {
         while (i < m) 
              i = i + 1;
      m = m + i;
      }
}

Hier ist die Aufwandsklasse O(n+log n). In jedem Durchlauf der äußeren Schleife wird m verdoppelt, d.h. sie läuft log n Mal. Die innere Schleife läuft bis n/2, aber nicht jedes Mal, weil i nur ein Mal auf 0 gesetzt wird. Man könnte als Aufwandsklasse auch O(n) sagen, da der Summand log n nicht ins Gewicht fällt.

Bestandteile iterativer Algorithmen

Zum einen haben wir elementare Anweisungen wie Zuweisungen und Vergleiche. Diese haben einen Aufwand von 1.

Des Weiteren haben wir Sequenzen $\alpha _{1}~und~\alpha _{2}$ oder auch $\alpha _{1};\alpha _{2}$ geschrieben. Die obere Grenze ist $O(f_{\alpha _{1}}(n))+O(f_{\alpha _{2}}(n))$ und die untere Grenze ist $\Omega (f_{\alpha _{1}}(n))+\Omega (f_{\alpha _{2}}(n))$ . Dabei ist $f_{\alpha _{1}}(n)$ der Aufwand, der bei der Ausführung von $\alpha _{1}$ entsteht.

Ein weiterer Bestandteil ist die Selektion. $if(B)\{\alpha _{1}\}else\{\alpha _{2}\}$ . Hier ist die obere Grenze $O(f_{B}(n))+O(max(f_{\alpha _{1}}(n),f_{\alpha _{2}}(n)))$ und die untere Grenze $\Omega (f_{B}(n))+\Omega (min(f_{\alpha _{1}}(n),f_{\alpha _{2}}(n)))$ .

Außerdem haben wir Iterationen $while(B)\{\alpha \}$ . Hierbei ist die obere und die untere Grenze die Anzahl der Schleifendurchläufe, $(O(f_{B}(n))+O(f_{\alpha }(n)))$ und die untere Grenze $(\Omega (f_{B}(n))+\Omega (f_{\alpha }(n)))$ . Doch wie ist der Aufwand für eine for-Schleife? Ein Beispiel ist $for(\alpha _{1};B;\alpha _{2})\{\alpha _{3}\}$ . Die Antwort ist die Abbildung auf eine while-Schleife.

$\alpha _{1};$

while(B) {

$\alpha _{3};$

$\alpha _{2};$

}

Beispiel Sequenz

public int berechne(int n) {
  int x = 0;
  x = x + 1;
  return x;
}

Jede Zeile hat den Aufwand $\Theta (1)$ . Wie viele Operationen werden nun durchlaufen? Und ist die Anzahl abhängig vom Eingabeparameter? Der Aufwand ist $f(n)=\Theta (1)+\Theta (1)+\Theta (1)=3\cdot \Theta (1)$

Die Aufwandsklasse ist somit $\Theta (f(n))=\Theta (1)$

Beispiel Schleifen

public int berechne(int n) {
  int x = 0;
  for (int i=0; i < n; i++) {
    x = x + 1;
  }
  return x;
}

Die for Schleife hat den Aufwand $n\cdot \Theta (1)$ . Die Initialisierung und das return haben jeweils den Aufwand $\Theta (1)$ .

Der Gesamtaufwand ist somit $f(n)=\Theta (1)+n\cdot \Theta (1)+\Theta (1)=2\cdot \Theta (1)+\Theta (n)$ . Somit ist die Aufwandsklasse $\Theta (f(n))=\Theta (n)$ .

public int berechne(int n) {
  int x = 0;
  for (int i=0; i < n; i++) {
    for (int j=0; j < n; j++) {
      x = x + 1;
    }
  }
  return x;
}

Hier hat die for-Schleife den Aufwand $n\cdot (n\cdot \Theta (1))$ und die Initialisierung und das return wieder $\Theta (1)$ . Damit ergibt der sich Gesamtaufwand $f(n)=\Theta (1)+n^{2}\cdot \Theta (1)+\Theta (1)=2\cdot \Theta (1)+\Theta (n^{2})$ . Daraus folgt die Aufwandsklasse $\Theta (f(n))=\Theta (n^{2})$ .

Beispiel Selektion

public int berechne(int n) { 
   if (n % 2 == 0) { 
      int x = 0;
      for (int i=0; i < n; i++) { 
         x = x + 1; 
      }
      return x;
   }else{
      return n;
   }
}

Hier hat die for-Schleife einen Aufwand von $\Theta (n)$ . Die Initialisierung und das return wieder $\Theta (1)$ .

Die obere Grenze ist somit $O(f(n))=\Theta (1)+O(max(\Theta (n),\Theta (1))=O(n)$ und die untere Grenze $\Omega (f(n))=\Theta (1)+\Omega (min(\Theta (n),\Theta (1))=\Omega (1)$

Faustregeln

Zu den häufig verwendeten Faustregeln gehört, dass wenn wir keine Schleife haben, der Aufwand konstant ist. Eine weitere ist, dass bei einer Schleife immer ein linearer Aufwand vorliegt. Bei zwei geschachtelten Schleifen haben wir immer einen quadratischen Aufwand. Doch die Faustegeln gelten nicht ohne Ausnahmen. Besonders Acht geben muss man bei Aufwandsbestimmungen für Schleifen, bei mehreren Eingabevariablen, bei Funktionsaufrufen und bei Rekursionen.

Aufwandsbestimmung für Schleifen

public int berechne(int n) { 
  int x = 0; 
  for (int i=0; i < 5; i++) { 
    x = x + 1; 
  } 
  return x; 
}

Der Schleifenabbruch hängt nicht vom Eingabeparameter ab. Der Aufwand beträgt $f(n)=\Theta (1)+5\cdot \Theta (1)+\Theta (1)=7\cdot \Theta (1)$ somit haben wir die Aufwandsklasse $\Theta (fn))=\Theta (1)$

public int berechne(int n) { 
  int x = 0; 
  for (int i=1; i < n; i = 2*i) { 
    x = x + 1; 
  } 
  return x; 
}

Hier wächst die Laufvariable nicht linear an.Daher ist der Aufwand $f(n)=\Theta (1)+log_{2}n\cdot \Theta (1)+\Theta (1)$ und wir haben die Aufwandsklasse $\Theta (f(n))=\Theta (log~n)$ .

Doch gibt es eine allgemeine Methodik zum Bestimmen des Schleifenaufwands?

for (int i=1; i < n; i=2*i) { 
  x = x + 1;
}

Schritt 1: Wie entwickelt sich hier die Laufvariable? Der Startwert i ist 1 und die Veränderung in jedem Schritt ist $i=2\cdot i$ . Die Laufvariable entwickelt sich somit wie folgt:

Nach dem 1. Durchlauf $i=1\cdot 2=2^{1}$

Nach dem 2. Durchlauf $i=(1\cdot 2)\cdot 2=2^{2}$

Nach dem 3. Durchlauf $i=((1\cdot 2)\cdot 2)\cdot 2=2^{3}$

Nach dem k. Durchlauf $i=2^{k}$

Schritt 2: Nach wie vielen Durchläufen wird die Schleife abgebrochen?

Der Abbruch erfolgt, wenn $i\geq n$

: $i\geq n\ \ \ \ \ \ \ |i=2^{k}$

$\Leftrightarrow 2^{k}\geq n\ \ \ \ \ |log_{2}$

$\Leftrightarrow k\geq log_{2}n$

Somit erfolgt ein Abbruch nach $k=$ ⌈ $log_{2}n$ ⌉ Durchläufen.

public int berechne(int[] f1, int[] f2) { 
   int result = 0; 
   for (int i=0; i < f1.length; i++) { 
      for (int j=0; j < f2.length; j++) { 
         if (f1[i] == f2[j]) result++; 
      } 
   } 
   return result; 
}

Hier haben wir nun eine for Schleife mit mehreren Eingabevariablen. Die Problemgrößen sind $n=f1.length~und~m=f2.length$ .

public int berechne2(int[] f1, int[] f2){ 
   f2 = mergeSort(f2);
   int result = 0; 
   for (int i=0; i < f1.length; i++) {
      if (binarySearch(f2, f1[i])) result++; 
   } 
   return result;
}

Der Aufwand ist hier $f(n,m)=\Theta (m\cdot log~m)+\Theta (1)+n\cdot (\Theta (log~m)+O(1))+\Theta (1)$ . Somit ist die Aufwandsklasse $\Theta (f(n,m))=\Theta (m\cdot log~m+n\cdot log~m)$ .

In diesem Beispiel haben wir wieder mehreren Eingabevariablen. Diese sind die gleichen Problemgrößen $n=f1.length~und~m=f2.length$ .

public int berechne2(int[] f1, int[] f2){ 
   int result = 0; 
   for (int i=0; i < f1.length; i++) {
      for (int j=0; j < f2.length; j++) {
         if (f1[i] == f2[j]) result++; 
      }
   } 
   return result;
}

Der Aufwand ist hier wie folgt: $f(n,m)=\Theta (1)+n\cdot (m\cdot (\Theta (1)+O(1)))+\Theta (1)$ . Somit ist die Aufwandsklasse $\Theta (f(n,m))=\Theta (n\cdot m)$ .

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.3.4 zu finden.

Aufwandsanalyse von rekursiven Algorithmen

Auf dieser Seite wird der Aufwand von rekursiven Algorithmen untersucht.

public int fib(int n) { 
   if (n == 0 || n == 1) {
      return 1;
   } else {
      return fib(n-1) + fib(n-2);
   }
}

Wie ist nun der Aufwand für Fibonacci? Bei Rekursionsabbruch $f(n)=\Theta (1)+\Theta (1)$ und im Rekursionsfall $f(n)=\Theta (1)+???$ . Zur Bestimmung benutzen wir Rekursionsgleichungen.

Rekursionsgleichungen

Eine Rekursionsgleichung ist eine Gleichung oder Ungleichung, die eine Funktion anhand ihrer Anwendung auf kleinere Werte beschreibt.

Rekursionsgleichung für Fibonacci:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n=0\lor n=1)\\\Theta (1)+T(n-1)+T(n-2)&sonst\end{array}}\right.$

Lösung von Rekursionsgleichungen

Die Frage ist nun, welche Aufwandklasse T(n) beschreibt. Dies könnten alle möglichen Aufwandsklassen sein. Methoden um dieses Problem zu lösen, sind die vollständige Induktion und das Master-Theorem.

Spezialfall Divide and Conquer Algorithmus

Ein Divide-and-Conquer Algorithmus stellt im Allgemeinen eine einfache, rekursive Version eines Algorithmus dar und hat drei Schritte:

Divide: Unterteile das Problem in eine Zahl von Teilproblemen
Conquer: Löse das Teilproblem rekursiv. Wenn das

Teilproblem klein genug ist, dann löse das Teilproblem direkt (z.B. bei leeren oder einelementigen Listen)

Combine: Die Lösungen der Teilprobleme werden zu einer Gesamtlösung kombiniert.

Merge Sort ist beispielsweise ein Divide and Conquer Algorithmus.

Divide: Zerteile eine Folge mit n Elementen in zwei Folgen mit je n/2 Elementen.
Conquer: Wenn die resultierende Folge 1 oder 0 Elemente enthält, dann ist sie sortiert.Ansonsten wende Merge Sort rekursiv an.
Combine: Mische die zwei sortierten Teilfolgen.

public List mergeSort(List f) {
  if (f.size() <= 1) {
    return f;
  } else {
    int m = f.size() / 2;
    List left = mergeSort(f.subList(0,m));
    List right = mergeSort(f.subList(m,f.size());
    return merge(left, right);
  }
}

Die dazugehörige Rekursionsgleichung lautet:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\\Theta (1)+2\cdot T(n/2)+\Theta (n)&sonst\end{array}}\right.$

Im Allgemeinen ist die Rekursionsgleichung für Divide and Conquer Algorithmen:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\D(n)+a\cdot T(n/b)+C(n)&sonst\end{array}}\right.$

mit D(n) als Aufwand für Divide, T(n/b) als Aufwand für Conquer und C(n) als Aufwand für Combine.

Ab- und Aufrunden

Die Rekursionsgleichung von MergeSort beschreibt den Aufwand für den schlechtesten Fall.

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\\Theta (1)+T(n/2)+T(n/2)+\Theta (n)&sonst\end{array}}\right.$

Aber die Annahme, dass n eine geeignete ganze Zahl ist ergibt normalerweise das gleiche Ergebnis wie eine beliebige Zahl mit Auf- bzw. Abrunden. Dies führt zur einfacheren Rekursionsgleichung:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\\Theta (1)+2\cdot T(n/2)+\Theta (n)&sonst\end{array}}\right.$

Beispiel Binäre Suche

public List binarySearch(ArrayList<Integer> f, int e) {
  if (f.size() == 0) {
    return -1;
  } else {
    int m = f.size() / 2;
    if (f.get(m) == e) {
      return m;
    } else if (f.get(m) < e) {
      return binarySearch(f.subList(0, m), e);
    } else {
      return binarySearch(f.subList(m+1, f.size()), e);
    }
  }
}

Die Rekursionsgleichung lautet $T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n=0)\\\Theta (1)+T(n/2)&sonst\end{array}}\right.$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.3.4 zu finden.

Vollständige Induktion

Auf dieser Seite wird die vollständige Induktion behandelt. Es handelt sich hierbei um eine rekursive Beweistechnik aus der Mathematik. Sie ist gut geeignet, um Eigenschaften von rekursiv definierten Funktionen zu beweisen.

Vorgehen

Zunächst vermutet man eine Eigenschaft (z.B. Aufwandsklasse einer Rekursionsgleichung). Nun folgt der Induktionsanfang: Eigenschaft hält für ein kleines n. Als nächstes folgt der Induktionsschritt: Die Annahme ist, dass wir es bereits für ein kleineres n gezeigt haben und wenn die Eigenschaft für kleinere n hält, dann hält sie auch für das nächstgrößere n!

Beispiel 1

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für}}\ n\leq 1\\4\cdot T({\frac {n}{2}})+\Theta (n^{3})&sonst\end{array}}\right.$

Nun wollen wir die obere Grenze für den Aufwand bestimmen. Unsere Vermutung ist, dass $T(n)\in O(n^{3})$ . Nun müssen wir zeigen, dass $\exists n_{0},c:\forall n\geq n_{o}:T(n)\leq c\cdot n^{3}$ ( siehe Definition der O-Notation). Die vereinfachte Annahme lautet $n=2^{k}$ . Hierbei werden keine Spezialfälle behandelt und im Induktionsschritt wird von ${\frac {n}{2}}$ nach n gegangen.

Induktionsvermutung: $T({\frac {n}{2}})\leq c\cdot ({\frac {n}{2}})^{3}$

Induktionsschritt: Wir beweisen von ${\frac {n}{2}}~nach~n$

zu zeigende obere Grenze:

T(n)\leq c\cdot n^{3}\ \ \ |T(n)=4\cdot T({\frac {n}{2}})+n^{3}

Rekursionsgleichung einsetzen:

$\Leftrightarrow 4\cdot T({\frac {n}{2}})+n^{3}\leq c\cdot n^{3}|T({\frac {n}{2}})\leq c\cdot ({\frac {n}{2}})^{3}$

Induktionsvermutung einsetzen:

$\ \Leftarrow 4\cdot c\cdot ({\frac {n}{2}})^{3}+n^{3}\leq c\cdot n^{3}$

$\ \Leftrightarrow 4\cdot c\cdot ({\frac {n^{3}}{8}})+n^{3}\leq c\cdot n^{3}|-c\cdot n^{3}$

$\ \Leftrightarrow -{\frac {1}{2}}\cdot c\cdot n^{3}+n^{3}\leq 0|:n^{3}$

$\ \Leftrightarrow -{\frac {1}{2}}\cdot c+1\leq 0|+{\frac {1}{2}}\cdot c$

$\ \Leftrightarrow 1\leq {\frac {1}{2}}\cdot c|\cdot 2$

$\ \Leftrightarrow 2\leq c$

Somit ist der Induktionsschritt erfolgreich, wenn $c\geq 2$ .

Induktionsanfang

Wir zeigen die Induktionsvermutung für einen Anfangswert, am einfachsten ist es, dies für den Rekursionsabbruch zu zeigen.

Zu zeigende obere Grenze:

T(1)\leq c\cdot 1^{3}|T(1)=1

Rekursionsgleichung einsetzen:

$\Leftrightarrow 1\leq c$

Der Induktionsanfang ist erfolgreich, wenn $c\geq 1$ ist. Doch wann können wir zeigen, dass $T(n)\leq c\cdot n^{3}$ ist? Für den Wert, den wir im Induktionsanfang gezeigt haben, also für $n_{0}=1$ und wenn $(c\geq 2\land c\geq 1)\Rightarrow c\geq 2$ .

Beispiel 2

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für}}\ n\leq 1\\4\cdot T({\frac {n}{2}})+\Theta (n)&sonst\end{array}}\right.$

Nun wollen wir die obere Grenze für den Aufwand bestimmen. Unsere Vermutung ist, dass $T(n)\in O(n^{2})$ . Nun müssen wir zeigen, dass $\exists n_{0},c:\forall n\geq n_{0}:T(n)\leq c\cdot n^{2}$ . Die vereinfachte Annahme lautet $n=2^{k}$ .

Induktionsvermutung: $T({\frac {n}{2}})\leq c\cdot ({\frac {n}{2}})^{2}$

Induktionsschritt: Wir beweisen von ${\frac {n}{2}}~nach~n$

T(n)\leq c\cdot n^{2}|T(n)=4\cdot T({\frac {n}{2}})+n

$\Leftrightarrow 4\cdot T({\frac {n}{2}})+n\leq c\cdot n^{2}|T({\frac {n}{2}})\leq c\cdot ({\frac {n}{2}})^{2}$

$\Leftarrow 4\cdot c\cdot ({\frac {n}{2}})^{2}+n\leq c\cdot n^{2}$

$\Leftrightarrow 4\cdot c\cdot ({\frac {n^{2}}{4}})+n\leq c\cdot n^{2}|-c\cdot n^{2}$

$\Leftrightarrow n\leq 0$

Das Problem ist nun, dass wir den Induktionsschritt für positive n zeigen wollen und nicht für negative, daher müssen wir neu ansetzen.

Induktionsvermutung:

Dabei gibt es folgenden Trick: Modifiziere die Induktionsvermutung, in dem ein kleineres Polynom addiert wird.

$T({\frac {n}{2}})\leq c_{1}\cdot ({\frac {n}{2}})^{2}+c_{2}\cdot {\frac {n}{2}}$

Induktionsschritt: Wir beweisen von ${\frac {n}{2}}~nach~n$

T(n)\leq c_{1}\cdot n^{2}+c_{2}\cdot n

$\Leftrightarrow 4\cdot T({\frac {n}{2}})+n\leq c_{1}\cdot n^{2}+c_{2}\cdot n$

$\Leftarrow 4\cdot (c_{1}\cdot ({\frac {n}{2}})^{2}+c_{2}\cdot {\frac {n}{2}})+n\leq c_{1}\cdot n^{2}+c_{2}\cdot n$

$\Leftrightarrow c_{1}\cdot n^{2}+2\cdot c_{2}\cdot n+n\leq c_{1}\cdot n^{2}+c_{2}\cdot n|-c_{1}\cdot n^{2};-c_{2}\cdot n$

$\Leftrightarrow c_{2}\cdot n+n\leq 0$

$\Leftrightarrow c_{2}+1\leq 0$

$\Leftrightarrow c_{2}\leq -1$

Induktionsanfang für n=1

T(1)\leq c_{1}\cdot 1^{2}+c_{2}\cdot 1|T(1)=1

$\Leftrightarrow 1\leq c_{1}+c_{2}|-c_{2}$

$\Leftrightarrow 1-c_{2}\leq c_{1}$

Wann können wir nun zeigen, dass $T(n)\leq c_{1}\cdot n^{2}+c_{2}\cdot n$ ?

Für $n_{0}=1~und~wenn~(c_{2}\leq -1\land c_{1}\geq 1-c_{2})$ . Somit haben wir gezeigt, dass $T(n)\in O(n^{2}+n)\Rightarrow T(n)\in O(max(n^{2},n))\Rightarrow T(n)\in O(n^{2})$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 7.2.5 zu finden.

Mastertheorem

Auf dieser Seite wird das Master Theorem behandelt. Die Mastermethode ist ein „Kochrezept“ zur Lösung von Rekursionsgleichungen der Form:

 $T(n)=aT(n/b)+f(n)$  mit den Konstanten  $a\geq 1~und~b>1$ , f(n) ist eine asymptotische, positive Funktion, d.h.  $f(n)>0\forall n>n_{0}$

a steht dabei für die Anzahl der Unterprobleme.

n/b ist die Größe eines Unterproblems

T(n/b) ist der Aufwand zum Lösen eines Unterproblems (der Größe n/b)

f(n) ist der Aufwand für das Zerlegen und Kombinieren in bzw. von Unterproblemen

Bei der Mastermethode handelt es sich um ein schnelles Lösungsverfahren zur Bestimmung der Laufzeitklasse einer gegebenen rekursiv definierten Funktion. Dabei gibt es 3 gängige Fälle:

Fall 1: Obere Abschätzung
Fall 2: Exakte Abschätzung
Fall 3: Untere Abschätzung

Lässt sich keiner dieser 3 Fälle anwenden, so muss die Komplexität anderweitig bestimmt werden und wir müssen Voraussetzungen für die Anwendung des Mastertheorems überprüfen.

Dafür vergleicht man $f(n)$ mit $n^{log_{b}a}$ . Wir verstehen n/b als $\llcorner n/b\lrcorner ~oder~\ulcorner n/b\urcorner$ . Im Folgenden verwenden wir die verkürzte Notation $log_{2}n~als~ld~n$ .

Fall 1

Wenn $f(n)\in O(n^{log_{b}a-\epsilon }){\text{für ein }}\epsilon >0$ . Daraus folgt, dass f(n) polynomiell langsamer wächst als $n^{log_{b}a}$ um einen Faktor $n^{\epsilon }$ . Damit haben wir die Lösung $T(n)=\Theta (n^{log_{b}a})$ .

Fall 2

Wenn $f(n)\in \Theta (n^{log_{b}a}\cdot ld^{k}n){\text{für ein }}k\geq 0$ . Daraus folgt, dass f(n) und $n^{log_{b}a}\cdot ld^{k}n$ vergleichbar schnell wachsen. Damit haben wir die Lösung $T(n)=\Theta (n^{log_{b}a}\cdot ld^{k+1}n)$ .

Fall 3

Wenn $f(n)\in \Omega (n^{log_{b}a+\epsilon }){\text{für ein }}\epsilon >0$ und die Regularitätsbedingung $a\cdot f(n/b)\leq c\cdot f(n)$ für eine Konstante $c\in (0,1)$ und genügend große n erfüllt. Daraus folgt, dass f(n) polynomiell schneller wächst als $n^{log_{b}a}$ um einen Faktor $n^{\epsilon }$ und f(n) erfüllt die sogenannte Regularitätsbedingung. Damit haben wir die Lösung $T(n)\in \Theta (f(n))$ .

Bedeutung

In jedem Fall vergleichen wir f(n) mit $n^{lob_{b}a}$ . Intuitiv kann man sagen, dass die Lösung durch die größere Funktion bestimmt wird. Im zweiten Fall wachsen sie ungefähr gleich schnell. Im ersten und dritten Fall muss f(n) nicht nur kleiner oder größer als $n^{lob_{b}a}$ sein, sondern auch polynomiell kleiner oder größer um einen Faktor $n^{\epsilon }$ . Der dritte Fall kann nur angewandt werden, wenn die Regularitätsbedingung erfüllt ist.

Regularitätsbedingung

Doch wozu wird die Regularitätsbedingung benötigt? Zur Erinnerung, im dritten Fall dominiert f(n) das Wachstum von T(n). Wir müssen an dieser Stelle sicherstellen, dass auch bei rekursivem Anwenden, also wenn die Argumente kleiner werden, T(n) von f(n) dominiert wird. Veranschaulicht heißt das:

$T(n)=aT(n/b)+f(n)$

=a(aT(n/b^{2})+f(n/b))+f(n)

=a^{2}T(n/b^{2})+af(n/b)+f(n)

für $af(n/b)\leq cf(n)(c\in (0,1))$ Das Wachstum muss durch f(n) dominiert werden und darf f(n) nicht dominieren.

Die Regularitätsbedingung gilt wenn sie für f(n) und g(n) gilt auch für $f(n)\cdot g(n)$ und auch für $f(n)+g(n)$

Nachweis für $f(n)\cdot g(n)$

Voraussetzung ist, dass die Regularitätsbedingung für f(n) und g(n) gilt, d.h.:

$\exists c_{1}\in (0,1),\exists n_{1}\in \mathbb {N} ~\forall n\geq n_{1}:af(n/b)\leq c_{1}f(n)$

$\exists c_{2}\in (0,1),\exists n_{2}\in \mathbb {N} ~\forall n\geq n_{2}:ag(n/b)\leq c_{2}g(n)$

Für $(f\cdot g)(n)$ gilt:

$a(f\cdot g)(n/b)=af(n/b)\cdot ag(n/b)$

man wählt $c=c_{1}\cdot c_{2}\in (0,1)$

und $n_{0}=max~\{n_{1},n_{2}\}$

$\forall n\geq n_{0}:af(n/b)\cdot ag(n/b)\leq c_{1}f(n)\cdot c_{2}g(n)=c(f\cdot g)(n)$

Nachweis für $f(n)+g(n)$

Voraussetzung ist, dass die Regularitätsbedingung für f(n) und g(n) gilt, d.h.:

$\exists c_{1}\in (0,1),\exists n_{1}\in \mathbb {N} ~\forall n\geq n_{1}:af(n/b)\leq c_{1}f(n)$

$\exists c_{2}\in (0,1),\exists n_{2}\in \mathbb {N} ~\forall n\geq n_{2}:ag(n/b)\leq c_{2}g(n)$

Für $(f+g)(n)$ gilt:

$a(f+g)(n/b)=af(n/b)+ag(n/b)$

man wählt $c=max~\{c_{1},c_{2}\}$

und $n_{0}=max~\{n_{1},n_{2}\}$

$\forall n\geq n_{0}:af(n/b)+ag(n/b)\leq c_{1}f(n)+c_{2}g(n)\leq c(f+g)(n)$

Überblick

Ist T(n) eine rekursiv definierte Funktion der Form

 $T(n)=aT(n/b)+f(n)~mit~a\geq 1,b>1,\forall n>n_{0}:f(n)>0$

Dann gilt:

1. Fall: Wenn $f(n)\in O(n^{log_{b}a-\epsilon })~{\text{für ein }}\epsilon >0~dann~T(n)=\Theta (n^{log_{b}a})$
2. Fall: Wenn $f(n)\in \Theta (n^{log_{b}a}\cdot ld^{k}n)~{\text{für ein }}k\geq 0~dann~T(n)=\Theta (n^{log_{b}a}\cdot ld^{k+1}n)$
3. Fall: Wenn $f(n)\in \Omega (n^{log_{b}a+\epsilon })\ {\text{für ein}}\ \epsilon >0$ und $a\cdot f(n/b)\leq c\cdot f(n)\ {\text{für eine Konstante }}c\in (0,1)$ und genügend große n dann $T(n)=\Theta (f(n))$

Idee

Wir haben folgenden Rekursionsbaum:

Auf der ersten Ebene ist der Aufwand f(n), auf der zweiten Ebene $af(n/b)$ und auf der dritten Ebene $a^{2}f(n/b^{2})$ . Die Höhe des Baumes beträgt $h=log_{b}n$ . Die Anzahl der Blätter berechnet sich durch $a^{h}$ und beträgt somit $a^{log_{b}n}=n^{log_{b}a}$ .

Fall 1: Das Gewicht wächst geometrisch von der Wurzel zu den Blättern. Die Blätter erhalten einen konstanten Anteil des Gesamtgewichts.

$\Theta (n^{log_{b}a})$

Fall 2: k ist 0 und das Gewicht ist ungefähr das Gleiche auf jedem der $log_{b}a$ Ebenen.

$\Theta (n^{log_{b}a}\cdot ld~n)$

Fall 3: Das Gewicht reduziert sich geometrisch von der Wurzel zu den Blättern. Die Wurzel erhält einen konstanten Anteil am Gesamtgewicht.

$\Theta (f(n))$

Beispiel 1

$T(n)=4T(n/2)+n$

$a=4,b=2\Rightarrow n^{log_{b}a}=n^{log_{2}4}=n^{2}$

$f(n)=n$

Fall 1: $f(n)\in O(n^{2-\epsilon }){\text{für }}\epsilon >0$

$\Rightarrow T(n)=\Theta (n^{2})$

Beispiel 2

$T(n)=4T(n/2)+n^{2}$

$a=4,b=2\Rightarrow n^{log_{b}a}=n^{log_{2}4}=n^{2}$

$f(n)=n^{2}$

Fall 2: $f(n)\in \Theta (n^{2}~ld^{k}~n)\ {\text{für }}k=0$

$\Rightarrow T(n)=\Theta (n^{2}~ld~n)$

Beispiel 3

$T(n)=4T(n/2)+n^{3}$

$a=4,b=2\Rightarrow n^{log_{b}a}=n^{log_{2}4}=n^{2}$

$f(n)=n^{3}$

Fall 3: $f(n)\in \Omega (n^{2+\epsilon }){\text{für }}\epsilon >0$

und $4({\frac {n}{2}})^{3}\leq cn^{3}$ (Regularitätsbedingung)

für $c={\frac {1}{2}}$

$\Rightarrow T(n)=\Theta (n^{3})$

Beispiel 4

$T(n)=4T(n/2)+{\frac {n^{2}}{log~n}}$

$a=4,b=2\Rightarrow n^{log_{b}a}=n^{log_{2}4}=n^{2}$

$f(n)={\frac {n^{2}}{log~n}}$

Welcher Fall liegt nun vor? Das Mastertheorem kann an dieser Stelle nicht benutzt werden, da

1. Fall $f(n)\notin O(n^{2-\epsilon })$
2. Fall $f(n)\notin \Theta (n^{2}\cdot ld^{k}~n){\text{ für }}k\geq 0$
3. Fall $f(n)\notin \Omega (n^{2+\epsilon })$

Nützliche Hinweise

Basisumrechnung

$log_{b}x={\frac {log_{a}x}{log_{a}b}}\Rightarrow O(log_{b}x)=O(log_{a}x)$

de L'Hospital

$lim_{x\to \infty }{\frac {f(x)}{g(x)}}=lim_{x\to \infty }{\frac {f'(x)}{g'(x)}}$

Vergleiche Logarithmus vs. Polynom

$lim_{x\to \infty }log_{b}x=\infty$

$lim_{x\to \infty }x^{\epsilon }=\infty \ {\text{ für }}\epsilon >0$

$lim_{x\to \infty }{\frac {log_{b}x}{x^{\epsilon }}}=lim_{x\to \infty }{\frac {(log_{b}x)'}{(x^{\epsilon })'}}=lim_{x\to \infty }{\frac {\frac {1}{x}}{\epsilon x^{\epsilon -1}}}$ $=lim_{x\to \infty }{\frac {1}{x\epsilon x^{\epsilon -1}}}=lim_{x\to \infty }{\frac {1}{\epsilon x^{\epsilon }}}=0{\text{ für }}\epsilon >0$

Rekursionsbäume

Auf dieser Seite wird das Thema Rekursionsbäume behandelt. Das allgemeine Problem ist, dass man zum Abschätzen von der Aufwandsklasse einer Rekursionsgleichung gute Vermutungen braucht. Doch wie kommt man darauf? Ein Ansatz ist die Veranschaulichung durch einen Rekursionsbaum. Die Aufwandsklasse wird dann durch die Rekursionsbaummethode bestimmt. Das ist sehr nützlich, um eine Lösung zu raten, die danach durch eine andere Methode (z.B. Induktion) gezeigt wird. Rekursionsbäume sind besonders anschaulich bei Divide-and-Conquer-Algorithmen.

Spezialfall Divide and Conquer

Bei MergeSort sehen die Divide and Conquer Schritte wie folgt aus:

Divide: Zerteile eine Folge mit n Elementen in zwei Folgen mit je n/2 Elementen.
Conquer: Wenn die resultierende Folge 1 oder 0 Elemente enthält,dann ist sie sortiert. Ansonsten wende MergeSort rekursiv an.
Combine: Mische die zwei sortierten Teilfolgen.

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\D(n)+\alpha \cdot T(n/b)+C(n)&{\text{sonst}}\end{array}}\right.$

public List mergeSort(List f) {
  if (f.size() <= 1) {
    return f;
  } else {
    int m = f.size() / 2;
    List left = mergeSort(f.subList(0,m));
    List right = mergeSort(f.subList(m,f.size());
    return merge(left, right);
  }
}

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}(n\leq 1)\\2\cdot T(n/2)+\Theta (n)&{\text{sonst}}\end{array}}\right.$

Rekursionsbaum

Herleitung des Aufwandes

Die Grundidee ist das wiederholte Einsetzen der Rekursionsgleichung in sich selbst als Baum dargestellt. Das Ziel ist ein Muster zu erkennen. Bei einem Rekursionsbaum beschreibt ein Knoten die Kosten eines Teilproblems. Die Blätter sind die Kosten der Basis fällt T(0) und T(1). Der Aufwand bestimmt sich aus der Summe über alle Ebenen.

1. Ebene $c\cdot n$

2. Ebene $2\cdot {\frac {1}{2}}\cdot c\cdot n$

3. Ebene $4\cdot {\frac {1}{4}}\cdot c\cdot n$

....

n. Ebene $\Theta (1)\cdot n=\Theta (n)$

Der Aufwand berechnet sich nun wie folgt:

$T(n)=c\cdot n+2\cdot {\frac {1}{2}}\cdot c\cdot n+4\cdot {\frac {1}{4}}\cdot c\cdot n+2^{log_{2}n-1}\cdot {\frac {1}{2^{log_{2}n-1}}}\cdot c\cdot n+\Theta (n)$

=\sum _{i=0}^{log_{2}n-1}c\cdot n+\Theta (n)

=c\cdot n\cdot \sum _{i=0}^{log_{2}n-1}1+\Theta (n)

=c\cdot n\cdot log_{2}n+\Theta (n)

=\Theta (n\cdot log_{2}n)+\Theta (n)=\Theta (n\cdot log_{2}n)

Allgemein bestimmt sich der Aufwand T(n) durch die Summe des Aufwands je Ebene und des Aufwands der Blattebene.

Bezogen auf den gegebenen Rekursionsbaum wäre das $T(n)=3\cdot T(n/4)+c\cdot n^{2}$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 8.3 zu finden.

Entwurfsprinzipien

Auf dieser Seite werden wir und mit Entwurfsprinzipien und einer Einführung in die Entwurfsmuster beschäftigen. Die Ableitung eines optimalen Algorithmus aus Anforderungsbeschreibungen ist nicht automatisierbar. Der Algorithmenentwurf ist eine kreative Tätigkeit, die durch Muster ( best practices) unterstützt wird. Vergleichbar ist das mit Mustern von Gebäuden in der Architektur oder mit Mustern aus der Softwarearchitektur.

Schrittweise Verfeinerung

Der Entwurf von Algorithmen erfolgt nach dem Prinzip der schrittweisen Verfeinerung von Pseudo Code Algorithmen. Pseudo Code Teile werden im ersten Schritt durch verfeinerten Pseudo Code ersetzt und im nächsten Schritt durch Programmiersprachen Code.

Beispiel 1

1. Pellkartoffeln kochen

verfeinert zu :

1.1 Fülle Topf mit Kartoffeln

1.2 Füge Wasser dazu

1.3 Stelle topf auf Herdplatte

1.4 Stelle Drehknopf auf 7

1.5 Koche das Wasser

Beispiel 2

Wir benutzen die Fakultät als Prozeduraufruf

Factorial(n)

Nun schreiben wir die Fakultät als Algorithmus

Fac: var X;Y:int;
input X; 
Y:=1;
while X>1 do Y:=Y*X; X:=  X-1 od
output Y

Nun schreiben wir die Fakultät als Implementierungscode

public static int factorial (int x) {
...
}

Einsatz von Algorithmenmustern

Die Idee ist, dass generische Algorithmenmuster für bestimmte Problemklassen an eine konkrete Aufgabe angepasst werden. Das Lösungsverfahrens wird am Beispiel eines einfachen Vertreters der Problemklasse dokumentiert. Es wird eine Bibliothek von Mustern (Design Pattern) zur Ableitung eines abstrakten Programmrahmens benutzt. Durch parametrisierte Algorithmen und Vererbung wird die Programmiersprache unterstützt.

Greedyalgorithmus

Auf dieser Seite wird der Greedyalgorithmus behandelt.

Greedy bedeutet "gierig". Der Algorithmus erfolgt nach dem Prinzip, dass versucht wird mit jedem Teilschritt so viel wie möglich zu erreichen. Greedy-Algorithmen (gierige Algorithmen) zeichnen sich dadurch aus, dass sie immer denjenigen Folgezustand auswählen, der zum Zeitpunkt der Wahl den größten Gewinn bzw. das beste Ergebnis verspricht.

Lokales Optimum

Der Greedy Algorithmus berechnet in jedem Schritt das lokale Optimum, dabei kann jedoch das globale Optimum verfehlt werden.

Jedoch entspricht in vielen Fällen das lokale Optimum auch dem globalem Optimum, bzw. es reicht ein lokales Optimum aus.

Problemklasse

Gegebene Menge von Eingabewerten
Menge von Lösungen, die aus Eingabewerten aufgebaut sind
Lösungen lassen sich schrittweise aus partiellen Lösungen, beginnend bei der leeren Lösung, durch Hinzunahme von Eingabewerten aufbauen. Alternativ: bei einer ganzen Menge beginnend schrittweise jeweils ein Element wegnehmen
Bewertungsfunktion für partielle und vollständige Lösungen
Gesucht wird die/eine optimale Lösung

Das Münzwechselproblem

Auf dieser Seite wird das Münzwechselproblem NICHT behandelt.

Beispiel

Als Beispiel nehmen wir die Herausgabe von Wechselgeld auf Beträge unter 1€. Verfügbar sind die Münzen mit den Werten 50ct, 10ct, 5ct, 2ct, 1ct. Unser Ziel ist, so wenig Münzen wie möglich in das Portemonnaie zu bekommen.

Ein Beispiel: $78ct=50+2\cdot 10+5+2+1$

Es wird jeweils immer die größte Münze unter dem Zielwert genommen und von diesem abgezogen. Das wird so lange durchgeführt, bis der Zielwert Null ist.

Formalisierung

Gesucht ist ein Algorithmus der folgende Eigenschaften beschreibt.

Bei der Eingabe muss gelten

1. dass die eingegebene Zahl eine natürliche Zahl ist, also

amount>0

2. dass eine Menge von Münzwerten zur Verfügung steht

currency=\{c_{1},...,c_{n}\}\ {\text{z.B.}}\{1,2,5,10,20,50\}

Die Ausgabe besteht dann aus ganzen Zahlen $change[1],...,change[n]$ . Dabei ist $change[i]$ die Anzahl der Münzen des Münzwertes für $c_{i}$ für $i=1,...,n$ und haben die Eigenschaften

1.

change[1]\cdot c_{1}+...+change[n]\cdot c_{n}=amount

2.

change[1]+...+change[n]

ist minimal unter allen Lösungen für 1.

Algorithmus

1. Nehme jeweils immer die größte Münze unter dem Zielwert und ziehe sie von diesem ab.

2. Verfahre derart, bis der Zielwert gleich Null ist.

Der dazugehörige Code in Java:

public int[] moneyChange(int[] currency, int amount){
   int[] change = new int[currency.length];
   int currentCoin = currency.length-1;
   while(amount > 0){
      while(amount < currency[currentCoin] && currentCoin > 0)
         currentCoin--;
      if(amount >= currency[currentCoin] && currentCoin >= 0){
         amount -= currency[currentCoin];
         change[currentCoin]++;
      } else return null;
   }
   return change;
}

Die Methode moneyChange wird dabei aufgerufen durch:

int[] currency = {1,2,5,10,20,50};
int amount = 78;
int[] change = moneyChange(currency, amount);

Lokales Optimum

Der Greedy Algorithmus berechnet im jedem Schritt das lokale Optimum, dabei kann jedoch das globale Optimum verfehlt werden.

Beispiel: Münzen 11ct, 5ct und 1ct. Unser Zielwert ist 15ct. Nach Greedy benutzen wir 11+1+1+1+1, das Optimum wäre aber 5+5+5.

Analyse

Theorem

Für $currency$ endlicher Länge und mit endlichen positiven Werten und endlichem positivem $amount$ , terminiert der Algorithmus moneyChange nach endlich viele Schritten.

Beweis

In Zeile 03 wird $currentCoin$ mit einem endlichen positiven Wert initialisiert
In Zeile 05 und 06 wird $currentCoin$ nur dekrementiert, spätestens beim Wert 0 wird die Schleife beendet (also eine endliche Wiederholung)
Falls die Zeilen 08 und 09 nicht ausgeführt werden, endet die Berechnung direkt in 10; andernfalls wird $amount$ in Zeile 08 echt kleiner
Irgendwann ist also der Bedingung in Zeile 04 nicht mehr gegeben und die Berechnung terminiert

Theorem

Für Eingabe $currency$ mit $|currency|=m$ und $amount=n$ hat der Algorithmus moneyChange eine Laufzeit von O(m+n).

Beweis

Die Zeile 6 wird maximal m-mal ausgeführt
Die Zeile 8 wird maximal n-mal ausgeführt, falls es nur eine Münze mit dem Wert "1" gibt

Theorem

Der Algorithmus moneyChange löst für $currency=\{1,2,5,10,20,50\}$ das Münzwechselproblem.

Beweis

Bei der Lösung musste zum Einen gelten, dass $change[1]\cdot c_{1}+...+change[n]\cdot c_{n}=amount$ ist. Da der Wert $amount$ stets um den Wert einer Münze $c_{i}$ verringert wird, während $change[i]$ um eins inkrementiert wird, ist dies erfüllt.

Die zweite Aussage zur Lösung war, dass $change[1]+...+change[n]$ minimal unter allen Lösungen sein soll. Dies wird hier nur für Münzen vom Wert 1,2 und 5 betrachtet, wobei es für die Münzen 10, 20 und 50 analog zu beweisen ist.

Zunächst gilt, dass 2er-Münzen stets 1er-Münzen zu bevorzugen sind, da es keinen Sinn macht im Algorithmus auf eine 2er-Münze zu verzichten, um dann im nächsten Schritt mehr 1er-Münzen zu bekommen. Das bedeutet, dass eine optimale Lösung maximal eine 1er-Münze beinhaltet.

Weiterhin gilt, eine optimale Lösung hat nicht mehr als zwei 2er-Münzen. Sollten drei 2er-Münzen in der Lösung sein, ist es besser diese durch eine 1er und eine 5er-Münze zu ersetzen.

Des Weiteren gilt, eine optimale Lösung kann nicht gleichzeitig eine 1er-Münze und zwei 2er-Münzen enthalten, weil dies durch eine 5er-Münze dargestellt werden kann.

Es folgt, dass der durch 1er- und 2er-Münzen dargestellte Betrag nicht mehr als 4 sein kann. Also ist eine maximale Wahl von 5er-Münzen im Greedy-Verfahren optimal.

Divide and Conquer

Auf dieser Seite wird Divide and Conquer behandelt. Divide and Conquer bedeutet "Teile und Herrsche". Quick Sort und Merge Sort sind typische Vertreter. Es verfolgt das Prinzip, dass auf identische Probleme mit einer kleinen Eingabemenge eine rekursive Rückführung geschieht.

Grundidee

Teile das gegebene Problem in mehrere getrennte Teilprobleme auf, löse diese einzeln und setze die Lösungen des ursprünglichen Problems aus den Teillösungen zusammen. Wende dieselbe Technik auf jedes der Teilprobleme an, dann auf deren Teilprobleme, usw, bis die Teilprobleme klein genug sind, dass man eine Lösung explizit angeben kann. Strebe an, dass jedes Teilproblem von derselben Art ist wie das ursprüngliche Problem, so dass es mit demselben Algorithmus gelöst werden kann.

Muster

procedure DIVANDCONQ (P: problem)
begin
	…
	if [P klein ]
	then [explizite Lösung ]
	else [ Teile P auf in P1, …, Pk ];
		DIVANDCONQ (P1 ) ;
		… ;
		DIVANDCONQ (Pk) ;
		[ Setze Lösung für P aus Lösungen für P1, …, Pk zusammen ]
	fi
end

Beispiel

Wir nehmen als Beispiel die Spielpläne für Turniere. Gegeben sind $n=2^{k}$ Spieler, wobei k ganzzahlig und größer 0 ist. Des weiteren sind mindestens n-1 Turniertage gegeben und jeder Spieler spielt gegen jeden anderen. Der Turnierplan $T_{k}$ ist bekannt und die Aufgabe ist $T_{k+1}$ für $m=2n=2^{k+1}$ zu konstruieren (Rekursionsprinzip).

Spielplan für $T_{2}$

	Tag 1	Tag 2	Tag 3
Spieler 1	2	3	4
Spieler 2	1	4	3
Spieler 3	4	1	2
Spieler 4	3	2	1

Spielplan für $T_{1}$ Für kleine Problemgröße kann Lösung direkt angegeben werden:

	Tag 1
Spieler 1	2
Spieler 2	1

Nun konstruieren wir $T_{k+1}$ aus $T_{k}$ .

	Tag 1...n-1	Tag n...m-1
Spieler 1... $n=2^{k}$	$T_{k}$	$S_{k}$
n+1... $m=2{k+1}$	$T_{k}^{[+n]}$	$Z_{k}$

$T_{k}^{[+n]}:T_{k}$ mit jeweils um n erhöhten Elementen
$S_{k}:(n~x~n)$ Matrix, konstruiert durch zyklisches Verschieben der Spalte (n+1,…,m) für $n=2^{k}~und~m=2^{k+1}$
$Z_{k}:(n~x~n)$ Matrix, konstruiert durch zyklisches Verschieben der Zeile (1,2,..., n)

$Z_{2}={\begin{pmatrix}1&2&3&4\\2&3&4&1\\3&4&1&2\\4&1&2&3\\\end{pmatrix}}$

$S_{2}={\begin{pmatrix}5&8&7&6\\6&5&8&7\\7&6&5&8\\8&7&6&5\\\end{pmatrix}}$

Spielplan für $T_{3}$

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

$T_{k}=$ Spieler 1-4 Tag 1-3

$S_{k}=$ Spieler 1-4 Tag 4-7

$T_{k}^{[+n]}=$ Spieler 5-8 Tag 1-3

$Z_{k}=$ Spieler 5-8 Tag 4-7

Türme von Hanoi

Bei den Türmen von Hanoi sind 3 Stapel mit Scheiben unterschiedlicher Größe gegeben. In jedem Schritt darf eine Scheibe, die ganz oben auf einem Stapel liegt, auf einen anderen Stapel gelegt werden. Allerdings unter der Bedingung, dass sie nur auf eine kleinere Scheibe gelegt werden darf.

Das Ziel ist es alle Scheiben vom ganz linken Stapel auf den ganz rechten Stapel zu verschieben.

Illegale Spielzüge sind dabei, wenn eine größere Scheibe auf eine kleinere Scheibe gelegt wird.

Algorithmenentwurf

Reduziere das Problem n Scheiben zu verschieben darauf nur noch n-1 Scheiben zu verschieben, bis schlussendlich nur noch eine Scheibe übrig bleibt.

Dies ist ein ähnliches Prinzip wie bei Induktionsbeweisen. Dabei kann das Nutzen des Algorithmus für n-1 Scheiben als der Induktionsschritt gesehen werden. Der Basisfall, also der Induktionsanfang, ist dabei, wenn es nur eine Scheibe gibt.

Um die Aufgabe zu lösen, muss beim Verschieben von mehr als einer Scheibe der dritte Stapel immer als "Zwischenlager" genutzt werden. Welcher der drei Stapel das "Zwischenlager" ist, kann ja nach Schritt wechseln. In dem Beispiel bei 5 Scheiben auf dem linken Stapel(A), dient dieser als Startstapel und soll auf den linken Stapel(C), also auf den Zielstapel, verschoben werden. Im ersten Schritt dient der mittlere Stapel(B) somit als Zwischenlager.

Das erste Unterziel ist es die obersten vier Scheiben von A zu verschieben. Dafür dient A als Startstapel, B als Zielstapel und C als Zwischenlager.

Weiterhin muss gewährleistet sein, dass das Zwischenlager nach Abschluss wieder genauso aussieht wie zuvor.

Der Pseudocode sieht wie folgt aus:

Algorithmus hanoi
Eingabe:
   Startstapel S,
   Zielstapel Z,
   Zwischenlager L,
   Anzahl der Scheiben n
Ausgabe:
   Aktionenfolgen um alle Scheiben von S nach L zu verschieben

Falls n=1
   Entferne die oberste Scheibe k von S und füge sie Z hinzu
   Gib aus "Verschiebe k von S nach Z"
Ansonsten
   hanoi(S,L,Z,n-1);
   Entferne die oberste Scheibe k von S und füge sie Z hinzu
   Gib aus "Verschiebe k von S nach Z"
   hanoi(L,Z,S,n-1);

Für die Implementierung in Java wird als Repräsentation der Stapel je ein $Stack$ und für eine Scheibe je ein $int$ verwendet. Bei den Scheiben gibt der Wert jeweils die Größe der Scheibe an.

public void hanoi(Stack<Integer> start, Stack<Integer> goal, Stack<Integer> tmp, int numDiscs){
   if(numDiscs == 1){
      int disc = start.pop();
      goal.push(disc);
      System.out.println("Moving disc " + disc);
   }else{
      hanoi(start, tmp, goal, numDiscs-1);
      int disc = start.pop();
      goal.push(disc);
      System.out.println("Moving disc " + disc);
      hanoi(tmp, goal, start, numDiscs-1);
   }
}

Der Aufruf erfolgt durch:

Stack<Integer> start = new Stack<Integer>();
for(int i = 5; i > 0; i--) start.push(i);
hanoi(start, new Stack<Integer>(), new Stack<Integer>(), 5);

Analyse

Theorem

Der Algorithmus $hanoi$ terminiert nach endlich vielen Schritten, wenn die Anzahl der Scheiben positiv ist.

Beweis

Die Zeile 03 stellt das Rekursionsende da und der Algorithmus terminiert bei numDiscs = 1
Die Else-Bedingung führt dazu, dass durch die rekursiven Aufrufe der Wert von numDiscs sich immer um 1 verringert.

Theorem

Für n Schreiben hat der Algortihmus $hanoi$ eine Laufzeit von $O(2^{n})$ .

Beweis

Die Rekursionsgleichung für $hanoi$ ist:

$T(n):=\left\{{\begin{array}{ll}1&{\text{falls}}\ n=1\\2\cdot T(n-1)+O(1)&sonst\end{array}}\right.$

Der Beweis erfolgt damit durch Induktion.

Theorem

Der Algorithmus $hanoi$ löst das Problem der Türme von Hanoi.

Beweis

Zu zeigen gelten:

Der Algorithmus hält sich an die Spielregeln, dass in jedem Zug nur eine Scheibe von oben von einem Stapel entfernt werden darf und auf einen leeren Stapel oder auf eine größere Scheibe gelegt wird.
Bei der Terminierung sind alle Scheiben auf dem Zielstapel.

Beide Aussagen kann man durch Induktion nach der Anzahl der Scheiben n beweisen.

Für $n=1$ : hier wird eine Scheibe direkt vom Startstapel zum leeren Zielstapel verschoben. In diesem Fall sind beide Bedingungen erfüllt.

Für $n-1\rightarrow n$ : Es sind n Scheiben von Stapel A zu C zu verschieben. Dazu sei B der dritte Stapel. Zunächst wird der Algorithmus rekursiv für die obersten n-1 Scheiben mit Zielstapel B aufgerufen. Da alle diese n-1 Scheiben kleiner als die unterste Scheibe ist und diese nicht bewegt wird, ist dies das gleiche Problem, als wenn die unterste Scheibe gar nicht da wäre. Nach rekursiven Aufruf werden also die n-1 Scheiben legal nach B verschoben. C ist dabei anschließend wieder leer. Die Verschiebung der untersten Scheibe nach C ist legal. Die rekursive Verschiebung der auf B liegenden n-1 Scheiben nach C ist nun wieder legal, aufgrund der Tatsache, dass auf C nur eine größere Scheibe liegt.

Der Algorithmus ist ebenso optimal, das heißt, er findet eine minimale Anzahl von Zügen zur Lösung des Problems.

Weiterhin ist eine Animation des Algorithmus verfügbar.

Backtracking

Auf dieser Seite wird das Backtracking behandelt.

Die Idee des Backtracking ist das Versuchs-und-Irrtum-Prinzip (trial and error). Versuche, die erreichte Teillösung schrittweise zu einer Gesamtlösung auszubauen. Falls die Teillösung nicht zu einer Lösung führen kann, dann nimm den letzten Schritt bzw. die letzten Schritte zurück und probiere stattdessen alternative Wege.Alle in Frage kommenden Lösungswege werden ausprobiert. Vorhandene Lösung wird entweder gefunden (unter Umständen nach sehr langer Laufzeit) oder es existiert definitiv keine Lösung. Backtracking (“Zurückverfolgen“) ist eine allgemeine systematische Suchtechnik. KF ist die Menge von Konfigurationen. $K_{0}$ ist die Anfangskonfiguration. Für jede Konfiguration $K_{i}$ gibt es eine direkte Erweiterung $K_{i,1},...,K_{i,n_{i}}$ . Außerdem ist für jede Konfiguration entscheidbar, ob sie eine Lösung ist. Aufgerufen wird Backtracking mit $BACKTRACK(K_{0})$ .

Labyrinth Suche

Backtracking Muster

procedure BACKTRACK (K: Konfiguration)
begin
	…
	if [ K ist Lösung ]
	then [ gib K aus ]
	else
		for each [ jede direkte Erweiterung K0 von K ]
			do
				BACKTRACK (K0)
			od
	fi
end

Einsatzfelder

Zu den typischen Einsatzfeldern von Backtracking gehören zum Beispiel einige Spielprogramme (Schach, Dame, Labyrinthsuche,…). Aber auch die Erfüllbarkeit von logischen Aussagen wie logische Programmiersprachen, Optimierung von Gattern oder Model checking (Theorembeweiser). Ein weiteres Einsatzfeld sind Planungsprobleme und Konfigurationen wie logistische Fragestellungen (Traveling Salesman, der kürzeste Wege, die optimale Verteilung, das Färben von Landkarten oder auch nichtdeterministisch-lösbare Probleme.

Beispiel Acht Damen Problem

Gesucht sind alle Konfigurationen von 8 Damen auf einem 8 x 8-Schachbrett, so dass keine Dame eine andere bedroht. Gesucht ist nun ein geeignetes KF. Für jede Lösungskonfigurationen L mit gelten $L\subseteq KF$ . Für jedes $k\in KF$ ist leicht entscheidbar, ob $k\in L$ . Die Konfigurationen lassen sich schrittweise erweitern und wir erhalten eine hierarchische Struktur. Es sollte auch beachtet werden, dass KF nicht zu groß sein sollte.

$L_{1}$ : Es sind 8 Damen auf dem Brett

$L_{2}$ : Keine zwei Damen bedrohen sich.

KF wird so gewählt, dass die Konfiguration mit je einer Dame in den ersten n Zeilen, $1\leq n\leq 8$ , so dass diese sich nicht bedrohen.

Diese Konfiguration ist nun nicht mehr erweiterbar. Jedes Feld in Zeile 7 ist bereits bedroht.

procedure PLATZIERE (i:[1..8]);
begin
   var h: [1..8];
   for h:=1 to 8 do
      if [Feld in Zeile i, Spalte h nicht bedroht]
      then
         [Setze Dame auf dieses Feld (i,h)];
         if [Brett voll] /* i=8*/
         then [Gib Konfiguration aus ]
         else PLATZIERE (i+1)
         fi
      fi
   od
end

Die Array Repräsentation ist [4,1,3,5,0,0,0,0]. Die Diagonalen sind belegt wenn:

i+h = i+h

i-h = i-h

(i = Spalte, h = Zeile)

Die Zeilen snd belegt, wenn die Position im Array besetzt ist und die Spalten sind belegt, wenn die Nummer im Array existiert.

Der initiale Aufruf geschieht mir Platziere(1). Es gibt insgesamt 92 Lösungen. Die Konfigurationen ist etwa als zweidimensionales boolesches Array oder als eindimensionales Array mit einer Damenposition pro Zeile realisierbar. Redundante Informationen über bedrohte Spalten und Diagonalen bieten Optimierungspotential.

Algorithmus in Java

Der Code zu dem Problem im allgemeinen Fall sieht in Java wie folgt aus.

public boolean isValid(int[] board, int current, int place){
   for(int i = 0; i < current-1; i++){
      if(board[i] == place) return false;
      if(place+current == board[i] + (i+1)) return false;
      if(place-current == board[i] - (i+1)) return false;
   }
   return true;
}

public int[] placeQueen(int[] board, int current){
   int[] tmp;
   for(int i=0; i< board.length; i++){
      if(isValid(board, current, i)){
         board[current-1] = i;
         if(current == board.length) return board;
         else{
            tmp = placeQueen(board, current+1);
            if(tmp != null) return tmp;
         }
      }
   }
   return null;
}

Aufgerufen wird der Code durch:

int[] result = placeQueen(new int[8], 1);

Analyse

Theorem

Der Algorithmus $placeQueen$ terminiert nach endlich vielen Schritten, wenn die Anzahl der Felder positiv ist.

Beweis

Die Methode $isValid$ terminiert offensichtlich immer.

In $placeQueen$ wird rekursiv $placeQueen$ stets um einen erhöhten Parameter $current$ aufgerufen. Die for-Schleife hat auch stets eine konstante Zahl an Durchgängen.

Theorem

Für ein Feld der Größe n x n hat der Algorithmus $placeQueen$ eine Laufzeit von $O(n^{n})$ .

Beweis

Im schlimmsten Fall werden alle Konfigurationen betrachtet:

n Positionen für eine einzelne Dame
n Damen sind zu plazieren

Die tatsächliche Laufzeit ist weitaus geringer, da viele Konfigurationen schon früh als nicht-erweiterbar erkannt werden. Dennoch ist die Laufzeit im schlimmsten Fall exponentiell $O(2^{n})$ .

Theorem

Der Algorithmus $placeQueen$ löst das n-Damenproblem.

Dynamische Programmierung

Auf dieser Seite wird die dynamische Programmierung behandelt.

Die dynamische Programmierung vereint die Ideen verschiedener Muster. Zum einen die Wahl der optimalen Teillösung des Greedy Musters und zum anderen die Rekursion und den Konfigurationsbaum aus Divide and Conquer und Backtracking. Die Unterschiede sind, dass Divide and Conquer unabhängige Teilprobleme löst und in der dynamischen Programmierung eine Optimierung von abhängigen Teilproblemen durchgeführt wird. Die dynamische Programmierung ist eine „bottom-up“-Realisierung der Backtracking-Strategie. Die Anwendungsbereiche sind die selben wie bei Greedy, jedoch wird dynamische Programmierung insbesondere dort angewandt, wo Greedy nur suboptimale Lösungen liefert.

Idee

Bei der dynamischen Programmierung werden kleinere Teilprobleme zuerst gelöst, um aus diesen größere Teillösungen zusammenzusetzen. Das Problemlösen geschieht quasi auf Vorrat. Es werden möglichst nur die Teilprobleme gelöst, die bei der Lösung der großen Probleme auch tatsächlich benötigt werden. Wir erzielen einen Gewinn, wenn identische Teilprobleme in mehreren Lösungszweigen betrachtet werden. Rekursives Problemlösen wird ersetzt durch Iteration und abgespeicherte Teilergebnisse.

Nicht immer ist es überhaupt möglich, die Lösungen kleinerer Probleme so zu kombinieren, dass sich die Lösung eines größeren Problems ergibt. Die Anzahl der zu lösenden Probleme kann unvertretbar groß werden. Es können zu viele Teillösungen entstehen, die dann doch nicht benötigt werden oder der Gewinn der Wiederverwendung ist zu gering, da die Lösungszweige disjunkt sind.

Beispiel Editierdistanz

Gegeben sind zwei Zeichenketten s und t, was ist die minimale Anzahl an Einfüge-, Lösch- und Ersetzoperationen um s in t zu transformieren?

Als Beispiel entspricht s "Haus" und t "Maus". Die Lösung ist hier, dass "H" durch "M" ersetzt wird. Bei s= "Katze" und t="Glatze" wird "K" durch "G" ersetzt und "I" hinzugefügt. Die Editierdistanz kommt in der Rechtschreibprüfung und Plagiatserkennung zur Anwendung.

Formalisierung

Definition ( Ein-Schritt Modifikation)

Beachte $s=s_{1}...s_{m}$

Jedes $s'=s_{1}...s_{i-1}s_{i+1}....s_{m}$ (für $i=1,...,m$ )
Jedes $s'=s_{1}...s_{i-1}xs_{i+1}....s_{m}$ (für $i=1,...,m~und~x!=s_{i}$ )
Jedes $s'=s_{1}...s_{i}xs_{i+1}....s_{m}$ (für $i=0,1,...,m~und~bel.~x$ )

heißt Ein-Schritt Modifikation von s.

Definition (k-Schritt Modifikation) Eine Zeichenkette t heißt k-Schritt Modifikation $(k>1)$ von s, wenn es Zeichenketten u gibt mit:

u ist eine Ein-Schritt Modifikation von s
t ist eine k-1-Schritt Modifikation von u

Definition (Editierdistanz, auch Levenshtein-Distanz) $D(s,t)=min\{d|s~ist~eine~d-Schritt~Modifikation~von~t\}$

Ist s eine d-Schritt Modifikation von t, so ist auch s eine d+2j Modifikation von t für jedes j>0.Eine minimale Modifikation muss nicht eindeutig sein. Wir sind aber hier nur an dem Wert einer minimalen Modifikation interessiert.

Charakterisierung und Algorithmus

Die Idee ist, dass die Berechnung von D(s,t) auf die Berechnung von D auf die Präfixe von s und t zurückgeführt wird.

Definition $D_{ij}(s,t)$

Sei $s=s_{1}...s_{m}~und~t=t_{1}...t_{n}$

Definiere $D_{ij}(s,t)=D(s_{1}...s_{i},t_{1}...t_{j})(fueri=0,...,m,j=0,...,n)$

Beachte für z.B i=0 haben wir $s_{1}...s_{i}=\epsilon$ (leerer String).

Wir beobachten, dass gilt $D_{mn}(s,t)=D(s,t)$ . Dies ist nun zu berechnen. Zudem ist $D_{00}(s,t)=D(\epsilon ,\epsilon )=0$ , also sind zwei leere Strings identisch.

$D_{0j}(s,t)=D(\epsilon ,t)=j$ für j=1,..,n. Also alle Zeichen $t_{1}...t_{j}$ müssen eingefügt werden.

$D_{i0}(s,t)=D(s,\epsilon )=i$ für i=1,...,m. Also alle Zeichen $s_{1}...s_{i}$ müssen eingefügt werden.

Theorem der zentralen Charakterisierung der Editierdistanz

Falls $s_{i}=t_{j}:D_{ij}(s,t)=D_{i-1,j-1}(s,t)$ .

Ansonsten: $D_{ij}(s,t)=min:=\left\{{\begin{array}{ll}D_{i-1,j-1}(s,t)+1&Ersetzung\\D_{i,j-1}(s,t)+1&Einfuegung\\D_{i-1,j}(s,t)+1&Loeschung\end{array}}\right.$

Algorithmus

For j=0,...,n set  $D_{0j}$ (s,t)=j
For i=0,...,m set  $D_{i0}$ (s,t)=i
For i=1,..,m
   For j=1,...,n
      If  $s_{i}=t_{j}$  set  $D_{ij}(s,t)=D_{i-1,j-1}(s,t)$ 
      else  $D_{ij}(s,t)=$ 
         min { $D_{i-1,j-1}(s,t)+1,D_{i,j-1}(s,t)+1,D_{i-1,j}(s,t)+1$ }
Return  $D_{mn}(s,t)$

Analyse

Theorem

Für endliche Zeichenketten s und t terminiert der Algorithmus editdistance nach endlich vielen Schritten.

Beweis

Der Beweis folgt auf dem nächsten Theorem.

Theorem

Für die Eingaben $s=s_{1}...s_{m}$ und $t=t_{1}...t_{n}$ hat der Algorithmus eine Laufzeit von $\Theta (mn)$ .

Beweis

Der Beweis besteht aus einer einfachen Schleifenanalyse.

Theorem

Der Algorithmus editdistance berechnet die Editierdistanz zweier Zeichenketten s und t.

Beweis

Der Beweis folgt direkt aus der zentralen Charakterisierung der Editierdistanz.

Einleitung Suchen

In diesem Kapitel geben wir einen Überblick über das Thema Suchen. Suchprobleme sind eine der häufigsten Probleme in der Informatik. Man kann in sortierten Folgen suchen, Zeichenketten im Text suchen, Dokumente in Textkorpora suchen, oder allgemeine Lösungen von Problemräumen, wie der Spielbaumsuche oder der Plansuche, suchen. Hier behandeln wir zunächst die Suche in sortierten Folgen.

Motivation

Beim Suchen wiederholt man häufig sehr nützliche Beispielalgorithmen, oder lernt diese sogar neu kennen. Außerdem dient es der Vorbereitung der theoretischen Betrachtungen zur Komplexität von Algorithmen. Des Weiteren dient es der informellen Diskussion von Entwurfsentscheidungen.

Suchen in sortierten Folgen

Annahme:

Die Folge F ist ein Feld mit numerischen Werten. Dazu ist die Folge sortiert, das heißt, wenn i<j, dann ist F[i]<F[j]. Auf das i-te Element hat man Zugriff über F[i]. Es wird nur der Suchschlüssel berücksichtigt.

Ein Beispiel ist ein Telefonbuch, in dem wir nach Namen suchen möchten. Doch wie repräsentiert man diese Daten?

Einschub lineare Datenstrukturen

Definition

Eine lineare Datenstruktur L ist eine Sequenz $L=(a_{1}...,a_{n})$ . Die lineare Datenstruktur ordnet Elemente (entweder primitive Datentypen oder komplexere Datenstrukturen) in einer linearen Anordnung an.

Beispiel

Zahlenfolgen

5	4	6	1	3	2

Strings

L	I	N	E	A	R

Atomare Operationen

Zu den Operationen gehören Lesen mit

get(i): Element an Position i lesen
first(): erstes Element lesen
last(): letztes Element lesen
next(e): Element nach Element e lesen

und Schreiben mit

set(i,e): Element an Position i auf e setzen
add(i,e): Element e an Position i einfügen
del(i): Element an Position i löschen

Arrays und Listen

Es gibt zwei Möglichkeiten lineare Datenstrukturen zu realisieren. Entweder Arrays oder (verlinkte) Listen. Arrays belegen einen zusammenhängenden Bereich im Speicher. Elemente einer verlinkten Liste können beliebig verteilt sein. Ob zur Realisierung einer linearen Datenstruktur ein Array oder eine Liste verwendet wird, hängt von der Anwendung ab. Arrays werden meist für statische Datenstrukturen verwendet, d.h. wenn die Länge des Arrays nicht verändert wird. Listen werden meist für dynamische Datenstrukturen verwendet, d.h. wenn die Länge variabel ist. Zu den positiven Eigenschaften von Arrays zählen der schneller Zugriff auf Einzelelemente durch den Index. Zu den negativen Eigenschaften von Arrays zählen das sehr aufwändige Einfügen der Elemente. Zu den positiven Eigenschaften von Listen zählen die relativ effiziente Manipulation, zu den negativen Eigenschaften der ineffiziente Direktzugriff.

Einfache verlinkte Liste von Zahlen in Java

public class IntegerList { 
  private class IntegerListElement{ 
   int value; 
   IntegerListElement next; 
  } 
 
  IntegerListElement ﬁrst; 
  int size = 0; 
     private IntegerListElement getElement(int i){ 
   if(i+1 > size)  
    throw new IllegalArgumentException(); 
   int idx = 0; 
   IntegerListElement current = ﬁrst; 
   while(idx != i){ 
    current = current.next; 
    idx ++; 
   } 
   return current; 
  } 
  public int get(int i){ 
   return this.getElement(i).value; 
  } 
 public int add(int pos, int val){ 
   IntegerListElement newElem = new IntegerListElement(); 
   newElem.value = val; 
   if(pos > 0){ 
    IntegerListElement e = this.getElement(pos‐1); 
    newElem.next = e.next; 
    e.next = newElem; 
   }else{ 
    newElem.next = this.ﬁrst; 
    this.ﬁrst = newElem; 
   }

Suchen und Sortieren

Suchen und Sortieren sind voneinander abhängige Operationen. Dabei gibt es zwei Ansätze: Wenn Elemente nie sortiert sind, dann ist die Suche sehr aufwändig. Wenn die Elemente sortiert sind, wird die Suche erleichtert, jedoch kann das Sortieren an sich sehr aufwändig sein. Wenn Elemente hinzugefügt oder gelöscht werden ist diese Problematik noch sichtbarer. Nur ein unsortiertes Element macht die Suche aufwändig, doch bei jeder Einfügung oder Löschung zu sortieren ist ebenfalls sehr aufwändig. Spezielle dynamische Datenstrukturen erlauben eine automatische und effiziente Sortierung bei Einfügung oder Löschung. lol ist alles falsch ich bin ncool und ihr seid alle behindert

Lineare Datenstruktur in Java

Arrays:

int[] arr = new int[10];

arr[1] = 4;

Listen:

List<Integer> myList = new LinkedList<Integer>();

myList.add(5);

Neben LinkedList unterstützt Java eine Reihe weiterer Listenimplementierungen mit unterschiedlichen Vor- und Nachteilen
Schnittstelle List<Type> beinhaltet die gemeinsamen Methoden

Suche

Problembeschreibung

Die Eingabe ist eine Folge F mit n Elementen von Zahlen und Suchelementen k. Die Ausgabe ist eine erfolgreiche oder nicht erfolgreiche Suche. Erfolgreich ist sie, wenn der Index p

(0\leq p<n)

ist. Eventuell muss man festlegen, was bei Mehrfachvorkommen passiert. Normalerweise gilt dann das erste Vorkommen. Ist die Suche nicht erfolgreich, dann ist die Ausgabe -1.

Merkmale der Suche

Es gibt immer einen Suchschlüssel für Suchelemente, z.B. Zahlen. Außerdem ist eine Suche immer erfolgreich oder erfolglos. Die Suche basiert auf Vergleichsoperationen und die Daten sind zunächst als Feld, bzw. Array, oder Liste dargestellt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5 zu finden.

Sequentielle Suche

Dieses Kapitel handelt von der sequentiellen Suche. Die Idee dieses Suchalgorithmus ist, dass zuerst das erste Elemente der Liste mit dem gesuchten Elemente verglichen wird, wenn sie übereinstimmen wird der aktuelle Index zurückgegeben. Wenn nicht wird der Schritt mit dem nächsten Element wiederholt. Sollte das gesuchte Element bis zum Ende der Folge nicht gefunden werden, war die Suche erfolglos und -1 wird zurückgegeben.

Algorithmus

 
int SeqSearch(int[] F, int k) {
   / * output: Position p  (0 ≤ p ≤ n-1) */ 
} 
 int n = F.length;
 for (int i = 0; i < n; i++) { 
    if (F[i] == k) {
          return i; 
 }  
 return -1;  }

Dabei ist Int[] die sortierte Folge von int, int k der Suchschlüssel und die Folge F hat die Länge n.

Aufwands Analyse

Das Terminierungs-Theorem besagt, dass der Algorithmus SeqSearch für eine endliche Eingabe nach endlicher Zeit terminiert. Das Korrektheits-Theorem besagt, falls das Array F ein Element k enthält, gibt SeqSearch(F,k) den Indes des ersten Vorkommens von k zurück. Ansonsten gibt SeqSearch(F,k) den Wert -1 zurück Im besten Fall beträgt die Anzahl der Vergleiche 1, das heißt direkt bei dem ersten Suchdurchlauf wird der Suchschlüssel gefunden. Im schlechtesten Fall beträgt die Anzahl der Vergleiche n, das heißt im letzten Suchdurchlauf wird der Suchschlüssel gefunden. Der Durchschnitt bei einer erfolgreichen Suche beträgt (n+1)/2 und der Durchschnitt einer erfolglosen Suche n. Die Folgen müssen nicht sortiert sein. Der Algorithmus SeqSearch hat also eine Worst-Case Laufzeit von $\Theta (n)$ .

Sequentielle Suche in Java

 
public class SequentialSearch{
     public final static int NO_KEY = -1;

static int SeqSearch(int[] F, int k) {
   for (int i = 0; i < F.length; i++) 
   if (F[i] == k) 
         return i;
   return NO_KEY; 
}
 public static void main(String[ ] args){
    if (args.length != 1) {
           System.out.println(''usage: SequentialSearch 
             <key>'');
    return;
    }

    int[ ] f = {2, 4, 5, 6, 7, 8, 9, 11};
    int k = Integer.parseInt(args[0]);
    System.out.println(''Sequentiell:“+seqSearch(f,k));
 }
}

In der Klasse SeqSearch ist eine Konstante NO_KEY definiert, die als Ergebnis zurückgegeben wird, wenn der gesuchte Wert nicht im Feld gefunden wurde. Die Methode search wird schließlich in der Klassenmethode main aufgerufen, um das Feld f nach dem Schlüsselwert k zu durchsuchen. Dieser Wert ist als Parameter beim Programmaufruf anzugeben. Da die Programmparameter als Feld args von Zeichenketten übergeben werden, ist zuvor noch eine Konvertierung in einen int-Wert mit Hilfe der Methode parseInt der Klasse java.lang.Integer vorzunehmen. Somit bedeutet der Programmaufruf "java SeqSearch 4" die Suche nach dem Wert 4 in der gegebenen Folge. Der Aufruf erfolgt mit java SequentialSearch 4

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.1.1 zu finden.

Binäre Suche

Dieses Kapitel behandelt die binäre Suche. Wir stellen uns die Frage, wie die Suche effizienter werden könnte. Das Prinzip der binären Suche ist zuerst den mittleren Eintrag zu wählen und zu prüfen ob sich der gesuchte Wert in der linken oder rechten Hälfte der Liste befindet. Anschließend fährt man rekursiv mit der Hälfte fort, in der sich der Eintrag befindet. Voraussetzung für das binäre Suchverfahren ist, dass die Folge sortiert ist. Das Suchverfahren entspricht dem Entwurfsmuster von Divide-and-Conquer.

Beispiel

Rekursiver Algorithmus

int BinarySearch(int[] F, int k){  
  /*input: Folge F der Länge n, Schlüssel k */
  /*output: Position p */
   return  BinarySearchRec(F, k, 0, F.length-1); //initialer Aufruf
} 
int BinarySearchRec (int[] F, int k, int u, int o) {
  /* input: Folge F der Länge n, Schlüssel k,
        untere Schranke u, obere Schranke o */
  /* output: Position p */ 
 
 m = (u+o)/2;
 if  (F[m] ==  k) return m;
 if  ( u == o) return -1;
 if  (F[m] >  k) return BinarySearchRec(F,k,u,m-1);
 return BinarySearchRec(F,k,m+1,o); 
}

Aufwands Analyse

Das Terminierungs-Theorem besagt, dass der Algorithmus BinarySearch für jede endliche Eingabe F nach endlicher Zeit terminiert. In jedem Rekursionsschritt verkürzt sich die Länge des betrachteten Arrays F um mehr als die Hälfte. Nach endlichen vielen Schritten hat das Array nur noch ein Element und die Suche endet entweder erfolgreich oder erfolglos. Falls das Element vorher gefunden wird terminiert der Algorithmus schon früher.

Das Korrektheits-Theorem besagt, dass falls das Array F ein Element k enthält, gibt BinarySearch(F.k) den Index eines Vorkommens von k zurück. Ansonsten gibt BinarySearch (F,k) den Wert ‐1 zurück. Beweisen kann man das durch die verallgemeinerte Induktion nach der Länge n von F. n=1: Der erste Aufruf von BinarySearchRec ist BinarySearchRec(F,k,0,0) und somit m=0. Ist F[0]=k so wird 0 zurückgegeben, ansonsten ‐1 da 0=0. n>1: Der erste Aufruf von BinarySearchRec ist BinarySearchRec(F,k,0,n‐1) und somit m=(n‐1)/2. Ist F[m]=k, so wird m zurückgegeben. Ansonsten wird rekursiv auf F[0...m‐1] oder F[m+1...n] fortgefahren. Da die Folge sortiert ist, kann k nur in einem der beiden Teile vorhanden sein.

Da die Liste nach jedem Aufruf halbiert wird, haben wir nach dem ersten Teilen der Folge noch n/2 Elemente, nach dem zweiten Schritt n/4 Elemente, nach dem dritten Schritt n/8 Elemente... daher lässt sich allgemein sagen, dass in jedem i-ten Schritt maximal $n/2^{i}$ Elemente, das heißt $log_{2}n$ Vergleiche bei der Suche. Im besten Fall hat die Suche nur einen Vergleich, weil der Suchschlüssel genau in der Mitte liegt. Im schlechtesten Fall und im Durchschnitt für eine erfolgreiche und eine erfolglose Suche liegt die Anzahl der Vergleiche bei $log_{2}n$ .

Rekursionsgleichung

Für die erfolglose Suche ergibt sich folgende Rekursionsgleichung.

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&falls~n=1\\T(n/2)&sonst\end{array}}\right.$

Das Auflösen von T(n) nach Induktion ergibt eine $T(n)=\Theta (log~n)$ Laufzeit für eine erfolglose, also Worst-Case, Suche.

Iterativer Algorithmus

int  BinarySearch(int[] F, int k) {
   /* input: Folge F der Länge n, Schlüssel k */ 
   /*  output: Position p  (0 ≤ p ≤ n-1)  */
 
   int u = 0;
   int o = F.length-1; 
   int m;
   while (u <= o) { 
       m = (u+o)/2;
       if  (F[m] ==  k)
           return m; 
       else
           if (k < F[m]) 
               o = m-1;
           else
               u = m+1; 
 
  }    
  return -1;
}

Der erste Teil des Algorithmus ist die Initialisierung. Die while Schleife, besagt, dass so lange wiederholt werden soll, bis die angegebenen Schranken erreicht sind. Die if Anweisung ist die Abbruchbedingung. Der letzte Teil des Algorithmus (else) passt die obere, bzw. untere Schranke an.

Vergleich der Suchverfahren

Verfahren / #Elemente	$10$	$10^{2}$	$10^{3}$	$10^{4}$
sequenziell (n/2)	$\approx 5$	$\approx 50$	$\approx 500$	$\approx 5000$
binär $log_{2}n$	$\approx 3,3$	$\approx 6,6$	$\approx 9,9$	$\approx 13,3$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.1.2 zu finden.

Fibonacci Suche

Dieses Kapitel behandelt die Fibonacci Suche. Die im vorherigen Kapitel behandelte binäre Suche hat Nachteile. Die binäre Suche ist der am häufigsten verwendete Algorithmus zur Suche in sortierten Arrays. Die Sprünge zu verschiedenen Testpositionen sind allerdings immer recht groß. Dies kann nachteilig sein, wenn das Array nicht vollständig im Speicher vorliegt (oder bei Datenträgertypen wie Kassetten). Außerdem werden neue Positionen durch Division berechnet und je nach Prozessor ist dies eine aufwändigere Operation als Addition und Subtraktion. Daher nehmen wir die Fibonacci Suche als eine weitere Alternative.

Fibonacci Zahlen

Zur Erinnerung, die Folge der Fibonacci Zahlen $F_{n}$ für $n\geq 0$ ist definiert durch

 $F_{0}=0$ 
 $F_{1}=1$ 
 $F_{2}=1$ 
 $F_{i}=F_{i-1}+F_{i-2}$  für  $i>1$

i	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14
$F_{i}$	0	1	1	2	3	5	8	13	21	34	55	89	144	233	377

Anstatt wie bei der binären Suche das Array in gleich große Teile zu teilen, wird das Array in Teilen entsprechend der Fibonacci-Zahlen geteilt. Es wird zunächst das Element an Indexposition m betrachtet, wobei m die größte Fibonaccizahl ist, die kleiner als die Arraylänge ist. Nun fährt man rekursiv mit dem entsprechenden Teilarray fort.

Rekursive Fibonacci Suche

public int fibonacciSearch(int[] arr, int elem) {
	return fibonacciSearchRec(arr,elem,0,arr.length-1);
}

public int fibonacciSearchRec(int[] arr, int elem, int u, int o) {
	int k = 0;
	while (fib(k) < o-u) k++;
	if (elem == arr[u+fib(--k)])
		return u+fib(k);
	if (u == o)
		return -1;
	if (elem < arr[u+fib(k)])
		return fibonacciSearchRec(arr, elem, u, u+fib(k)-1);
	return fibonacciSearchRec(arr ,elem, u+fib(k)+1, o);
}

Beispiel

9	19	21	34	87	102	158	159	199	205

Wo befindet sich die 133?

fibonacciSearchRec(arr,133,0,9)
1. fib(6)=8 < 9-0 (und maximal)
2. arr[fib(6)+0] = arr[8] = 199 > 133
fibonacciSearchRec(arr,133,0,7)
1. fib(5)=5 < 7-0 (und maximal)
2. arr[fib(5)+0] = arr[5] = 102 < 133
fibonacciSearchRec(arr,133,6,7)
1. fib(0)=0 < 7-6 (und maximal)
2. arr[fib(0)+6] = arr[6] = 158 > 133
fibonacciSearchRec(arr,133,6,6)
1. Suche erfolglos

Wo befindet sich die 87?

fibonacciSearchRec(arr,87,0,9)
1. fib(6)=8 < 9-0 (und maximal)
2. arr[fib(6)+0] = arr[8] = 199 > 87
fibonacciSearchRec(arr,87,0,7)
1. fib(5)=5 < 7-0 (und maximal)
2. arr[fib(5)+0] = arr[5] = 102 > 87
fibonacciSearchRec(arr,87,0,4)
1. fib(4)=3 < 4-0 (und maximal)
2. arr[fib(4)+0] = arr[3] = 34 < 87
fibonacciSearchRec(arr,87,4,4)
1. Suche erfolgreich

Aufwands Analyse

Die Fibonacci Suche hat dieselbe Komplexität wie die binäre Suche. Die Anzahl der Vergleiche im besten Fall ist 1 und die Anzahl der Vergleiche im Durchschnitt (erfolgreich/erfolglos) und im schlechtesten Fall ist $log_{2}n$ . Die nötigen Fibonaccizahlen können vorab berechnet und in einem (statischen) Array gespeichert werden. Für Arrays mit weniger als 100.000.000 Elementen werden “nur” die ersten 50 Fibonaccizahlen benötigt. Als Operationen können nur Subtraktion und Addition genutzt werden und die “Sprünge” zwischen Arrayposition ist im Durchschnitt geringer als bei binärer Suche.

Einleitung Suchen in Texten

Nun behandeln wir das Suchen in Texten. Das Problem ist das Suchen eines Teilwortes in einem langen anderen Wort. Dies ist eine typische Funktion der Textverarbeitung. Nun ist eine effiziente Lösung gesucht. Das Maß der Effizienz ist hierbei die Anzahl der Vergleiche zwischen den Buchstaben der Worte. Den Vergleich von Zeichenketten nennt man String-Matching und eine nicht übereinstimmende Position nennt man Mismatch.

Vorgegebene Daten

Worte als Array:

- text[] zu durchsuchender Text

- pat[] 'Pattern', gesuchtes Wort

Wortlängen:

- n Länge des zu durchsuchenden Textes

- m Länge des gesuchten Wortes

$\sum$ Alphabet, $\epsilon$ leerer String

Abstrakte Algorithmenbeschreibung:

Eingabe: text[], pat[]

Ausgabe: Index i mit text[i...i+m]=pat[1...m+1] oder -1 falls das gesuchte Wort nicht im Text vorkommt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5 zu finden.

Einleitung Suchen in Texten

Nun betrachten wir einen naiven Algorithmus zur Textsuche.

Problem der Worterkennung

Direkte Lösung - brute force

a	b	a	c	a	a	b	a	c	c	a	b	a	c	a	b	a	a	b	b

a (1)	b (2)	a (3)	c (4)	a (5)	b (6)

a (7)	b	a	c	a	b

a (8)	b (9)	a	c	a	b

....

a (22)	b (23)	a (24)	c (25)	a (26)	b (27)

Pseudocode Brute Force Algorithmus

for i=1 to n-m+1 do

Falls pat = text[i...i+m-1] gib i zurück;

Gib -1 zurück

In Java:

  
int bruteforce_search(char[] text, char[] pat){
    int i,j;
    for(i = 0; i < text.length - pat.length+1; i++){
        for(j = 0; j < pat.length && pat[j] == text[i+j]; j++)
            ;
        if(j == pat.length)
            return i;
    }
    return -1;
}

Analyse

Das Terminierungstheorem besagt, dass der Algorithmus bruteforce_search bei endlicher Eingabe nach endlich vielen Schritten terminiert.

Das Theorem der Korrektheit besagt, wenn text die Zeichenkette pat enthält, so gibt bruteforce_search(text,pat) den Startindex des ersten Vorkommens von pat zurück, ansonsten -1.

Das Theorem der Laufzeit besagt, dass der Algorithmus bruteforce_search einen Worst-Case Laufzeit von $\Theta (mn)$ hat. Beweisen lässt sich das durch eine einfache Schleifenanalyse. Die äußere for-Schleife wird maximal (n-m)-mal durchlaufen, die innere for-Schleife wird jedes mal maximal m-mal durchlaufen:

$\Theta ((n-m)*m)=\Theta (mn)$

Dafür hat bruteforce_search nun einen Platzbedarf von $\Theta (1)$ . Kann man durch zusätzlichen Platzbedarf die Laufzeit verbessern?

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5 zu finden.

Einleitung Algorithmus von Knuth-Morris-Pratt

Auf dieser Seite behandeln wir den Algorithmus von Knuth-Morris-Pratt. Die Idee ist, dass bereits gelesene Informationen bei einem Mismatch genutzt werden. Kommt es an Stelle j von pat zum Mismatch, so gilt:

pat[1...j-1]=text[i...i+j-2]

a	b	a	c	a	a	b	a	c	c	a	b	a	c	a	b	a	a	b	b

a (1)	b (2)	a (3)	c (4)	a (5)	b (6)

Das a an Stelle 5 ist das Suffix von pat[1..5]. Nun gilt: schiebe Muster um 4, überprüfe weiter ab Position 6 im Text, ab Position 2 im Muster

a	b (7)	a	c	a	b

Das erste a ist nun das Präfix

a (8)	b (9)	a (10)	c (11)	a (12)	b

a (13)	b	a	c	a	b

a (14)	b (15)	a (16)	c (17)	a (18)	b (19)

Realisierung mit Fehlerfunktion

Bestimme für jedes j der Länge f[j] des längsten Präfixes von pat der Suffix von pat[1..j] ist. Gibt es einen Fehler an Stelle j, dann verschiebe die Suchposition im Muster auf j:=f[j-1]+1=border[j].

Position j im Pattern	1	2	3	4	5	6
Pattern pat[j]	a	b	a	c	a	b
Längster Präfix f[j]	0	0	1	0	1	2
Verschiebeposition	0	1	1	2	1	2

border im Detail

Preprocessing bedeutet, dass für jedes $j,1\leq j\leq m$ das größte k so bestimmt wird, dass pat [1...k-1] ein echter Suffix von pat[1...j-1] ist. Genauer berechnet und als border bezeichnet wird:

 $border[j]:=max_{a\leq k\leq j-1}\{k|pat[1...k-1]=pat[j-k+1...j-1]\}$

Bei einem Mismatch an Position j verschiebe die Position im Text auf i:=i+ border[j] )oder 1 falls nicht definiert, z.B. erste Position) und die Position im Suchmuster auf j:=border[j]

Die border-Tabelle

Beispiel: Drei Zeilen j, pat[j] und border [j]

1	2	3	4	5	6	7	8	9	10	11	12	13	j
a	b	a	a	b	a	b	a	a	b	a	a	b	pat[j]
0	1	1	2	2	3	4	3	4	5	6	7	5	border[j]

Dieses Beispiel ist ein so genannter Fibonacci String.

$F_{7}:$

$1.F_{0}=\epsilon ,F_{1}=b,F_{2}=a$

$2.F_{n}=F_{n-1}F_{n-2}$

Algorithmus von border

 
Eingabe: char-Array pattern[]
Ausgabe: int-Array border[]

int[] border = new int[pattern.length];
for(int k = 0; k < border.length; k++){
    border[k] = 0;
}

int i = 1, j = 0;
while(i < border.length){
     while(i+j < border.length-1 && 
           pattern[j] == pattern[i+j]){
        border[i+j+1] = max(border[i+j+1],j+1);
        j++;
     }
     i++;
}

sborder als Verbesserung von border

Problem:

pat:							a	b	a	a	b	a	-	-
text:	-	-	-	-	-	-	a	b	a	a	b	c	-	-

Hier gibt es ein mismatch an der Stelle j=g, border[6]=3. Daher muss um 3 verschoben werden.

pat:										a	b	a	a	b	a	-	-
text:	-	-	-	-	-	-	a	b	a	a	b	c	-	-

Nun haben wir als Result sofort wieder ein Mismatch. Wir wissen bereits, dass an der Mismatch Stelle kein a stehen darf.

Verbesserung:

 $sborder[j]=max_{1\leq k\leq j-1}\{k|pat[1...k-1]=pat[j-k+1...j-1]\land pat[k]\neq pat[j]\}$

Falls kein deratiges k existiert, dann 0.

Beispeil vier Zeilen mit j, pat[j], border[j] und sborder[j]:

1	2	3	4	5	6	7	8	9	10	11	12	13	j
a	b	a	a	b	a	b	a	a	b	a	a	b	pat[j]
0	1	1	2	2	3	4	3	4	5	6	7	5	border[j]
0	1	0	2	1	0	4	0	2	1	0	7	1	sborder[j]

Algorithmus

 
Eingabe: char-Array text[], char-Array pattern[]
Ausgabe: true/false

int[] sborder = new int[pattern.length];
for(int k = 0; k < sborder.length; k++){
    sborder[k] = 0;
}

int i = 1, j = 0;
while(i < sborder.length){
   while(i+j < sborder.length-1 && 
                pattern[j] == pattern[i+j]){
      if(pattern [j+1] == pattern[i+j+1])
          sborder[i+j+1] = max(sborder[i+j+1],j+1);
      j++;
    }
    i++;
}
i = 0;
j = 0;
while(i < text.length() - pattern.length() + 1){
     while(j < pattern.length() && text[i+j] == pattern[j]){
       j++;
     }
     if(j == pattern.length()) return true;
     i = i + max(border[j], 1);
     j = border[j];
}

Analyse

Das Theorem der Terminierung besagt, dass der Algorithmus von Knuth-Morris-Pratt für endliche text[] und pat[] eine endliche Laufzeit hat.

Das Theorem der Korrektheit besagt, wenn text die Zeichenkette pat enthält, so gibt der Algorithmus von Knu5‐Morris‐Pra5 TRUE zurück, ansonsten FALSE.

Das Theorem der Laufzeit besagt, dass der Algorithmus von Knutt-Morris-Pratt eine Worst-Case Laufzeit von $\Theta (m+n)$ hat. Beweisen kann man das durch eine einfache Schleifenanalyse: $\Theta (m)$ für die Berechnung von sborder und </math> \Theta (n) </math> für die Hauptschleife. Der zusätzliche Platzbedarf des Algorithmus von Knutt-Morris-Pratt ist $\Theta (m)$ .

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5 zu finden.

Sortieren

Dieses Kapitel gibt eine grundlegende Einführung in das Thema Sortieren. Sortieren ist ein grundlegendes Problem in der Informatik. Es beinhaltet das Ordnen von Dateien mit Datensätzen, die Schlüssel enthalten und das Umordnen der Datensätze, so, dass eine klar definierte Ordnung der Schlüssel (numerisch/alphabetisch) besteht. Eine Vereinfachung ist die Betrachtung der Schlüssel, z.B. ein Feld von int-Werten.

Ordnung

Partielle Ordnung

Sei M eine Menge und

\leq \subseteq (MxM)=

binäre Relation.

Es gilt:

Reflexivität $x\leq x\ \forall x\in M$
Transitivität $x\leq y\land y\leq z\to x\leq z~\forall x,y,z\in M$
Antisymmetrie $x\leq y\land y\leq x\to x=y~\forall x,y\in M$

Strikter Anteil einer Ordnungsrelation $\leq$

x<y:=x\leq y\land x\neq y

Totale Ordnung

Partielle Ordnung $(M,\leq )$
Trichotomie ("Dreiteilung") $x<y\lor x=y\lor x>y~\forall x,y\in M$

Grundbegriffe

Das Verfahren ist intern, wenn auf Hauptspeicherstruktur, wie Felder und Listen sortiert wird. Hingegen ist es extern, wenn die Datensätze auf externen Medien, wie Festplatten und weitere sortiert werden. Die Annahmen sind eine totale Ordnung, aufsteigend vs. absteigend und der Platzbedarf.

Problembeschreibung

Als Eingabe haben wir eine Folge von Zahlen $\langle a_{1},...,a_{n}\rangle$ . Als Ausgabe haben wir die Permutation $\langle a'_{1},...,a'_{n}\rangle$ der Zahlen mit der Eigenschaft $a'_{1}\leq a'_{2}\leq ,...,a'_{n}$ . Die Sortierung erfolgt nach einem Schlüssel, z.B. Zahlen. In Programmen ist es übertragbar auf beliebige Datenstrukturen mit Schlüssel.

Stabilität

Ein Sortierverfahren heißt stabil, wenn es die relative Reihenfolge gleicher Schlüssel in der Datei beibehält. Beispiel: alphabetisch geordnete Liste von Personen soll nach Alter sortiert werden. Personen mit gleichem Alter sollen weiterhin alphabetisch geordnet bleiben:

Name          Alter               Name          Alter
Aristoteles   24                  Aristoteles   24
Platon        28     SORTIEREN →  Platon        28
Sokrates      30                  Theophrastos  28
Theophrastos  28                  Sokrates      30

Sortieralgorithmen

Java Stub

public class InsertionSort extends Sort {
 /*
  * Sortiert die Sequenz a nach dem Verfahren  
  * „Sortieren durch Einfügen“
  */ 
 @Override
 public void execute(int[] a) {
  // Elemente: a[0], … , a[n-1] 
  int n=a.length;
  int x; 
  int j;
 
  // HIER KOMMT DER SORTIERALGORITHMUS
  // assert: a[0] <= … <= a[n-1] 
 }
}

Vergleichsbasiertes Sortieren

Das vergleichbasierte Sortieren ist ein wichtiger Spezialfall des Sortierproblems. Zur Sortierung können nur direkte Vergleiche zweier Werte benutzt werden. Der Wertebereich der Schlüssel kann beliebig sein. Als Eingabe haben wir ein Array ganzer Zahlen und als Ausgabe ein sortiertes Array mit den selben Zahlen mit erhaltenen Mehrfachvorkommen. Einige Sortierverfahren sind effizienter, wenn Listen anstatt Arrays benutzt werden.

Sortierinterface in Java

public interface Sort {

   /**
    * sorts the given array.
    * @param toSort - array to sort.
    */
    public void execute(int[] toSort);
}

Ausblick

Auf den folgenden Seiten werden die Sortieralgorithmen Insertion Sort, Selection Sort, Merge Sort und Quick Sort behandelt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2 zu finden.

InsertionSort

Dieses Kapitel behandelt die Sortiermethode InsertionSort oder auch Sortieren durch Einfügen genannt. Die Idee des Algorithmus ist, die typische menschliche Vorgehensweise, etwa beim Sortieren eines Stapels von Karten umzusetzen. Das heißt es wird mit der ersten Karte ein neuer Stapel gestartet. Anschließend nimmt man jeweils die nächste Karte des Originalstapels und fügt diese an der richtigen Stelle im neuen Stapel ein.

Beispiel

Java Code

void  InsertionSort(int[] F) {  

int m,j;
for (int i = 1; i < F.length; i++){
      j = i;
      m = F[i];
      while (j > 0 && F[j-1] > m) {
             /*verschiebe F[j-1] nach rechts */
              F[j] = F[j-1];
              j--;
       }
       F[j] = m;
     }
}

Das Array hat F.length viele Elemente von Position 0 bis F.Length-1. Wenn F[j-1] größer m ist, dann wird F[j-1] nach rechts verschoben. Am Ende des Algorithmus wird F[i] an Position F[j] gesetzt.

Analyse

Theorem der Terminierung

Das Theorem der Terminierung besagt, dass der Algorithmus InsertionSort für jede Eingabe int[] F nach endlicher Zeit terminiert.

Beweis

Die Laufvariable i in der äußeren for‐Schleife wird in jedem Durchgang um eins erhöht und wird damit irgendwann die Abbruchbedingung (eine Konstante)erreichen. Die Laufvariable j der inneren while‐Schleife wird in jedem Durchgang um eins verringert und somit die Schleifenbedingung j>0 irgendwann nicht mehr erfüllen.

Theorem der Korrektheit

Das Theorem der Korrektheit besagt, dass der Algorithmus InsertionSort das Problem des vergleichsbasierten Sortierens löst. Beweisen

Beweis

Wir zeigen, dass die folgende Aussage eine Invariante der äußeren for‐Schleife ist (d.h. sie ist am Ende eines jeden Schleifendurchgangs gültig): Das Teilarray F[0..i] ist sortiert Damit gilt auch, dass nach Abbruch der for‐Schleife das Array F[0..n]=F (mit n=F.length‐1) sortiert ist. Zu zeigen ist nun, dass am Ende jeden Durchgangs der äußeren for Schleife F[0...i] sortiert ist. Dies wird durch Induktion nach i gezeigt. Für i=1 gilt im ersten Durchgang wird das erste Element F[0] mit dem zweiten Element F[1] verglichen und ggfs. getauscht um Sortierung zu erreichen (while‐Bedingung). Für $i\to i+1$ gilt angenommen F[0...i] ist am Anfang der äußeren for‐Schleife im Durchgang i+1 sortiert. In der while‐Schleife werden Elemente solange einen Platz weiter nach hinten verschoben, bis ein Index k erreicht wird, sodass alle Elemente mit Index 0..k‐1 kleiner/gleich dem ursprünglichen Element an Index i+1 sind (Induktionsbedingung) und alle Elemente mit Index k+1...i+1 größer sind (while‐Bedingung). Das ursprüngliche Element an Index i+1 wird dann an Position k geschrieben. Damit gilt, dass F[0...i+1] sortiert ist.

Theorem der Laufzeit

Das Theorem der Laufzeit besagt, dass die Anzahl der Vergleichsoperationen von Insertion Sort im besten Fall $\Theta (n)$ ist und im durchschnittlichen und schlechtesten $O(n^{2})$ .

Beweis

Für die Aufwandsanalyse sind die Anzahl der Vertauschungen und der Vergleiche relevant. Allerdings dominieren die Vergleiche die Vertauschungen, das heißt es werden wesentlich mehr Vergleiche als Vertauschungen benötigt. Wir müssen in jedem Fall alle Elemente i:=1 bis n-1 durchgehen, d.h. immer Faktor n-1 für die Anzahl der Vergleiche. Dann müssen wir zur korrekten Einfügeposition zurückgehen

Im besten Fall ist die Liste schon sortiert. Die Einfügeposition ist gleich nach einem Schritt an Position i-1, d.h. die Anzahl der Vergleiche ist gleich der Anzahl der Schleifendurchläufe = n-1. Bei jedem Rückweg zur Einfügeposition nimmt man den Faktor 1. Somit beträgt die Gesamtzahl der Vergleiche: $(n-1)\cdot 1=n-1$ . Für große Listen lässt sich $n-1\approx n$ abschätzen. Damit haben wir einen linearen Aufwand.

Im mittleren Fall ist die Liste unsortiert. Die Einfügeposition befindet sich wahrscheinlich auf der Hälfte des Rückwegs. Bei jedem der n-1 Rückwege, muss ein (i-1)/2 Vergleich addiert werden. Die Gesamtzahl der Vergleiche beträgt dann:

$(n-1)/2+(n-2)/2+(n-3)/2+...+2/2+1/2$

$={\frac {(n-1)+(n-2)+(n-3)+...+2+1}{2}}$

$={\frac {1}{2}}\cdot {\frac {n\cdot (n-1)}{2}}$

$={\frac {n\cdot (n-1)}{4}}$

$\approx {\frac {n^{2}}{4}}$

Daraus ergibt sich ein quadratischer Aufwand, wenn konstante Faktoren nicht berücksichtigt werden.

Im schlechtesten Fall ist die Liste absteigend sortiert. Die Einfügeposition befindet sich am Ende des Rückgabewertes bei Position 1. Bei jedem der n-1 Rückwege müssen i-1 Elemente verglichen werden (d.h. alle vorherigen Elemente F[1...i-1]). Analog zu vorhergehenden Überlegungen, gibt es hier aber die doppelte Rückweglänge. Daraus ergibt sich die Gesamtanzahl der Vergleiche:

$(n-1)+(n-2)+(n-3)+...+2+1$ $={\frac {n\cdot (n-1)}{2}}$ $\approx {\frac {n^{2}}{2}}$

Daraus ergibt sich ein quadratischer Aufwand, wenn konstante Faktoren nicht berücksichtigt werden.

Optimierung

In der vorgestellten Version des Algorithmus wird die Einfügeposition eines Elements durch (umgekehrte) sequenzielle Suche gefunden. Verwendet man hier binäre Suche (das Teilarray vor dem aktuellen Element ist sortiert!) kann die Anzahl der Vergleichsoperationen gesenkt werden zu O(n log n) (genauere Analyse zeigt, dass die Zahl noch kleiner ist)

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.2 zu finden.

SelectionSort

Dieses Kapitel behandelt die Suchmethode SelectionSort. Die Idee dieses Suchalgorithmus ist, den jeweils größten Wert im Array zu suchen und diesen an die letzte Stelle zu tauschen. Anschließend fährt man mit der um 1 kleineren Liste fort.

Beispiel

Java Code

void  SelectionSort(int[] F) {  
   int  meinSackJuckt = F.length -1;
   while (meinSackJuckt >= 0) {
     /*bestimme größtes Element links v. Marker*/
       int max = 0;  /* Indexposition*/
       for (int i = 1; i <= meinSackJuckt; i++){
           if (F[i] > F[max])
               max = i;
       swap(F, meinSackJuckt, max);
       meinSackJuckt--;   /*verkleinere Array */
   }
void  swap(int[] F, int idx1, int idx2) {  
    int tmp = F[idx1];
    F[idx1] = F[idx2];
    F[idx2] = tmp;
}

In Java benutzt man die Hilfsmethode swap, welche zwei Elemente im Array vertauscht.

Analyse

Theorem der Terminierung

Das Theorem der Terminierung besagt, dass der Algorithmus SelectionSort für jede Eingabe int[]F nach endlicher Zeit terminiert.

Beweis

Die Variable marker wird zu Anfang des Algorithmus auf einen positiven endlichen Wert gesetzt und in jedem Durchgang der äußeren while‐Schleife um 1 verkleinert. Abbruch der while Schleife erfolgt, wenn marker kleiner 0 ist, also wird die while‐Schleife endlich oft durchlaufen. Die innere for‐Schleife hat in jedem Durchgang marker‐viele (also endlich viele) Durchläufe.

Theorem der Laufzeit

Das Theorem der Laufzeit besagt, dass der Algorithmus SelectionSort eine Laufzeit von $\Theta (n^{2})$ hat im besten, mittleren und schlechtesten Fall.

Beweis

Die äußere while‐Schleife wird genau n‐mal (n=F.length) durchlaufen. Dort werden somit n Vertauschungen vorgenommen (=jeweils konstanter Aufwand). Die innere for‐Schleife hat im i‐ten Durchlauf der while‐Schleife n‐i Durchläufe mit jeweils einem Vergleich, deswegen insgesamt

$(n-1)+(n-2)+(n-3)+...+1$ $={\frac {n\cdot (n-1)}{2}}\approx {\frac {n^{2}}{2}}$

Die Anzahl der Vergleiche ist im besten, mittleren und schlechteste Fall identisch, da immer das komplette Array durchlaufen wird.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.3 zu finden.

BubbleSort

Dieses Kapitel behandelt die Suchmethode BubbleSort. Es handelt sich hierbei um ein sehr bekanntes, aber nicht besonders effizientes Sortierverfahren. Es ist eine einfach zu implementierende zugrunde liegende Vorstellung. Bei einer vertikalen Anordnung von Elementen in Form von Luftblasen (bubbles) werden wie in einer Flüssigkeit von alleine sortiert, da die größeren Blasen die kleiner „überholen“. Das Grundprinzip ist somit die Folge immer wieder zu durchlaufen und dabei benachbarte Elemente, die nicht die gewünschte Sortierreihenfolge haben, zu vertauschen. Das bedeutet Elemente die größer sind als ihre Nachfolger, überholen diese.

Beispiel

Java Code

void  BubbleSort(int[] F) {  
     
    for (int n= F.length; n >1; n=n-1) { 
      for (int i =0; i < F.length-1; i++)  {
           if (F[i] > F[i+1]){
               swap(F, i, i+1);
           }
       }
    }
}

Hierbei handelt es sich um die einfachste Form, doch der Algorithmus kann auch optimiert werden. Wir haben beobachtet, dass die größte Zahl in jedem Durchlauf automatisch an das Ende der Liste rutscht. Daraus folgt in jedem Durchlauf j reicht die Untersuchung bis Position n-j, das heißt im j.ten Durchlauf sind die Elemente zwischen den Positionen n-j und n-1 sortiert. Wenn keine Vertauschung mehr stattfindet, soll das Programm abbrechen.

void  BubbleSort(int[] F) {  
   boolean swapped;
   int n = F.length;
   do {
       swapped = false;
       for (int i =0; i < n-1; i++)  {
           if (F[i] > F[i+1]){
               swap(F, i, i+1);
               swapped = true;
           }
       }
       n--;
    }while (swapped);
  
}

Aufwand

Im besten Fall beträgt der Aufwand n. Im mittleren Fall ohne Optimierung $n^{2}$ und mit Optimierung ${\frac {n^{2}}{2}}$ . Im schlechtesten Fall ohne Optimierung beträgt der Aufwand $n^{2}$ und mit Optimierung ${\frac {n^{2}}{2}}$ .

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.4 zu finden.

MergeSort

In diesem Kapitel wird der Sortieralgorithmus MergeSort behandelt.

Rückblick

Die bisherige Verfahren erforderten einen direkten Zugriff auf einzelne Elemente (z.B. in einem Array). Sie sind besonders geeignet für internes Sortieren. Allerdings gibt es Probleme, wenn Daten sortiert werden sollen, die nicht in den den Hauptspeicher passen. Daher brauchen wir andere Verfahren, die nicht zwingend Elemente intern verwalten. Das Prinzip dieser Algorithmen ist das Sortieren in mehreren Phasen oder Schritten.

Idee

MergeSort ist ein Divide-and-Conquer Algorithmus zum vergleichsbasierten Sortieren. Zuerst wird die zu sortierende Folge in zwei Teile geteilt. Anschließend werden beide Teile voneinander getrennt sortiert. Zuletzt werden beide Teilergebnisse in der richtigen Reihenfolge zusammen gemischt.

Beispiel

Algorithmus

void mergeSort(int[] F) {
    int[] tmpF = new int[F.length];
    mergeSort(F, tmpF, 0, F.length -1);
}


void mergeSort(int[] F, int[] tmpF, int left,int right)
{ 
    if (left < right) {
        int m = (left + right)/2;
        mergeSort(F, tmpF, left, m);
        mergeSort(F, tmpF, m+1, right);
        merge(F, tmpF, left, m+1, right);
    }
}
void merge(int[] F, int[] tmpF, int startLeft, int startRight, int endRight) {
  int endLeft = startRight-1;
  int tmpPos = startLeft;
  int numElements = endRight – startLeft +1;
  while (startLeft <= endLeft && startRight <= endRight)
     if (F[startLeft] < F[startRight])
         tmpF[tmpPos++] = F[startLeft++];
     else
         tmpF[tmpPos++] = F[startRight++];
  
  while (startLeft <= endLeft)
      tmpF[tmpPos++] = F[startLeft++];
  while (startRight <= endRight)
      tmpF[tmpPos++] = F[startRight++];
  
  for (int i = 0; i < numElements; i++, endRight--)
         F[endRight] = tmpF[endRight];
}

Das Abbruchkriterium für den rekursiven Aufruf ist eine einelementige Liste.Der Misch-Vorgang erfordert in der Regel doppelten Speicherplatz, da eine neue Folge aus den beiden Sortierten generiert werden muss. Eine Alternative ist das Mischen in einem Feld (in-place), das erfordert aber aufwendiges Verschieben.

Analyse

Theorem der Terminierung

Das Theorem der Terminierung besagt, dass der Algorithmus MergeSort für jeden Eingabe int[]F nach endlicher Zeit terminiert.

Beweis

Zeige zunächst, dass jeder Aufruf mergeSort(int[] F, int[] tmpF, int left,int right) terminiert:  

Falls lef < right nicht gilt, terminiert der Aufruf sofort
Andernfalls rufen wir mergeSort rekursiv auf, wobei entweder lef einen echt größeren oder right einen echt kleineren Wert erhält. In jedem Fall wird nach einem gewissen rekursiven

Abstieg irgendwann lef<right nicht mehr gelten.

Theorem der Korrektheit

Das Theorem der Korrektheit besagt, dass der Algorithmus MergeSort das Problem des vergleichsbasierten Sortierens löst.

Beweis

Durch Induktion nach n = F.length. Annahme n=2 für eine ganze Zahl k.

n=1: Für n=1 ist der erste Aufruf der mergeSort Hilfsmethode mergeSort(F, tmpF, 0, 0)

und somit gilt nicht lef < right. Die Methode terminiert ohne Änderung an F. Dies ist korrekt, da jedes einelementige Array sortiert ist.

n/2 → n: Sei F[0...n‐1] ein beliebiges Array. Der erste Aufruf mergeSort(F, tmpF, 0, n-1) erfüllt lef<right und es werden folgende Rekursive Aufrufe getätigt: mergeSort(F, tmpF, 0, n/2-1) mergeSort(F, tmpF, n/2, n-1) Beide Aufrufe erhalten ein Array der Länge n/2. Nach Induktionsannahme gilt, dass anschliessend sowohl F[0...n/2‐1] als auch F[n/2...n‐1] separat sortiert sind. Noch zu zeigen ist, dass merge korrekt zwei sortierte Arrays in ein sortiertes Array mischt.

Theorem der Laufzeit

Das Theorem der Laufzeit besagt, dass der Algorithmus MergeSort eine Laufzeit von $\Theta (nlog_{2}n)$ hat. Diese Laufzeit ist die selbe für den besten, mittleren und schlechtesten Fall.

Beweis

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}n\leq 1\\2T(n/2)+\Theta (n)&sonst\end{array}}\right.$

Nun wenden wir das Master Theorem an.

Im 2. Fall, wenn $f(n)\in \Theta (n^{log_{b}a}*ld^{k}n){\text{ für ein }}k\geq 0{\text{ dann }}T(n)=\Theta (n^{log_{b}a}*ld^{k+1}n)$

Hier ist a=2 und b=2 und es folgt $n^{log_{b}a}=n^{log_{2}2}=n^{1}=n.$

Es ist zudem f(n)=n und es gilt für k=0:

$n\in \Theta (n~ld^{k}~n)=\Theta (n)$

Es folgt $T(n)\in \Theta (n~ld^{k+1}~n)=\Theta (n~ld~n).$

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.5 zu finden.

Zwischenbemerkungen

An dieser Stelle gibt es einige Zwischenbemerkungen zu den vorgestellten Sortieralgorithmen.

Einordnung der elementaren Sortierverfahren

	Implementierung Array	Implementierung Liste
greedy	selection sort, bubble sort	insertion sort
divide-and-conquer	quicksort	merge sort

Eigenschaften

Divide and conquer bedeutet teile und herrsche. Dabei wird das eigentliche Problem so lange in kleiner und einfachere Teilprobleme zerlegt, bis man diese lösen kann. Oft können Teilprobleme parallel gelöst werden. Des Weiteren sind Teilprobleme „eigenständige“ Probleme. Anschließend werden die Teillösungen zu einer Gesamtlösung zusammengeführt.

Greedy bedeutet gierig. Hierbei wird schrittweise ein Folgezustand ausgewählt, der aktuell den größten Gewinn und das beste Ergebnis verspricht. Die Auswahl des Folgezustands erfolgt anhand von Bewertungsfunktionen und Gewichtsfunktionen. Ein Problem dabei ist, dass oft nur ein lokales Maximum gewählt wird. Mehr dazu im Thema Entwurfsmuster.

Generische Implementierung

Algorithmen werden „parametrisiert“ durch Vergleichsoperator. Im Paket java.lang gibt es dafür ein Interface Comparable. Der Aufruf der Vergleichsmethode a.compareTo(b) liefert ein Zahl <0, =0, >0 für a<b, a=b und a größer b. Das Muster für Objekte vom Referenztyp Comparable lautet:

public class MyObject  implements Comparable {
      MyType data;
      public int compareTo (MyObject obj) {
            if („this.data < obj.data“) return -1;
            if („this.data = obj.data“) return 0;
            if („this.data > obj.data“) return 1;
     }
}

Das Muster für Aufrufe in Klassenmethoden bei Suchverfahren lautet:

 

public static int binarySearch( Comparable[] f,
       Comparable a,  int l,  int r) {
           int p = (l+r)/2; 
           int c = f[p].compareTo(a);
  ... }

Listenimplementierung generisch

 

public class MyObject implements Comparable {. . .}

public class Node { 
    MyObject data;    
    Node next;   
}
public class OrderedList { 
 private Node head;  
 public OrderedList sort ( ) {. . .}

Interne Hilfsmethoden

int findMin(){...}
- F.findMin() bestimmt den Index des minimalen Elements von OrderedList F
void insertLast(int a)
- F.insertLast(a) fügt Element mit Index (Key) a an das Ende von F an
void deleteElem(int a)
- F.deleteElem(a) löscht Element mit Index a aus der Liste F
Aufwand: jeweils = O(n), wenn n = Anzahl der Objekte in Liste

MergeSort generisch

 

public class OrderedList {
   OrderedNode head;
   int length;
   // ...

   /**    * Sorts this list in non-descending order       */
   public void mergeSort() {
     OrderedList aList, bList; // the divided lists
     OrderedNode aChain; // start of first node chain
     OrderedNode bChain; // start of second node chain
     OrderedNode tmp; // working node for split

     // trivial cases
     if ( (head==null) ||  (head.next == null) ) 
          return; 
// divide: split the list in two parts
    aChain = head;
    tmp = head;      // init working node for split
    // advance half of the list
    for (int i=0; i < (length-1) / 2; i++)
      tmp=tmp.next;

    // cut chain into aChain and bChain
    bChain=tmp.next;
    tmp.next=null;

    // encapsulate the two node chains in two lists 
    aList = new OrderedList();
    aList.head=aChain;
    aList.length=length/2;
    bList = new OrderedList();
    bList.head=bChain;
    bList.length=length - aList.length;

    // conquer: recursion
    aList.mergeSort(); bList.mergeSort();
    // join: merge
    merge(aList, bList);
  }
}

Aus Gründen der Übersichtlichkeit erzeugt dieses Programm im Divide-Schritt jeweils gekapselte Zwischenlisten vom Typ OrderedList. In der Praxis würde man hierauf verzichten und rein auf Knoten-Ketten arbeiten, da insgesamt O(n) Objekte vom Typ OrderedList erzeugt und wieder vernichtet werden(maximal O(log n) davon sind gleichzeitig aktiv).

QuickSort

In diesem Kapitel wird der Sortieralgorithmus QuickSort behandelt.

Idee

Es gibt eine rekursive Aufteilung (wie bei MergeSort), aber hier werden Mischvorgänge vermieden (speicherintensiv!). Die Teillisten werden in zwei Hälften geteilt bezüglich eines Pivot-Elements, wobei in einer Liste alle Elemente größer als das PivotElement sind und in der anderen Liste alle kleiner. Das Pivot Element ist ein beliebiges Element der Liste/Folge, z.B. das linke, mittlere oder rechte Element.

Beispiel

Vertauschen von Elementen

Für gegebenes Pivot-Element p wird die Folge von links durchsuchen, bis das Element gefunden wurde, das größer oder gleich p ist. Und gleichzeitig wird die Folge von rechts durchsuchen, bis das Element gefunden ist, das kleiner p ist. Dabei werden die Elemente ggf. getauscht.

Sortierprinzip

Sortieren einer Folge F[u...o] nach dem „divide-and-conquer“Prinzip. Divide heißt die Folge F[u...o] wird in zwei Teilfolgen F[u...p-1] und F[p+1...o] geteilt. Die zwei Teilfolgen haben folgende Eigenschaften:

F[i] ≤ F[p] für alle i = u,...,p-1
F[i] > F[p] für alle i = p+1, …, o

Conquer bedeutet, dass die Teilfolgen sortiert werden. Mit combine werden die Teilfolgen zu F[u...o] verbunden. Vergleiche sind an dieser Stelle nicht erforderlich, da die Teilfolgen bereits sortiert sind.

Pivot Element

Im Prinzip muss man nicht das letzte Element als Pivot‐Element wählen. Je nach Verteilung der Daten, kann es sinnvoll sein ein anderes Element zu wählen. Wenn beispielsweise die Liste schon fast sortiert ist, sollte man immer das mittlere Element wählen Eine optimale Rekursion erhält man, wenn man immer den Median als Pivot-Element wählt (dieser ist aber nicht direkt bestimmbar, dafür müsste man die Liste erst sortiert haben. Hat man ein Pivot-Element ausgewählt, tauscht man dies einfach mit dem letzten Element und benutzt den Algorithmus wie zuvor.

Algorithmus

void quickSort(int[] F, int u, int o) {
     if (u < o) {
        int p = (u+o)/2;
        int pn = zerlege(F,u,o,p);
        quickSort(F,u,pn-1);
        quickSort(F,pn+1,o);
     }
int zerlege(int[] F, int u, int o, int p) {
     int pivot = F[p];
     int i = u;
     int j = o;    
  
     while (i < j) {
         while (F[i] < pivot)
             i++;
         while (F[j] > pivot)
             j--;
         if (i < j) {
             swap(F,i , j );
         }
     }
     return i;
} 
int zerlege(int[] F, int u, int o, int p) {     
     int pivot = F[p];

     //Tausche Pivot-Element mit dem letzten Element 
     //kann entfallen, wenn immer p=o gewählt wird
     swap(F,p, o);    
     int pn = u;

     //bringe kleinere Elemente nach vorne und größere nach hinten
     for (int j = u; j < o; j++) {    
          if (F[j] <= pivot){ 
               swap(F,pn, j );
               pn++;
          }
     }

     //bringe das Pivot-Element an die richtige Position und gebe diese zurück
     swap(F,pn, o);     
     return pn;
} 

void swap(int[] f, int x, int y){   //Hilfsmethode zum Vertaucshen
   int tmp = f[x];
   f[x] = f[y];
   f[y] = tmp;
}

}

P gibt an ,an welcher Position das Pivot Element ist. Bei diesem Beispiel ist es in der Mitte. Es kann aber auch an Stelle o oder u sein.

Beispiel 1

Zerlege (F,0,6,3) mit 3=(0+6)/2

8	2	1	5	9	7	3

...

3	2	1	5	9	7	3

Beispiel 2

Sei f[8]=5 das Pivot-Element

8	9	2	6	7	3	4	1	5

Suche von links aus das Element, welches kleiner als das Pivot-Element ist

8	9	2	6	7	3	4	1	5

Vertausche mit dem ersten größeren Element

2	9	8	6	7	3	4	1	5

Suche das nächste kleinere Element als die 5

2	9	8	6	7	3	4	1	5

Vertausche dieses mit dem zweiten größeren Element

2	3	8	6	7	9	4	1	5

Suche wieder das nächste kleinere Element

2	3	8	6	7	9	4	1	5

und vertausche dies mit dem dritt größeren Element

2	3	4	6	7	9	8	1	5

2	3	4	6	7	9	8	1	5

2	3	4	1	7	9	8	6	5

nun ist man rechts angekommen und hier wird nun das Pivot-Element getauscht

2	3	4	1	5	9	8	6	7

Von nun an steht das Pivot-Element an seiner finalen Position. Alle Elemente links vom Pivot-Element sind kleiner und alle auf der rechten Seite sind größer. Das bedeutet, dass nun ein rekursiver Abstieg für die Folgen

2	3	4	1

und

9	8	6	7

beginnen würde. Wenn das letzte Element wieder als Pivot-Element gewählt werden würde, dann hat die erste erste Folge nun das Pivot-Element 1 und in der zweiten Folge währe es das Element 7.

Alternative: Zerlegung mit while-schleifen

Man wählt zuerst ein Pivotelement, beispielsweise das mittlere Element. Nun beginnt man von unten an und vergleicht die Einträge mit dem Pivot. Danach beginnt man von oben und vergleicht die Elemente mit dem Pivot. Wenn ein Element kleiner bzw. größer ist als das Pivot Element, dann wird dieses Element getauscht.

Analyse

Theorem der Terminierung

Das Theorem der Terminierung besagt, dass der Algorithmus quickSort für jede Eingabe int[]F nach endlicher Zeit terminiert.

Beweis

In jedem rekursiven Aufruf von quickSort ist die Eingabelänge um mindestens 1 kleiner als vorher und die Rekursionsanfang ist erreicht wenn die Länge gleich 1 ist. In der Methode split gibt es nur eine for‐Schleife, dessen Zähler j in jedem Durchgang inkrementiert wird. Da u<o wird die for‐Schleife also nur endlich oft durchlaufen.

Theorem der Korrektheit

Das Theorem der Korrektheit besagt, dass der Algorithmus quickSort das Problem des vergleichsbasierten Sortierend löst.

Beweis

Die Korrektheit der Methode swap ist zunächst offensichtlich. Zeige nun, dass nach Aufruf pn=split(f,u,o,p) für u<o und $p\in [u,o]$ gilt:

f[p] wurde zu f[pn] verschoben

Dies ist klar (vorletzte Zeile der Methode split)

f[i] ≤ f[pn] für i=u,...,pn‐1

pn wird zu anfangs mit u initialisiert und immer dann inkrementiert, wenn die Position f[pn] durch ein Element, das kleiner/gleich dem Pivot‐Element ist, belegt wird.

f[i] > f[pn] für i=pn+1,...,o

Folgt aus der Beobachtung, dass in 2.) immer „genau dann“gilt. Beachte zudem, dass Element immer getauscht werden, also die Elemente im Array stets dieselben bleiben.

Die Korrektheit der Methode quickSort folgt nach Induktion nach der Länge von f (n=f.length):

  n=1: Der Algorithmus terminiert sofort und ein einelementiges Array ist stets sortiert
  n→n+1: Nach Korrektheit von split steht das Pivot‐Element an der richtigen Stelle und links und rechts stehen jeweils nur kleinere/größere Element. Die beiden rekursiven Aufrufe von quickSort erhalten jeweils ein Array, das echt kleiner als n+1 ist (mindestens das Pivot‐Element ist nicht mehr Teil des übergebenen Arrays). Nach Induktionsannahme folgt die Korrektheit von quickSort.

Theorem der Laufzeit

Das Theorem der Laufzeit besagt, dass wenn als Pivot Element stets der Median des aktuell betrachteten Arrays gewählt wird, so hat der Algorithmus quickSort eine Laufzeit von $\Theta (n~log~n)$ .

Beweis

Es gilt zunächst, dass split $\in \Theta (n)(mit~n=o-u)$ . Ausschlaggebend ist hier die for-Schleife, die genau n-mal durchlaufen wird. Gilt nach dem Aufruf von split stets pn=(u+o)/2 (dies ist gleichbedeutend damit, dass das Pivot‐Element stets der Median ist), so erhalten wir folgende Rekursionsgleichung für quickSort:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}n\leq 1\\2T((n-1)/2)+\Theta (n)&sonst\end{array}}\right.$

Die ist fast dieselbe Rekursionsgleichung wie für MergeSort und es folgt $T(n)\in \Theta (n~log~n).$

Doch was ist, wenn die Voraussetzung des Theorems nicht erfüllt ist und wir ungleiche Rekursionsaufrufe haben?

Theorem der Laufzeit 2

Das Theorem der Laufzeit besagt, dass der Algorithmus quickSort im schlechtesten Fall eine Laufzeit von $\Theta (n^{2})$ hat.

Beweis

Angenommen, die Aufteilung erzeugt ein Teilarray mit Länge n‐1 und ein Teilarray mit Länge 0 (Pivot‐Element ist also immer Minimum oder Maximum), dann erhalten wir folgende Rekursionsgleichung für die Laufzeit:

$T(n):=\left\{{\begin{array}{ll}\Theta (1)&{\text{für }}n\leq 1\\2T(n-1)+\Theta (n)&sonst\end{array}}\right.$

Durch Induktionsbeweis kann leicht gezeigt werden, dass $T(n)\in \Theta (n^{2})$ . Dies ist auch tatsächlich der schlechteste Fall.

Für den mittleren Fall kann gezeigt werden, dass quickSort einen Aufwand von $\Theta (n~log~n)$ hat (wie im besten Fall), die in $\Theta$ versteckten Konstanten sind nur etwas größer.

Bemerkung

Im Gegensatz zu MergeSort ist QuickSort durch die Vorgehensweise bei Vertauschungen instabil, d.h. relative Reihenfolge gleicher Schlüssel werden nicht notwendigerweise beibehalten.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.6 zu finden.

Untere Schranke

Auf dieser Seite wird die untere Schranke für vergleichbare Sortierverfahren behandelt.

Eigenschaften der betrachteten Algorithmen

Die Komplexität im Durchschnittsfall und im Schlechtesten Fall ist nie besser als n ‧ log n. Die Sortierung erfolgt ausschließlich durch Vergleich der Eingabe-Elemente (comparison sorts), es handelt sich somit um vergleichsorientierte Sortierverfahren. Nun zeigen wir, dass n ‧ log n Vergleiche eine untere Schranke für „Comparison Sort“-Algorithmen ist. Dies heißt dann, dass Sortieralgorithmen mit Komplexität (schlechtester Fall) von n ‧ log n (z.B. MergeSort) asymptotisch optimal sind.

Problembeschreibung

Zuerst die Problembeschreibung. Als Eingabe haben wir $\langle a_{1},a_{2},...,a_{n}\rangle$ . Als Vergleichstests nehmen wir $a_{i}<a_{j},a_{i}\leq a_{j},a_{i}\equiv a_{j},a_{i}\geq a_{j},a_{i}>a_{j}$ . Als vereinfachte Annahmen nehmen wir an, dass es nur verschiedene Elemente gibt, somit entfällt $a_{i}\equiv a_{j}$ . Die restlichen Test liefern alle gleichwertige Informationen. Sie bestimmen die Reihenfolge von $a_{i}~und~a_{j}$ . Außerdem können sie und auf $a_{i}\leq a_{j}$ beschränken. Somit haben wir eine binäre Entscheidung und es gilt entweder $a_{i}\leq a_{j}~oder~a_{i}>a_{j}$

Entscheidungsbaum

Eine beispielhafte Eingabe ist $a_{1}=6,a_{2}=8,a_{3}=5$ Die inneren Knoten vergleichen die Elemente $a_{i}~und~a_{j}$ . Es wird ein Test durchgeführt ob $a_{i}\leq a_{j}$ gilt oder nicht. Die Blätter sind Permutationen mit $\langle \pi (a_{1}),...,\pi (a_{n})\rangle$ Sortieren heißt das Finden eines Pfades von der Wurzel zu einem Blatt. An jedem internen Knoten erfolgt ein Vergleich und entsprechend wird links oder rechts weiter gesucht. Ist ein Blatt erreicht, dann hat der Sortieralgorithmus eine Ordnung und die Permutation der Elemente ist erstellt. Daraus lässt sich schlussfolgern, dass jeder Sortieralgorithmus jede Permutation der n Eingabe-Elemente erreichen muss (n!). Daraus folgt wiederum, dass es n! Blätter geben muss, die alle von der Wurzel erreichbar sind. Andernfalls kann er zwei unterschiedliche Eingaben nicht unterscheiden und liefert für beide dasselbe Ergebnis und eins davon muss falsch klassifiziert sein. Die Anzahl an Vergleichen im schlechtesten Fall ist die Pfadlänge von Wurzel bis Blatt, oder auch Höhe genannt.

Somit erhalten wir das Theorem, dass jeder vergleichsorientierte Sortieralgorithmus im schlechtesten Fall mindestens n*log n Versuche braucht.

Beweis

Gegeben ist die Anzahl der Elemente n, h die Pfadlänge bzw. Höhe des Baums und b die Anzahl der Blätter. Jede Permutation muss in einem Blatt sein, das bedeutet $n!\leq b$ . Der Binärbaum hat die Höhe h und maximal $2^{h}$ Blätter, daraus folgt $n!\leq b\leq 2^{h}$ . Wenn man nun logarithmiert, erhält man

$h\geq log_{2}(n!)$

\sim n\cdot log_{2}(n)

(genauer~=\Omega (n\cdot log_{2}(n)))

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 5.2.7 zu finden.

Dynamische Datenstrukturen

Auf dieser Seite wird es eine Einführung in die dynamischen Datenstrukturen geben. Unter dynamischen Datenstrukturen verstehen wir Datenstrukturen bei denen man Elemente löschen und hinzufügen kann, eine interne Ordnung (z.B. Sortierung) vorliegt und diese Ordnung unter Änderungen aufrecht erhalten bleibt. Ein Beispiel sind Lineare Datenstrukturen und Sortierung. Bei unsortierte Liste sind Änderung einfach, aber Zugriff aufwändig. Bei einer Neusortierung einer Liste sind Änderung schwierig, aber Zugriff einfach. Bei Trade-of ist eine “intelligente Datenstruktur” gesucht, die Änderungen und Zugriffe einfach, sprich effizient, halten. Viele dynamische Datenstrukturen nutzen Bäume als Repräsentation.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 8.5 zu finden.

Bäume

In diesem Kapitel werden Bäume als kurzen Einschub behandelt. Ein Baumelement e ist ein Tupel $e=(v,\lbrace e_{1},...,e_{n}\rbrace )$ mit v vom Wert e und $\lbrace e_{1},...,e_{n}\rbrace$ sind die Nachfolger, bzw. Kinder von e. Ein Baum T ist ein Tupel $T=(r,\lbrace e_{1},...,e_{n}\rbrace )$ mit r als Wurzelknoten (ein Baumelement) und $\lbrace e_{1},...,e_{n}\rbrace$ als Knoten (Baumelemente) des Baumes mit $r\in \lbrace e_{1},...,e_{n}\rbrace$ und für alle $e_{i}=(v_{i},K_{i})~und~e_{j}=(v_{j},K_{j})\in \lbrace e_{1},...,e_{n}\rbrace ~gilt~K_{i}\bigcap K_{j}=\emptyset$

Man spricht von einem geordneten Baum, wenn die Reihenfolge der Kinder $\lbrace e_{1},..,e_{n}\rbrace$ eines jeden Elements $e=(v,\lbrace e_{1},...,e_{n}\rbrace )$ festgelegt ist (schreibe dann $(e_{1},...,e_{n})$ statt $\lbrace e_{1},...,e_{n}\rbrace ).$

Beispiel

$T=(v_{4},\lbrace v_{1},v_{2},v_{3},v_{4},v_{5}\rbrace )$

$v_{1}=(1,\lbrace \rbrace )$

$v_{2}=(2,\lbrace v_{1},v_{3}\rbrace )$

$v_{3}=(3,\lbrace \rbrace )$

$v_{4}=(4,\lbrace v_{2},v_{5}\rbrace )$

$v_{5}=(5,\lbrace \rbrace )$

$T'=(v_{4},\lbrace v_{2},v_{5}\rbrace )$

$v_{2}=(2,\lbrace v_{5}\rbrace )$

$v_{4}=(4,\lbrace v_{2},v_{5}\rbrace )$

$v_{5}=(5,\lbrace \rbrace )$

T' ist kein Baum, da $v_{4}~und~v_{2}$ ein gemeinsames Kind haben.

Begriffe

Ein Pfad folgt über Kanten zu verbundenen Knoten, dabei existiert zu jedem Knoten genau ein Pfad von der Wurzel. Ein Baum ist immer zusammenhängend und zyklenfrei.

Das Niveau der jeweiligen Ebene entspricht immer der jeweiligen Länge des Pfades. Die Höhe eines Baumes entspricht dem größten Niveau+1.

Anwendungen

Man benutzt Bäume beispielsweise zur Darstellung von Hierarchien, wie Taxonomien, oder für Entscheidungsbäume. Bäume werden oft genutzt um sortierte, dynamische oder lineare Datenstrukturen zu repräsentieren, da Einfüge-und Löschoperationen leicht so definiert werden können, dass die Sortierung beibehalten wird. Ein Baum kann auch als Datenindex genutzt werden und stellt so eine Alternative zu Listen und Arrays dar.

Hier wird beispielsweise nach der 5 gesucht und der Baum wird als Suchbaum genutzt.

Man kann auch einen Baum aus Termen bilden. Der Term (3+4) * 5 + 2 * 3 gibt folgenden Baum:

Atomare Operationen auf Bäumen

Zu den Operationen zählen lesen mit

root(): Wurzelknoten eines Baums
get(e): Wert eines Baumelements e
children(e): Kinderknoten eines Elements e
parent(e): Elternknoten eines Elements e

und schreiben mit

set(e,v): Wert des Elements e auf v setzen
addChild(e,e’): Füge Element e’ als Kind von e ein (falls geordneter Baum nutze addChild(e,e’,i) für Index i)
del(e): Lösche Element e (nur wenn e keine Kinder hat)

Spezialfall: Binärer Baum als Datentyp

 
class TreeNode<K extends Comparable<K>>{
          
       K key;
       TreeNode<K> left = null; 
       TreeNode<K> right = null;
         
       public TreeNode(K e) {key = e; }
       public TreeNode<K> getLeft() {return left; } 
       public TreeNode<K> getRight()  {return right; }
       public K getKey() {return key; }
         
       public void setLeft(TreeNode<K> n) {left = n;}
       public void setRight(TreeNode<K> n) {right = n;} 

         ...
         
 }

Beispiel

TreeNode<Character> root = new TreeNode<Character>(‘A‘);

TreeNode<Character> node1 = new TreeNode<Character>(‘B‘);

TreeNode<Character> node2 = new TreeNode<Character>(‘C‘);

TreeNode<Character> node3 = new TreeNode<Character>(‘D‘);

root.setLeft(node1);

root.setRight(node2);

node2.setLeft(node3);

Typische Problemstellungen

Als typische Problemstellung haben wir zum einen die Traversierung, zum Anderen das Löschen eines inneren Knotens und die daraus folgende Re-strukturierung des Baumes und das Suchen in Bäumen.

Traversierung

Bäume können visuell gut dargestellt werden. Manchmal ist jedoch eine Serialisierung der Elemente eines Baumes nötig. Man kann die Elemente eines Baumes durch Preorder-Aufzählung, Inorder-Aufzählung, Postorder-Aufzählung oder Levelorder-Aufzählung eindeutig aufzählen.

Bei der Traversierung werden systematisch alle Knoten des Baumes durchlaufen.

Preorder (W-L-R): $A\to B\to D\to E\to C\to F\to G$

Inorder (L-W-R): $D\to B\to E\to A\to F\to C\to G$

Postorder (L-R-W): $D\to E\to B\to F\to G\to C\to A$

Levelorder: $A\to B\to C\to D\to E\to F\to G$

Traversierung mit Iteratoren

Bei der Traversierung sind Iteratoren erlaubt. Diese werden schrittweise abgearbeitet und es werden Standardschleifen für die Baumdurchläufe verwendet.

 for  (Integer i : tree) 
              System.out.print(i);

Dabei ist es allerdings notwendig, dass der Bearbeitungszustand zwischengespeichert wird.

public class BinarySearchTree<K extends Comparable<K>>
      implement Iterable<K> {

   public static final int INORDER = 1;  
   public static final int PREORDER = 2;
   public static final int POSTORDER = 3;
   public static final int LEVELORDER = 4;

   private int iteratorOrder;
    ...

  public void setIterationOrder(int io) {
      if (io < i || io > 4)
          return;
      iteratorOrder = io;
  }
 public Iterator<K> iterator() {
     switch (iterationOrder) { 
         case INORDER:
            return new InorderIterator<K>(this);
         case PRORDER:
            return new PreorderIterator<K>(this);
         case POSTORDER:
            return new PostorderIterator<K>(this);
         case LEVELORDER:
            return new LevelorderIterator<K>(this);
         default:
            return new InorderIterator<K>(this);
     }
 }

Preorder Traversierung

Bei der Preorder Traversierung wird der aktuelle Knoten zuerst behandelt und dann der linke oder rechte Teilbaum.

static class TreeNode<K extends Comparable<K>> {
  ...
  public void traverse() {
      if (key==null)
          return;
      System.out.print(” ” + key);
      left.traverse();
      right.traverse();   
  }

Preorder Iteratoren

Der Wurzelknoten wird auf den Stack gelegt, anschließend der rechte Knoten und dann der linke Knoten.

 class PreorderIterator<K extends Comparable <K>>
         implements Iterator<K> {

     java.util.Stack<TreeNode<K>> st =
         new java.util.Stack<TreeNode<K>>();

     public PreorderIterator(BinarySearchTree<K> tree){
           if (tree.head.getRight() != nullNode)
                st.push(tree.head.getRight());
                
     }
  public boolean hasNext() { 
          return !st.isEmpty();
  } 
  
   public K next(){ 
       TreeNode<K> node = st.pop();
       K obj = node.getKey(); 
       node = node.getRight();
       if(node != nullNode) {
          st.push(node);  //rechten Knoten auf den Stack
       }
       node = node.getLeft(); 
       if(node != nullNode) {
          st.push(node);  //linken Knoten auf den Stack
       } 
       return obj;
   } 
}

Inorder Traversierung

Bei der Inorder Traversierung wird zuerst der linke Teilbaum behandelt, dann der aktuelle Knoten und dann der rechte Teilbaum. Als Ergebnis erhält man den Baum in sortierter Reihenfolge.

static class TreeNode<K extends Comparable<K>> {
  ...
  public void traverse() {
      if (key==null)
          return;
      left.traverse();
      System.out.print(” ” + key);
      right.traverse();   
  }

Inorder Iteratoren

Der Knoten head hat immer einen rechten Nachfolger. Es wird vom Wurzelknoten begonnen alle linken Knoten auf den Stack zu legen.

 class InorderIterator<K extends Comparable <K>>
         implements Iterator<K> {

     java.util.Stack<TreeNode<K>> st =
         new java.util.Stack<TreeNode<K>>();

     public InorderIterator(BinarySearchTree<K> tree) {
           TreeNode<K> node = tree.head.getRight();
           while (node != nullNode) {
                st.push(node);
                node = node.getLeft();
           }
    }
  public boolean hasNext() {
          return !st.isEmpty();
  }
  
   public K next(){
       TreeNode<K> node = st.pop();
       K obj = node.getKey();
       node = node.getRight();  //rechten Knoten holen
       while (node != nullNode) {
          st.push(node);
          node = node.getLeft();  //linken Knoten auf den Stack
       }
       return obj;
   }

}

Postorder Traversierung

Bei der Postorder Traversierung wird zuerst der linke und der rechte Teilbaum behandelt und dann der aktuelle Knoten. Dies kann beispielsweise genutzt werden, um einen Baum aus Termen, entsprechend der Priorität der Operatoren, auszuwerten.

static class TreeNode<K extends Comparable<K>> {
  ...
  public void traverse() {
      if (key==null)
          return;
      left.traverse();
      right.traverse();   
      System.out.print(” ” + key);
  }

Levelorder Iteratoren

Der Wurzelknoten wird in der Warteschlange eingefügt. Dann wird zuerst der linke und dann der rechte Knoten in die Warteschlange eingefügt. In dieser Implementierung wird die queue als LinkedList repräsentiert. Dies ist jedoch beliebig.

 class LevelorderIterator<K extends Comparable <K>>
         implements Iterator<K> {

   //Wurzelknoten in die Warteschlange (queue) einfügen
   java.util.Queue<TreeNode<K>> q =
         new java.util.LinkedList<TreeNode<K>>();

   public LevelorderIterator(BinarySearchTree<K> tree){
         TreeNode<K> node = tree.head.getRight();
         if (node != nullNode)
                q.addLast(node);}
  
   public K next(){
       TreeNode<K> node = q.getFirst();
       K obj = node.getKey();
       if (node.getLeft() != nullNode)
            q.addLast(node.getLeft());
       if (node.getRight() != nullNode)
            q.addLast(node.getRight());
       return obj;
   }
}

Bäume in Java

In Java gibt es keine hauseigene Implementierung für allgemeine Bäume. Einige Klassen (TreeMap, TreeSet) benutzen Bäume zur Realisierung anderer Datenstrukturen. Andere Klassen (JTree) benutzen Bäume als Datenmodell zur Visualisierung.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14 zu finden.

Binäre Suchbäume

Auf dieser Seite werden die binären Suchbäume behandelt. Er ermöglicht einen schneller Zugriff auf Daten mit dem Aufwand O(log n) unter geeigneten Voraussetzungen. Des weiteren ermöglicht er effiziente Sortierung von Daten, durch Heapsort und effiziente Warteschlangen. Der binäre Suchbaum dient als Datenstruktur für kontextfreie Sprachen. In der Computergrafik sind Szenengraphen oft (Beinahe-)Bäume. Bei Informationssysteme dienen binäre Suchbäume zur Datenindizierung und Anfrageoptimierung.

Operationen

Auf Suchbäumen können die Operationen Suchen von Elementen, Einfügen von Elementen und Entfernen von Elementen angewandt werden, wobei letztere zwei voraussetzen, dass die Ordnung der Schlüssel erhalten bleibt.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14 zu finden.

Suchen

Ein binärer Suchbaum kann für viele Anwendungen eingesetzt werden.

Hier ist der Baum ein Datenindex und eine Alternative zu Listen und Arrays. Beispielsweise kann dieser Baum als Suchbaum verwendet werden und nach "5" gesucht werden.

Bei der Anwendung von Bäumen zur effizienten Suche gibt es pro Knoten einen Schlüssel und ein Datenelement und die Ordnung der Knoten erfolgt anhand der Schlüssel. Bei einem binärer Suchbaum enthält der Knoten k einen Schlüsselwert k.key. Alle Schlüsselwerte im linken Teilbaum k.left sind kleiner als k.key und alle Schlüsselwerte im rechten Teilbaum k.right sind größer als k.key. Die Auswertung eines Suchbaums sieht wie folgt aus:

Vergleich des Suchschlüssels mit Schlüssel der Wurzel
Wenn kleiner, dann in linken Teilbaum weiter suchen
Wenn größer, dann in rechtem Teilbaum weiter suchen
Sonst gefunden/nicht gefunden

static class  TreeNode<K extends Comparable<K>>{
         
       K key;
       TreeNode<K> left = null;
       TreeNode<K> right = null;
        
       public TreeNode(K e) {key = e; }
       public TreeNode<K> getLeft() {return left; }
       public TreeNode<K> getRight()  {return right; }
       public K getKey() {return key; }
        
       public void setLeft(TreeNode<K> n) {left = n;}
       public void setRight(TreeNode<K> n) {right = n;}

         ...
        
 }

Knotenvergleich

class  TreeNode<...> { 
          ...

     public int compareKeyTo(K k) {
           return (key == null ? -1: 
                        key.compareTo(k));
     }
         ...
    
    
 }

Rekursives Suchen

protected  TreeNode<K>
         recursiveFindNode(TreeNode<K>  n, k){ 
          /* k wird gesucht */

          if (n!= nullNode) {
              int cmp = n.compareKeyTo(k.key);
              if (cmp == 0)
                  return n;
              else if (cmp > 0)
                  return 
                     recursiveFindNode(n.getLeft(),k);
              else 
                  return 
                     recursiveFindNode(n.getRight(),k);
          }
          else
                return null;
 }

Iteratives Suchen

protected  TreeNode<K> iterativeFindNode(TreeNode<K> k){ 
          /* k wird gesucht */
          TreeNode<K> n = head.getRight();
          while (n!= nullNode) {
              int cmp = n.compareKeyTo(k.key);
              if (cmp == 0)
                  return n;
              else 
                  n = (cmp > 0 ? 
                      n.getLeft(): n.getRight());
           }
           return null;
 }

Suchen des kleinsten Elements

protected  K findMinElement(){ 
          TreeNode<K> n = head.getRight();
          while (n.getLeft() != nullNode) 
              n = n.getLeft();
          return n.getKey();
}

Suchen des größten Elements

protected  K findMaxElement(){ 
          TreeNode<K> n = head.getRight();
          while (n.getRight() != nullNode) 
              n = n.getRight();
          return n.getKey();
}

Eine weitere Anwendungsmöglichkeit ist der Baum aus Termen. Wir haben den Term $(3+4)\cdot 5+2\cdot 3$ als Baumdarstellung sieht es so aus:

Bei der Auswertung müssen die Operatoren auf die beiden Werte der Teilbäume angewandt werden.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14.3 zu finden.

Einfügen

Das Finden der Einfügeposition erfolgt durch Suchen des Knotens, dessen Schlüsselwert größer als der einzufügende Schlüssel ist und der keinen linken Nachfolger hat oder durch Suchen des Knotens, dessen Schlüsselwert kleiner als der einzufügende Schlüssel ist und der keinen rechten Nachfolger hat. Das Einfügen erfolgt prinzipiell in 2 Schritten. Im ersten Schritt wird die Einfügeposition gesucht, sprich der Blattknoten mit dem nächstkleineren oder nächstgrößerem Schlüssel. Im zweiten Schritt wird ein neuer Knoten erzeugt und als Kindknoten des Knotens aus Schritt eins verlinkt. Wenn in Schritt eins der Schlüssel bereits existiert, dann wird nicht erneut eingefügt.

Programm in Java

 /* Einfügeposition suchen */
public boolean  insert(K k){ 
          TreeNode<K> parent = head;
          TreeNode<K> child = head.getRight();
          while (child != nullNode) {
              parent = child;
              int cmp = child.compareKeyTo(k);
              //Schlüssel bereits vorhanden
              if (cmp == 0)
                  return false;
              else if (cmp > 0)
                  child = child.getLeft();
              else
                  child = child.getRight();
           }
/* Neuen Knoten verlinken */  
  TreeNode<K> node = new TreeNode<K>(k);
            node.setLeft(nullNode);
            node.setRight(nullNode);
            if (parent.compareKeyTo(k) > 0)
                  parent.setLeft(node);
            else
                  parent.setRight(node);
            return true;

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14.3.2 zu finden.

Löschen

Zuerst wird das zu löschendes Element gesucht, der Knoten k. Nun gibt es drei Fälle

k ist Blatt: löschen
k hat ein Kind: Kind „hochziehen“
k hat zwei Kinder: Tausche mit weitest links stehenden Kind des rechten Teilbaums, da dieser in der Sortierreihenfolge der nächste Knoten ist und entferne diesen nach den Regeln 1. oder 2.

Ein Schlüssel wird in drei Schritten gelöscht. Im ersten Schritt wird der zu löschende Knoten gefunden. Im zweiten Schritt wird der Nachrückknoten gefunden. Dafür gibt es mehrere Fälle. Im Fall 1 handelt es sich um einen externen Knoten, sprich ein Blatt, ohne Kinder. Dabei wird der Knoten durch einen nullNode ersetzt. Im Fall 2a gibt es nur einen rechten Kindknoten, dabei wird der gelöschte Knoten durch den rechten Kindknoten ersetzt. Im Fall 2b gibt es nur einen linken Kindknoten und der gelöschte Knoten wird durch diesen ersetzt. Im Fall 3 gibt es einen internen Knoten mit Kindern rechts und links. Dabei wird der gelöschte Knoten durch den Knoten mit dem kleinstem (alternativ größtem) Schlüssel im rechten (alternativ linken) Teilbaum ersetzt. im dritten und letzten Schritt wird nun der Baum reorganisiert. Während dem Löschen kann sich die Höhe von Teilbäumen ändern.

Programm in Java

 /* Knoten suchen */
public boolean  remove(K k){ 
          TreeNode<K> parent = head;
          TreeNode<K> node = head.getRight();
          TreeNode<K> child = null;
          TreeNode<K> tmp = null;
          while (node != nullNode) {
              int cmp = node.compareKeyTo(k);
              //Löschposition gefunden
              if (cmp == 0)
                 break;
              else {
                 parent = node;
                 node = (cmp > 0 ?
                      node.getLeft() : node.getRight());
             }
         }
         //Knoten k nicht im Baum
         if (node == nullNode)
            return false;
/* Nachrücker finden */
    if (node.getLeft() == nullNode  &&
            Node.getRight() == nullNode)  //Fall 1
         child = nullNode;
     else if (node.getLeft() == nullNode)  //Fall 2a
           child = node.getRight();
     else if (node.getRight() == nullNode)  //Fall 2b
           child = node.getLight();
          ...   
  //Fall 3
  else {
       child = node.getRight();
       tmp = node;
       while (child.getLeft() != nullNode) {
            tmp = child;
            child = child.getLeft();
       }
       child.setLeft(node.getLeft());
       if (tmp != node) {
            tmp.setLeft(child.getRight());
            child.setRight(node.getRight());
       }
  } 
/* Baum reorganisieren */
        if (parent.getLeft() == node)
                 parent.setLeft(child)
        else 
                 parent.setRight(child);
        return true;
      ...

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14.3.2 zu finden.

Implementierung

Ein binärer Suchbaum ist eine häufig verwendete Hauptspeicherstruktur und ist besonders geeignet für Schlüssel fester Größe, z.B. numerische wie int, float und char[n]. Der Aufwand von O(log n) für Suchen, Einfügen und Löschen ist garantiert, vorausgesetzt der Baum ist balanciert. Später werden wir lernen, dass die Gewährleistung der Balancierung durch spezielle Algorithmen gesichert wird. Des weiteren sind größere, angepasste Knoten für Sekundärspeicher günstiger, diese nennt man B-Bäume. Für Zeichenketten benutzt man als Schlüssel variable Schlüsselgröße, sogenannte Tries.

public class   
      BinarySearchTree<K extends Comparable<K>>
           implements Iterable<K> {
         
          ...

    static class TreeNode<K extends Comparable<K>> {
         K key;
         TreeNode<K> left = null;
         TreeNode<K> right = null;
 
         ...
    
    }
 }

Die Schlüssel müssen Comparable-Interface, d.h. compareTo()-Methode, implementieren, da der Suchbaum auf Vergleichen der Schlüssel basiert. Der Baum selbst implementiert Iterable-Interface, d.h. iterator()-Methode, um Traversierung des Baums über Iterator zu erlauben (später Baumtraversierung).TreeNode und alles weitere werden als innere Klassen implementiert. Dadurch werden Zugriff auf Attribute und Methoden der Baumklasse erlaubt. Eine Besonderheit der Implementierung sind die „leeren“ Pseudoknoten head und nullNode zur Vereinfachung der Algorithmen (manchmal „Wächter“ / „sentinel“ genannt). Grundlegende Algorithmen sind

Suchen
Einfügen
Löschen

Implementierung mit Pseudoknoten

Wir vereinbaren an dieser Stelle, dass man auf dem Kopf kein getRight() anwenden kann.

public class   
      BinarySearchTree<K extends Comparable<K>>
           implements Iterable<K> {
         
          ...

       pulic BinarySearchTree(){
            head = new TreeNode<K>(null);
            nullNode = new TreeNode<K>(null);
            nullNode.setLeft(nullNode);
            nullNode.setRight(nullNode);
            head.setRight(nullNode);
       }
         ...
    
    
 }

Das Ziel der Implementierung ist, die Reduzierung der Zahl an Sonderfällen. Im head würde das Einfügen oder Löschen des Wurzelknotens spezielle Behandlung in der Baum-Klasse erfordern. Der nullNode erspart den Test, ob zum linken oder zum rechten Teilknoten navigiert werden kann. Des weiteren ist im NullNode ein einfaches Beenden der Navigation (z.B. Beenden der Rekursion) möglich.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14.2.1 zu finden.

Weitere Aspekte

Die Komplexität der Operation hängt von der Höhe ab. Der Aufwand für die Höhe des Baumes beträgt O(h). Die Höhe eines ausgeglichenen binären Baumes ist h=ld(n) für Knoten. Bei eines ausgeglichenen oder balancierten Baum unterscheiden sich zum einen der rechte und linke Teilbaum eines jeden Knotens in der Höhe um höchstens 1 und zum anderen unterscheiden sich je zwei Wege von der Wurzel zu einem Blattknoten höchstens in um 1 in der Länge. Rot-Schwarz Bäume und AVL Bäume benötigen einen Ausgleich nach dem Einfügen und Löschen.

Entartung von Bäumen

Ungünstige Einfüge- oder Löschreihenfolge führt zu extremer Unbalanciertheit. Im Extremfall wird der Baum zur Liste, dann haben die Operationen eine Komplexität von O(n). Beispiel:

for (int i = 0; i < 10; i++)
tree.insert(i);

Vermeiden kann man dies durch spezielle Algorithmen zum Einfügen und Löschen, z.B. mit Rot-Schwarz-Bäumen und AVL-Bäumen.

Heaps

Heap Sort

Auf dieser Seite wird das Thema Heap Sort behandelt. Von "Heap" gibt es zwei völlig verschiedene Definitionen. Zum einen ist es ein größeres Gebiet im Hauptspeicher, aus dem Programmierer Blöcke beanspruchen und wieder freigeben können und zum anderen ist es ein balancierter, linksbündiger Binärbaum in dem kein Knoten einen Wert hat, der größer ist als der Wert seines Elternknoten. Im Falle von Heapsort wird die zweite Definition benutzt.

Balancierter Binärbaum

Jeder Knoten ist in einer Ebene platziert, der Wurzelknoten in Ebene 0. Die Höhe eines Baumes ist die Distanz von seiner Wurzel zum weitest entfernten Knoten plus 1. Ein Knoten ist tiefer als ein anderer Knoten, wenn seine Ebene eine höhere Zahl hat. Ein Binärbaum der Höhe h ist balanciert, wenn alle Knoten der Ebenen 0 bis h-3 zwei Kinder haben.

Ein balancierter Binärbaum der Höhe h ist linksbündig, wenn er $2^{k}$ Knoten in der Ebene k hat für alle $k<h-1$ und alle Blätter der Ebene h-1 so weit wie möglich links sind.

Motivation

Der Vorteil von MergeSort gegenüber QuickSort ist, dass MergeSort einen garantierten Aufwand von O(n log n) hat. Der Vorteil von QuickSort gegenüber MergeSort ist, dass QuickSort n viel Speicher benötigt und MergeSort 2n viel Speicher. Gibt es nun einen Sortieralgorithmus, der n viel Speicher benötigt und garantiert in O(n log n) läuft? Ja HeapSort! Mit HeapSort lassen sich zudem die Warteschlangen mit Prioritäten effizient implementieren. Außerdem ist die Idee des Heaps sehr interessant. Eine komplexe Datenstruktur (Baum) wird in einer einfacheren Struktur (Array) abgebildet.

Heap Eigenschaft

Ein Knoten hat die Heap-Eigenschaft, wenn der Wert in dem Knoten so groß oder größer ist als die Werte seiner Kinder. Alle Blattknoten haben dann auch automatisch die Heap Eigenschaft. Ein Binärbaum ist nur dann ein Heap, wenn alle Knoten die Heap Eigenschaft besitzen.

Anmerkung

Ein Heap ist kein binärer Suchbaum. Das Sortierkriterium bei Suchbäumen war, dass der Wert eines Knotens stets größer ist, als die Werte der Knoten, die im linken Teilbaum liegen und, dass der Wert eines Knotens stets kleiner ist, als die Werte der Knoten, die im rechten Teilbaum liegen. Das Sortierkriterium beim Heap ist, dass die Werte eines Knotens stets größer oder gleich der Werte der Knoten sind, die in beiden Teilbäumen liegen.

Literatur

Da die Vorlesungsinhalte auf dem Buch Algorithmen und Datenstrukturen: Eine Einführung mit Java von Gunter Saake und Kai-Uwe Sattler aufbauen, empfiehlt sich dieses Buch um das hier vorgestellte Wissen zu vertiefen. Die auf dieser Seite behandelten Inhalte sind in Kapitel 14.6.1 zu finden.

Hashtabellen

Auf dieser Seite wird das Thema Hashtabellen behandelt. Gesucht ist eine dynamische Datenstruktur mit sehr schnellem direktem Zugriff auf Elemente. Die Idee der Hashfunktion ist, dass ein Feld von 0 bis N-1 benutzt wird, beispielsweise ein Array. Die einzelnen Positionen im Feld werden oft als Buckets bezeichnet. Die Hashfunktion h(e) bestimmt für Elemente e die Position im Feld. H(e) ist sehr schnell berechenbar. Es gilt $h(e)\neq h(e')~wenn~e\neq e'$

Beispiele

Wir haben ein Array von 0 bis 9 und h(i)=i mod 10. Das Array sieht nach dem Einfügen der Zahlen 42 und 119 wie folgt aus:

Index	Eintrag
0
1
2	42
3
4
5
6
7
8
9	119

Der Vorteil von Hashing ist, dass Anfragen der Form " Enthält die Datenstruktur das Element 42?" schnell beantwortbar sind. Dazu verhalten sich Hashtabellen ähnlich zu binären Suchbäumen wie BucketSort zu vergleichsbasierten Sortierverfahren.

Hashfunktionen

Die Hashfunktionen hängen vom Datentyp der Elemente und der konkreten Anwendungen ab. Für den Datentyp Integer ist die Hashfunktion meist h(i)=i mod N. Das funktioniert im Allgemeinen sehr gut, wenn N eine Primzahl ist und hängt mit Methoden zur Erzeugung von Zufallszahlen zusammen. Für andere Datentypen führt man eine Rückführung auf Integer aus. Bei Fließpunkt-Zahlen werden Mantisse und Exponent einfach addiert.

Die Hashwerte sollten gut streuen. Das ist eventuell von den Besonderheiten der Eingabewerte abhängig. Beispielsweise tauchen Buchstaben des Alphabets in Namen unterschiedlich oft auf. Des weiteren müssen die Hash-Werte effizient berechenbar sein. Ein konstanter Zeitbedarf ist erfordert, dieser ist nicht von der Anzahl der gespeicherten Werte abhängig.

Ungünstige Hashfunktionen

Als erstes Beispiel wählen wir $N=2^{i}$ und eine generierte Artikelnummer mit den Kontrollziffern 1,3 oder 7 am Ende. Damit wäre die Abbildung nur auf ungeraden Adressen möglich. Als zweites Beispiel wählen wir Matrikelnummern in einer Hashtabelle mit 100 Einträgen. In der ersten Variante nutzen wir die ersten beiden Stellen als Hashwert, damit kann eine Abbildung nur auf wenige Buckets erfolgen. In der zweiten Variante nutzen wir die beiden letzten Stellen und erhalten eine gleichmäßige Verteilung.

Typen von Graphen und Anwendungen

In diesem Kapitel werden Graphen behandelt. Ein Graph ist das mathematische Modell eines Netzwerks bestehend aus Knoten und Kanten. Graphen haben einen vielfältigen Einsatz. So kommen sie bei Verbindungsnetzwerken (Bahnnetz, Flugververbindungen, Straßenkarten, ...), Verweisen (WWW, Literaturverweise, Wikipedia, symbolische Links, ...), Technischen Modellen (Platinen-layout, finite Elemente, Computergrafik) und Software Reengineering und - dokumentation zum Einsatz. Bäume und Listen sind spezielle Graphen.

Ungerichteter Graph

Es gibt verschiedene Typen von Graphen. Der ungerichtete Graph ist beispielsweise eine Straßenverbindung, eine Telefonnetz oder ein soziales Netzwerk. Ein ungerichteter Graph ist ein Tupel G=(V,E). Wir haben eine endliche Menge V von Knoten (Vertices) und eine Menge E von Kanten (Edges), die aus ungeordneten Paaren aus V besteht. Es gilt, dass $E\subseteq VxV$ und jedes $e\in E$ ist eine zweielementige Teilmenge der Knotenmenge $V(e={a,b}{\text{ mit }}a,b\in V)$ . Im ungerichteten Graphen gibt es keine Schleifen, das heißt es gibt keine Kanten die von einem Knoten zu sich selbst laufen. Außerdem gibt es keine mehrfachen Kanten zwischen zwei Knoten, Parallelkanten genannt.

$V=\{1,2,3,4,5,6,7\}$

$E=\{\{1,2\},\{1,3\},\{1,4\},\{2,6\},\{3,4\},\{3,5\},\{3,6\},\{4,6\},\{5,6\}\}$

Hier können zum Beispiel die kürzesten Wege bei sozialen Netzwerken wie Facebook berechnet werden.

Spezielle Graphen

Sei $G=(V,E)$ ein Graph.

G heißt planar, falls er ohne Überschneidungen der Kanten in der Ebene gezeichnet werden kann.

G heißt vollständig, falls $E=V\times V$

G heißt regulär, falls alle Knoten denselben Grad haben

G heißt bipartit, falls $V=V_{1}\cup V_{2}$ und

- keine zwei Knoten in $V_{1}$ sind adjazent
- keine zwei Knoten in $V_{2}$ sind adjazent

Beispiele

Dieser Graph ist sowohl planar, regulär als auch vollständig.

Dieser Graph ist jedoch nur regulär und vollständig.

Hier handelt es sich nur um einen regulären Graphen.

Dies ist ein Beispiel für einen bipartiten Graph.

Gerichteter Graph

Der gerichtete Graph ist beispielsweise eine Förderanlage oder ein Kontrollfluss in Programmen. Der gerichtete Graph (auch Digraph) ist ein Tupel G=(V,E) mit V als endliche Menge von Knoten und E einer Menge von Kanten, geordneten Paaren aus V. Jedes $e\in E$ ist nun ein Tupel e=(a,b) mit $a,b\in V$ . Schleifen der Form (a,a) sind nun erlaubt. Dazu ist (a,b) eine andere Kante als (b,a). Der Unterschied zwischen (a,b) und {a,b} besteht darin, dass das Tupel (a,b) geordnet ist. Die Reihenfolge kann nicht verändert werden. Hingegen ist {a,b} eine Menge, in der die Reihenfolge der Elemente keine Rolle spielt.

$G_{g}=(V_{g},E_{g})$

$V_{g}=\{1,2,3,4,5,6\}$

$E_{g}=\{(1,2),(1,3),(3,1),(3,4),(3,6),(4,1),(5,3),(5,5),(6,2),(6,4),(6,5)\}$

Gerichtete Graphen werden zum Beispiel als Web-Graph (Google`s PageRank) benutzt. Aber auch in der Scientometrie kommen sie zum Einsatz bei der Impact Faktoren Berechnung. Bei Datenstrukturen im Semantik Web werden gerichtete Graphen zum Speichern von Daten genutzt.

Gerichtete und ungerichtete Graphen

Ein ungerichteter Graph kann in einen gerichteten Graphen transformiert werden, indem jede ungerichtete Kante {v,w} durch zwei gerichtete Kanten (v,w) und (w,v) ersetzt wird. Dann ist beispielsweise der Zusammenhang identisch mit dem starken Zusammenhang. Dazu haben gerichtete Graphen eine größere Ausdrucksstärke und daher wird "Graph" oft als Synonym für einen Digraph verwendet.

Gewichteter Graph

Ein ungerichteter gewichteter Graph ist beispielsweise eine Flugverbindung mit Meilen oder Kosten, ein Straßennetz mit Kilometern oder ein Rohrsystem mit Durchfluss.

Ein gerichteter gewichteter Graph ist beispielsweise ein Straßennetz mit Einbahnstraßen, Rohre mit Ventilen oder ein Förderband.

Der Graph ist ein Paar G=(V,E) und wir haben eine Kantengewichtsfunktion g. Daraus erhalten wir G=(V,E,g) mit  $g:E\to \mathbb {N}$ . Der Graph kann gerichtet oder ungerichtet sein und die Kantengewichte müssen nicht notwendigerweise natürliche Zahlen sein.

Ungerichtete gewichtete Graphen kommen zum Beispiel bei der Navigation beim Berechnen des kürzesten Weges zum Einsatz.

Gerichtete gewichtete Graphen kommen bei der Optimierung in der Telekommunikation zum Einsatz.

Hypergraph

Es gibt aber noch viele weitere Varianten von Graphen wie Multigraphen oder Hypergraphen.

Ein Hypergraph ist ein Paar G=(V,E) mit einer Menge von Knoten V und einer Menge von Hyperkanten $E\subseteq 2^{V}$ .

Definitionen

Hier werden allgemeine Definitionen bezüglich der Graphen behandelt. Dazu werden immer wieder Beispiele gebracht, die sich auf folgende Graphen beziehen. Dabei gilt je nach Beispiel G=(V,E) entweder für den ungerichteten oder den gerichteten Graphen.

Adjazenz

Ungerichteter Graph

Zwei Knoten $v,w\in V$ heißen adjazent, falls $\{v,w\}\in E$ .

Hier heißt v auch Nachbar von w.

Beispiel:

Knoten 1 und 3 sind adjazent

Gerichteter Graph

Zwei Knoten $v,w\in V$ heißen adjazent, falls $(v,w)\in E$ oder $(w,v)\in E$ .

Für $(v,w)\in E$ heißt w Nachfolger von v und v Vorgänger von w.

Beispiele:

Knoten 1 ist Vorgänger zu Knoten 3
Knoten 4 ist Nachfolger zu Knoten 6

Inzidenz

Ungerichteter Graph

Eine Kante $\{v,w\}\in E$ ist inzident zu einem Knoten $z\in V$ , falls $v=z$ oder $w=z$ .

Gerichteter Graph

Eine Kante $(v,w)\in E$ ist inzident zu einem Knoten $z\in V$ , falls $v=z$ oder $w=z$ .

Grad

Ungerichteter Graph

Der Grad (engl. degree) eines Knotens $v\in V$ ist die Anzahl seiner inzidenten Kanten, das heißt: $degree(v)=|\{\{w,x\}\in E|w=v{\text{ oder }}x=v\}|$ .

Beispiel:

Der Grad von Knoten 4 ist 3

Gerichteter Graph

Der Eingangsgrad (engl. in-degree) eines Knotens $v\in V$ ist die Anzahl seiner Vorgänger: $indeg(v)=|\{(w,v)\in E\}|$ .

Der Ausgangsgrad (engl. out-degree) eines Knotens $v\in V$ ist die Anzahl seiner Nachfolger: $outdeg(v)=|\{(v,w)\in E\}|$ .

Beispiele:

Der Eingangsgrad von Knoten 3 ist 2
Der Ausgangsgrad von Knoten 3 ist 3

Weg

Ungerichteter Graph

Ein Weg W ist eine Sequenz von Knoten $W=(v_{1},...,v_{n})$ mit $v_{1},...,v_{n}\in V$ für die gilt: $\{v_{i},v_{i+1}\}\in E{\text{ für alle }}i=1,...,n-1$

Beispiel:

(1,3,5,6,3,4) ist ein Weg

Gerichteter Graph

Ein (gerichteter) Weg W ist eine Sequenz von Knoten $W=(v_{1},...,v_{n}){\text{ mit }}v_{1},...,v_{n}\in V{\text{, für die gilt: }}(v_{i},v_{i+1})\in E{\text{ für alle }}i=1,...,n-1$ .

Beispiel:

(1,3,6,5,5,3,1) ist ein (gerichteter) Weg

Pfad

Ein Weg W heißt Pfad, falls zusätzlich gilt $v_{i}\neq v_{j}{\text{ für alle }}i,j=1,...,n{\text{ mit }}i\neq j$ . Das heißt, der Weg enthält keine doppelten Knoten. Diese Definition gilt sowohl für ungerichtete als auch gerichtete Graphen.

Beispiel:

(1,4,6,5) ist ein Pfad

Kreis

Ein Weg P heißt Kreis, falls $v_{1}=v_{n}$ . Dazu ist ein Kreis K elementar, falls $v_{i}\neq v_{j}{\text{ für alle }}i,j=1,...,n-1{\text{ mit }}i\neq j$ . Der Kreis enthält also keine doppelten Knoten bis auf den Anfangs- und den Endpunkt. Diese Definition gilt sowohl für ungerichtete als auch gerichtete Graphen.

Beispiel:

(1,3,4,6,3,4,1) ist ein Kreis
(3,4,6,3) ist ein elementarer Kreis

Länge

Die Länge eines Weges ist die Anzahl der durchlaufenen Kanten. Die Länge eines Pfades ist also n-1. Diese Definition gilt sowohl für ungerichtete als auch gerichtete Graphen.

Beispiel:

Die Länge von (3,4,6,3,4,1) ist 4
Die Länge von (1,3,6) ist 2

Teilgraph

Ungerichteter Graph

Ein Graph $G'=(V',E')$ heißt Teilgraph von G, falls $V'\subseteq V{\text{ und }}E'\subseteq E\cap (V'\times V')$ .

Beispiel:

G'=({3,4,6},{{3,4},{4,6}}) ist ein Teilgraph von G

Gerichteter Graph

Ein Graph $G'=(V',E')$ heißt Teilgraph von G, falls $V'\subseteq V$ und $E'\subseteq E\cap (V'\times V')$ .

Beispiel:

$G'=(\{1,3,4\},\{(1,3),(4,1)\})$ ist ein Teilgraph von $G_{g}$ .

Erreichbarkeit

Ungerichteter Graph

Ein Knoten $w\in V$ heißt erreichbar von einem Knoten $v\in V$ , falls ein Weg $W=(v_{1},...,v_{n})$ existiert mit $v_{1}=v$ und $v_{n}=w$ .

Beispiele:

Knoten 6 ist erreichbar von Knoten 1
Knoten 7 ist nicht erreichbar von Knoten 1

Gerichteter Graph

Ein Knoten $w\in V$ heißt erreichbar von einem Knoten $v\in V$ , falls ein Weg $W=(v_{1},...,v_{n})$ existiert mit $v_{1}=v$ und $v_{n}=w$ .

Beispiele:

Knoten 6 ist erreichbar von Knoten 1
Knoten 5 ist nicht erreichbar von Knoten 2

Zusammenhang

Ungerichteter Graph

G heißt (einfach) zusammenhängend, falls für alle $v,w\in V$ gilt, dass w von v erreichbar ist

Ein Teilgraph $G'=(V',E')$ von G heißt Zusammenhangskomponente von G, falls G' zusammenhängend ist und kein Teilgraph $G''=(V'',E'')$ von G existert mit $V'\subset V''$ .

Beispiele:

G ist nicht zusammenhängend
Der Teilgraph $G''=(V'',E''){\text{ mit }}V''=\{1,2,3,4,5,6\}{\text{ und }}E''=\{\{1,2\},\{1,3\},\{1,4\},\{2,6\},\{3,4\},\{3,5\},\{3,6\},\{4,6\},\{5,6\}\}$ ist eine Zusammenhangskomponente von G
Der Teilgraph $G'''=(\{7\},\emptyset )$ ist eine Zusammenhangskomponente von G

Gerichteter Graph

G heißt (stark) zusammenhängend, falls für alle $v,w,\in V$ gilt, dass w von v und v von w erreichbar ist.

Ein Teilgraph $G'=(V',E')$ von G heißt starke Zusammenhangskomponente von G, falls $G'$ stark zusammenhängend ist und kein Teilgraph $G''=(V'',E'')$ von G existiert mit $V'\subset V''$ .

Beispiel:

Der Teilgraph $G''=(V'',E'')$ mit $V''=\{1,3,4,5,6\}$ und $E''=\{(1,3),(3,1),(3,4),(3,6),(4,1),(5,3),(5,5),(6,4),(6,5)\}$ ist eine starke Zusammenhangskomponente von $G_{g}$ .

Repräsentation von Graphen

Auf dieser Seite wird die Repräsentation von Graphen behandelt. Wir fragen uns wie effizient die Datenstruktur für Graphen ist.

Kanten- und Knotenlisten

Bei durchnummerierten Knoten erfolgt eine einfache Realisierung. Historisch gesehen ist es die erste verwendete Datenstruktur. Außerdem ist sie als Austauschformat geeignet und die Auflistung ist nach Knoten oder nach Kanten sortiert.

Beispiel Kantenliste

Gegeben ist eine Kantenliste für $G_{g}:$

Die erste Zahl (6) steht für die Knotenzahl. Die zweite Zahl (11) steht für die Kantenzahl. Die weiteren Paare (1,2 ; 1,3...) stehen für die Kanten.

6,11,1,2,1,3,3,1,4,1,3,4,3,6,5,3,5,5,6,5,6,2,6,4

Beispiel Knotenliste

Gegeben ist eine Knotenliste für $G_{g}:$

6,11,2,2,3,0,3,1,4,6,1,1,2,3,5,3,2,4,5 Die Teilfolge 2,2,3 bedeutet, dass der Knoten 1 den Ausgangsgrad 2 hat und herausgehende Kanten zu den Knoten 2 und 3.

Vergleich Kanten-und Knotenliste

Falls ein Graph mehr Kanten als Knoten hat (=„Normalfall“),benötigen Knotenlisten weniger Speicherbedarf als Kantenlisten. Das bedeutet für die Kantenlisten gilt $2+2|E|$ und für die Knotenliste gilt $2+|V|+|E|$ .

Adjazenzmatrix

Adjazenz bedeutet berühren oder aneinander grenzen. Hier werden die Graphen als Boole‘sche Matrix dargestellt. 1-Einträge werden für direkte Nachbarschaften verwendet. A ist eine Adjazenzmatrix für den Graph $G=(V,E):(A_{ij})=1~genau~dann~wenn~(i,j)\in E$

Beispiel

Eigenschaften

Bei ungerichteten Graphen reicht eine Halbmatrix (ein Dreieck) aus. Bei gewichteten Graphen werden Gewichte statt Boolsche Werte genutzt. Der Vorteil einer Adjazenzmatrix ist, dass einige Graphenoperationen als Matrixoperation möglich sind. So ist sie beispielsweise durch iterierte Matrixmultiplikation erreichbar und besitzt schöne Eigenschaften für die mathematische Analyse.

So sieht die Darstellung als Dreiecksmatrix aus. Die Diagonale kann ebenfalls weggelassen werden, wenn Schleifen verboten sind.

Adjazenzliste

Wir haben eine Liste der 3b oder alternativ ein Array. Pro Knoten werden die von ihm ausgehenden Kanten als Liste, welche besonders geeignet für dünn besetzte Matrizen sind, oder als Array von Zeigern dargestellt. Der Graph wird durch |V|+1 verkettete Listen realisiert. In Adjazenzlisten sind dynamische Erweiterungen im Sinne verketteter Listen erlaubt. Knotenlisten können natürlich auch als verkettete Listen realisiert werden.

Speicherbedarf

Seien n=|V| und m=|E|. Benötigt werden insgesamt $n+\sum _{i=1}^{n}ag(i)=n+m$ Listenelemente. ag(i) ist die Anzahl der Nachbarn von i (gerichtet).

Transformation zwischen den Darstellungen

Die vorgestellten Realisierungsvarianten sind äquivalent. Jede Darstellung kann in jede andere ohne Informationsverlust transformiert werden. Dafür wird die eigene Darstellung ausgelesen und anschließend die andere Darstellung erzeugt. Der Aufwand dieser Transformationen variiert von O(n+m) bis $O(n^{2})$ wobei im schlechtesten Fall $m=n^{2}$ gilt. $n^{2}$ tritt immer auf, wenn eine naive Matrixdarstellung beteiligt ist. Nicht naive Darstellungen sind für sehr dünn besetzte Matrizen nötig.

Komplexitätsbetrachtung

Bei Kantenlisten ist das Einfügen von Kanten (Anhängen von zwei Zahlen) und von Knoten (Erhöhung der ersten Zahl um 1) besonders günstig. Das Löschen von Kanten zieht das Verschieben der nachfolgenden Kanten mit sich und die Knoten müssen neu nummeriert werden.

Bei Knotenlisten ist das Einfügen von Knoten, also die Erhöhung der ersten Zahl und das Anhängen einer 0, günstig.

Bei der Matrixdarstellung ist das Manipulieren von Kanten sehr effizient ausführbar. Der Aufwand beim Knoteneinfügen hängt von der Realisierung ab. Im worst case wird die Matrix in eine größere Matrix kopiert.

Bei Adjazenzlisten gibt es unterschiedlichen Aufwand, je nachdem, ob die Knotenliste ein Feld mit Direktzugriff oder eine verkettete Liste mit sequenziellem Durchlauf realisiert.

Operation	Kantenliste	Knotenliste	Adjazenzmatrix	Adjazenzliste
Einfügen Kanten	Beta(1)	O(n+m)	O(1)	O(1)/O(n)
Löschen Kanten	O(m)	O(n+m)	O(1)	O(n)
Einfügen Knoten	O(1)	O(1)	$O(n^{2})$	O(1)
Löschen Knoten	O(m)	O(n+m)	$O(n^{2})$	O(n+m)

Das Löschen eines Knotens impliziert für gewöhnlich auch das Löschen der dazugehörigen Kanten.

Datenstrukturen für Graphen

Auf dieser Seite werden die Datenstrukturen für Graphen behandelt. In Java gibt es keine hauseigene Graphimplementierung, aber es gibt diverse Pakete für verschiedene Anwendungen.

Jung (http://jung.sourceforge.net)

Graph<Integer, String> g = new SparseMultigraph<Integer, String>(); 
g.addVertex((Integer)1); 
g.addVertex((Integer)2); 
g.addEdge("Edge1", 1, 2);

Neo4j (http://www.neo4j.org)

GraphDatabaseService= new 
"GraphDatabaseFactory().newEmbeddedDatabase(“PATH”); 
Transaction tx = graphDb.beginTx(); 
try{ 
   Node firstNode = graphDb.createNode(); 
   Node secondNode = graphDb.createNode(); 
   Relationship relationship = firstNode.createRelationshipTo(secondNode, 
    … ); 
   tx.success(); 
}finally{ 
   tx.finish(); 
}

Die allgemeine Schnittstelle für die Vorlesung ist:

 public interface Graph {
   public int addNode();
   public boolean addEdge (int orig, int dest);
}

Implementierung Adjazenzliste

 public class AdjazenzListGraph implements Graph {
   private int [][] adjacencyList=null;

   //Knoten hinzufügen:
   public int addNode() {
      int nodeNumber = (adjacencyList ==null)?0: adjacencyList.length;
      int [][] newAdjacencyList= new int [nodeNumber+1][];
      //alte adjacencyList kopieren
      for (int i=0; i< nodeNumber; i++) 
         newAdjacencyList [i]=adjacencyList[i];
      //neuer Knoten hat noch keine Kanten
      newAdjacencyList[nodeNumber] =null; 
      adjacencyList=newAdjacencyList;
      return nodeNumber+1;
   }

   //Kante hinzufügen:
   public boolean addEdge (int orig, int dest){
      int nodeNumber = (adjacencyList == null)? 0: adjacencyList.length;
      if (orig > nodeNumber || dest > nodeNumber || orig < 1 || dest < 1 )
         return false;
      if (adjacencyList[orig-1] != null)
         for (int n : adjacencyList[orig-1])
            //Kante bereits vorhanden?
            if (n==dest) return false; 
      //Erste Kante am Knoten orig?
      if ( adjacencyList[orig-1] == null ) { 
         adjacencyList [orig-1] = new int[1];
         adjacencyList[orig-1][0]=dest;
      }  
      else {
         int[] newList= new int[adjacencyList[orig-1].length+1];
         System.arraycopy(adjacencyList[orig-1],0,newList,0,adjacencyList[orig-1].length);
         newList[adjacencyList[orig-1].length]=dest;
         adjacencyList [orig-1]=newList;
      }
      return true;
   }
}

Breitensuche

Auf dieser Seite behandeln wir die Breitensuche. Wir fragen uns wie man die Knoten eines Graphen effizient aufzählt. Die Lösung ist der Breitendurchlauf ( Breadth-First-Search, BFS). Dabei werden die Knoten eines Graphen nach der Entfernung vom Zielknoten aufgezählt. Eine andere Methode ist der Tiefendurchlauf, zu dem kommen wir aber später. Bei dem Breitendurchlauf für ungerichtete Graphen gibt es eine Warteschlange als Zwischenspeicher. Farbmarkierungen beschreiben den Status der Knoten. Weiß bedeutet er ist unbearbeitet, grau bedeutet er ist in Bearbeitung und schwarz bedeutet, dass er abgearbeitet ist. Pro Knoten wird die Entfernung zum Startknoten berechnet. Bei der Initialisierung wird der Startknoten in eine Warteschlange eingefügt, die Farbe auf grau gesetzt und die Entfernung mit 0 berechnet. Die anderen Knoten haben eine unendliche Entfernung und sind weiß markiert.

Beim Breitendurchlauf wird der aktuelle Knoten k aus der Warteschlange genommen und schwarz gefärbt. Alle von k aus erreichbaren weißen Knoten werden grau gefärbt, die Entfernung ist der Entfernungswert von k+1 und sie werden in der Warteschlange aufgenommen.

Algorithmus

Ergänzung zum Graph-Interface:

public interface Graph{
   public int addNode();
   public boolean addEdge(int orig, int dest);
   public Collection<Integer> getChildren(int node);!
}

Breitendurchlauf als Iterator:

public class BfsIterator implements Iterator<Integer>{
   private Graph g; 
   private Queue<Integer> q;
   private Set<Integer> visited;

   public BfsIterator(Graph g, int s){
      this.g = g;
      this.q = new LinkedList<Integer>();
      q.add(s);
      this.visited = new HashSet<Integer>();
   }

   public boolean hasNext() { return !this.q.isEmpty(); }

   public Integer next() {
      Integer n = this.q.poll();
      for(Integer m: this.g.getChildren(n))
           if(!this.visited.contains(m) && !this.q.contains(m))
             this.q.add(m);
      this.visited.add(n);
      return n;
   }
}

Ausgabe aller Knoten:

//Sei g ein Graph
Iterator<Integer> it = new BfsIterator(g,1);
while(it.hasNext())
   System.out.println(it.next());

Analyse

Theorem der Terminierung

Die Breitensuche terminiert nach endlicher Zeit

Theorem der Korrektheit

Ist G zusammenhängend, so werden alle Knoten von G genau einmal besucht.

Theorem der Laufzeit

Ist G=(V,E) zusammenhängend und ist die Laufzeit von getChildren linear in der Anzahl der Kinder, so hat die Breitensuche eine Laufzeit von O(|V| + |E|).

Tiefendurchlauf

Auf dieser Seite wird der Tiefendurchlauf behandelt. Der Tiefendurchlauf wird auch Depth-First-Search, oder abgekürzt DFS, genannt. Die Knoten werden aufgezählt indem vom Startknoten aus ein Pfad so weit wie möglich verfolgt wird und bei Bedarf ein Backtracking durchgeführt wird. Bei Tiefendurchlauf werden die Knoten ebenfalls farblich markiert. Weiß bedeutet der Knoten ist noch nicht bearbeitet, grau bedeutet der Knoten ist in Bearbeitung und schwarz bedeutet der Knoten ist bereits fertig abgearbeitet.

Ergänzung zum Graph Interface:

public interface Graph{
   public int addNode();
   public boolean addEdge(int orig, int dest);
   public Collection<Integer> getChildren(int node);
   public Collection<Integer> getNodes();
}

Algorithmus

enum Color {WHITE, GRAY, BLACK};

Map<Integer,Color> color = new HashMap<Integer,Color>();
Map<Integer,Integer> pi = new HashMap<Integer,Integer>();
Map<Integer,Integer> f = new HashMap<Integer,Integer>();
Map<Integer,Integer> d = new HashMap<Integer,Integer>();

int time = 0;

color speichert die Farbe, bzw. den Bearbeitungszustand eines Knotens.

pi speichert den Vorgänger eines Knotens beim Durchlauf.

f speichert den Zeitpunkt des Bearbeitungsbeginns eines Knotens.

d speichert den Zeitpunkt des Bearbeitungsendes eines Knotens.

public void dfs(Graph g){ 
   for(Integer n: g.getNodes())
      color.put(n, Color.WHITE); 
   for(Integer n: g.getNodes())
      if(color.get(n).equals(Color.WHITE))
          dfsVisit(g,n); 
}

public void dfsVisit(Graph g, Integer n){
   color.put(n, Color.GRAY);
   time++;
   d.put(n, time);
   for(Integer m: g.getChildren(n)){
      if(color.get(m).equals(Color.WHITE)){
         pi.put(m, n);
         dfsVisit(g,m);
      } 
   }
   color.put(n, Color.BLACK);
   time++;
   f.put(n, time);
}

Vorgehen

Der Tiefendurchlauf ist ein rekursiver Abstieg. Pro Knoten haben wir zwei Werte und deren Farbwerte. Beginn der Bearbeitung ist d und Ende der Bearbeitung ist f. Der rekursive Aufruf erfolgt nur bei weißen Knoten, die Terminierung der Rekursion ist hier garantiert. Die Ausführung von DFS resultiert in einer Folge von DFS-Bäumen. Der erste Baum wird aufgebaut bis keine Knoten mehr hinzugefügt werden können. Anschließend wird ein unbesuchter Knoten gewählt und fortgefahren. Bei den Kanten des aufgespannten Baumes ist der Zielknoten beim Test weiß. An den B-Kanten ist der Zielknoten beim Test grau. Hierbei handelt es sich um Back Edges oder Rückkanten im aufgespannten Baum. Eine mit B markierte Kante zeigt einen Zyklus an. Bei F Kanten werden beim Test schwarze Knoten gefunden, dessen Bearbeitungsintervall ins Intervall des aktuellen bearbeiteten Knotens passt. Es handelt sich hierbei um Forward Edges bzw. Vorwärtskanten in dem aufgespannten Baum. Bei C Kanten haben wir schwarze Zielknoten v, dessen Intervalle nicht in das aktuelle Intervall passen (d[u]>f[v]). Hierbei handelt es sich um Cross Edges, eine Kante die zwei aufgespannte Bäume verbindet.

Beispiel

Die Notation an den Knoten ist dabei durch <Beginn der Bearbeitung d> / <Ende der Bearbeitung f> gegeben.

Analyse

Theorem der Terminierung

Die Tiefensuche terminiert nach endlicher Zeit.

Theorem der Korrektheit

Es werden alle Knoten von G genau einmal besucht.

Theorem der Laufzeit

Ist sowohl die Laufzeit von getChidlren linear in der Anzahl der Kinder als auch getNodes linear in der Anzahl der Knoten, so hat die Tiefensuche eine Laufzeit von O(|V|+|E|).

Anwendung

Der Tiefendurchlauf wird beispielsweise bei dem Test auf Zyklenfreiheit verwendet. Damit ein Graph zyklenfrei ist, darf kein Kreis K in dem Graph G vorhanden sein. Deshalb basiert dieser Test auf dem Erkennen von Back Edges. Er ist effizienter als beispielsweise die Konstruktion einer transitiven Hülle. Die Tiefensuche wird aber auch beim topologischen Sortieren verwendet. Topologisch bedeutet sortieren nach Nachbarschaft, nicht nach totaler Ordnung.

Topologisches Sortieren

Auf dieser Seite wird das topologische Sortieren behandelt. Wir fragen uns, wie Knoten unter Berücksichtigung von Abhängigkeiten aufgezählt werden können bei gegebenem azyklischem gerichteten Graph. Zur Anwendung kommt diese Sortierung bei Scheduling bei kausalen und zeitlichen Abhängigkeiten, zum Beispiel bei der Netzplantechnik. Mathematisch liegt hier eine Konstruktion einer totalen Ordnung aus einer Halbordnung vor.

Beispiel

Die sorgfältige Mutter legt ihrem Kind morgens die Kleidungsstücke so auf einen Stapel, dass das Kind nur die Kleidungsstücke vom Stapel nehmen und anziehen muss und dann richtig gekleidet ist. Hierfür legt sie die Reihenfolgebedingungen fest:

Unterhose vor Hose

Hose vor Gürtel

Unterhemd vor Gürtel

Gürtel vor Pulli

Unterhemd vor Rolli

Rolli vor Pulli

Socken vor Schuhen

Hose vor Schuhen

Uhr: egal

DFS erstellt die topologische Ordnung on the fly. Das Sortieren nach f-Wert (invers) ergibt eine korrekte Reihenfolge. Statt der expliziten Sortierung nach f werden beim Setzen des f-Wertes die Knoten vorne in eine verkettete Liste eingehängt.

18 Socken

16 Unterhose

15 Hose

14 Schuhe

10 Uhr

8 Unterhemd

7 Gürtel

5 Rolli

4 Pulli

Alternativer Durchlauf:

Berechnung kürzester Wege

Auf dieser Seite wird die Berechnung der kürzesten Wege behandelt.

Gegeben ist ein (Di-)Graph $G=(V,E,\gamma )$ mit einer Gewichtsfunktion: $\gamma :E\to \mathbb {N}$ . Der Pfad durch G ist eine Liste von aneinanderstoßenden Kanten $P=\{(v_{1},v_{2}),(v_{2},v_{3}),...(v_{n-1},v_{n})\}\subseteq E$ . Das Gewicht oder die Länge eines Pfades ist die Aufsummierung der einzelnen Kantengewichte. $w(P)=\sum _{i=1}^{n-1}\gamma ((v_{i},v_{i+1}))$ . Die Distanz zweier Punkte d(u,v) ist das Gewicht des kürzesten Pfades von u nach v.

Es existieren verschiedene kürzeste Wege Probleme.

SPSP: Single pari shortest path

Eingabe: Graph G, Startknoten s, Endknoten t

Ausgabe: Distanz d(s,t)

SSSP: Single source shortest paths

Eingabe: Graph G, Startknoten s

Ausgabe: Distanzen d(s,v) für alle Knoten v

APSP: All-pairs shortest paths

Eingabe: Graph G

Ausgabe: Distanzen d(v,w) für alle Knoten v,w

Auf den nächsten Seiten lernen wir zwei Algorithmen zum Berechnen des kürzesten Weges kennen.

Dijkstra Algorithmus

Auf dieser Seite wird der Dijkstra Algorithmus behandelt. Der Dijkstra Algorithmus wird zur Berechnung des kürzesten Weges benutzt (SSSP). Der Algorithmus stammt von 1959. Es erfolgt eine iterative Erweiterung einer Menge von günstig erreichbaren Knoten. Der Greedy Algorithmus hat eine ähnliche Breitensuche ist aber nur für nichtnegative Gewichte. Er berechnet iterativ verfeinert die Distanzwerte d(v,w) und es gibt eine Prioritätswarteschlange zum Herauslesen des jeweils minimalen Elements.

Priority Queues

Eine Priority‐Queue P ist eine dynamische Datenstruktur, die (mindestens) die folgenden Operationen unterstützt:

P.add(Element): Element hinzufügen
P.poll(): Minimalste Element zurückgeben
P.contains(Element): Enthält P das Element?

Die Ordnung zur Sortierung muss dabei vorab deﬁniert sein.

Ein Heap kann beispielsweise zur Implementierung einer Priority‐Queue benutzt werden (add‐Operation ist dann O(log n), poll‐Operation O(log n), und contains‐Operation ist O(n)). Benutzt man zusätzlich zum Heap noch einen binären Suchbaum auf denselben Element so ist auch contains in O(log n) realisierbar.

Priority Queue in Java

class DijkstraComparator implements Comparator<Integer>{
   Map<Integer,Integer> d = new HashMap<Integer,Integer>();

   public DijComparator(Map<Integer,Integer> d){
      this.d = d;
   }

   public int compare(Integer o1, Integer o2) {
      return d.get(o1).compareTo(d.get(o2));
   }
}

Ist d eine Map “Knoten”‐>”Aktueller Distanzwert von s aus”, so ist PriorityQueue<Integer> queue = new PriorityQueue<Integer>(g.getNumberOfNodes(),new DijkstraComparator(d)); eine Priority‐Queue, die bei iterativen Aufruf queue.poll() immer das Element mit dem minimalsten d‐Wert zurückliefert.

Idee

Initialisiere alle Distanzwerte von s zu v mit ∞ (und von s zu s mit 0)
Initialisiere eine Priority‐Queue Q mit allen v
Extrahiere das minimale Element $w_{min}$ aus Q
Aktualisiere alle Distanzwerte der Nachfolger von $w_{min}$ in Q:

Ist es günstiger über $w_{min}$ zu einem Knoten w zu kommen?
Falls ja setzte d(s,w)=d(s, $w_{min}$ )+y( $w_{min}$ ,w)

5. Wiederhole bei 3 solange Q noch Elemente hat

Algorithmus in Java

Map<Integer,Integer> dijkstra(Graph g, int s){
   Map<Integer,Integer> d = new HashMap<Integer, Integer>();
   PriorityQueue<Integer> queue = //Initialisiere Priority-Queue entsprechend
   for(Integer n: g){
      if(!n.equals(s)){
         d.put(n, Integer.MAX_VALUE);
         queue.add(n);
      }
   }
   d.put(s, 0);
   queue.add(s);

   while(!queue.isEmpty()){
      Integer u = queue.poll();
      for(Integer v: g.getChildren(u)){
         if(queue.contains(v)){
            if(d.get(u) + g.getWeight(u,v) < d.get(v){
               d.put(v, d.get(u) + g.getWeight(u,v));
            }
         }
      }
   }
   return d;
}

Algorithmus

algorithm Dijkstra (G,s)

Eingabe: Graph G mit Startknoten s

for each Knoten u

\in

V[G] -s do // Initialisierung

D[u] :=

\infty

od;

D[s]:= O; PriorityQueue Q := V;

while not isEmpty (Q) do

U := extractMinimal (Q);

for each v

\in

ZielknotenAusgehenderKanten (u)

\cap

Q do

if D[u] +

\gamma

((u,v)) < D[v] then // Entfernung über u nach v kleiner als aktuelle Entfernung D[v]

D[v] := D[u] +

\gamma

((u,v));

adjustiere Q an neuen Wert D[v]

fi

od

Initialisierung

$D[s]+\gamma (s,u)<D[u]?$

$0+10<\infty$

$\Rightarrow D[u]=10$

$D[s]+\gamma (s,x)<D[x]?$

$0+5<\infty$

$\Rightarrow D[x]=5$

$Q=\langle (s:0),(u:\infty ),(v:\infty ),(y:\infty )\rangle$

$D[x]+\gamma (x,u)<D[u]?$

$5+3<10$

$\Rightarrow D[u]=8$

$D[y]analog$

$Q=\langle (x:5),(u:10),(v:\infty ),(y:\infty )\rangle$

$Q=\langle (y:7),(u:8),(v:\infty )\rangle$

$Q=\langle (u:8),(v:13)\rangle$

$Q=\langle (v:9)\rangle$

Der Iterationsstart ist korrekt für die Tiefe 0. Wir nehmen an, dass der vorherige Iterationsschritt korrekt war ( Induktionsbeweis). Der Ein Iterationsschritt ist jeweils die günstigste Verbindung zu einem noch nicht bearbeiteten Knoten hinzunehmen. Da die bisher bearbeiteten Knoten den korrekten Distanzwert haben, ist der neue Distanzwert durch den „günstigsten“ aus dem bisher bearbeiteten Teilgraphen um genau eine Kante hinausgehenden Pfad bestimmt. Jeder Pfad zum Zielknoten dieses Pfades, der um mehr als eine Kante aus dem bearbeiteten Bereich hinausgeht, ist teurer als die gewählte, da Kosten mit zusätzlich hinzu genommenen Kanten nicht sinken können.

Analyse

Terminierungstheorem

Der Algorithmus von Dijkstra terminiert für eine endliche Eingabe nach endlicher Zeit.

Beweis

In jedem Schritt der while‐Schleife wird ein Element aus queue entfernt und die Schleife endet sobald queue leer ist. Jeder Knoten hat nur endliche viele Kinder, deswegen ist auch die Laufzeit der inneren for‐Schleife endlich.

Korrektheitstheorem

Sind alle Kantengewichte nicht‐negativ, so enthält d am Ende die Distanzwerte von s zu allen anderen Knoten.

Beweis

Beachte, dass sobald ein Knoten v aus queue entfernt wird, der Wert für v in d nicht mehr geändert wird.

Zeige nun, dass gilt: Wird v aus queue entfernt, so enthält d den Distanzwert von s nach v. Zeige dies durch Induktion nach i=„Anzahl bisher aus queue entfernter Knoten“:

i=0: Am Anfang hat queue nur für s einen endlichen Wert gespeichert, alle anderen Werte sind ∞. Der Knoten s wird auch stets zuerst entfernt und der Distanzwert ist 0. Dies ist auch korrekt, da s zu sich selbst Distanz 0 hat und alle anderen Knoten keine geringere Distanz von s aus haben können (da alle Kanten nicht‐negative Gewichte haben).
i → i+1: Sei v der (i+1)te Knoten, der aus queue entfernt wird.
- Da die bisher bearbeiteten Knoten den korrekten Distanzwert haben, ist der neue Distanzwert durch den „günstigsten“ aus dem bisher bearbeiteten Teilgraphen um genau eine Kante hinausgehenden Pfad bestimmt.
- Jeder Pfad zum Zielknoten dieses Pfades, der um mehr als eine Kante aus dem bearbeiteten Bereich hinausgeht, ist teurer als die gewählte, da Kosten mit zusätzlich hinzugenommenen Kanten nicht sinken können.

Laufzeittheorem

Sei G=(V,E,g) ein gerichteter Graph. Der Laufzeitaufwand von Dijkstras Algorithmus für einen beliebigen Knoten s in G ist O((|E| + |V|) log |V|).

Beweis

Beachte: Wird für die Priority‐Queue beispielsweise ein Heap verwendet, so hat die Operation poll() einen Aufwand von O(log k) (mit k=„Anzahl Elemente in Queue“). Sei |V|=n und |E|=m. Insgesamt: O(n log n) + O(n) + n* O(log n) + m *O(log n) = O((m + n) log n) Durch Benutzung sog. Fibonacci‐Heaps (anstatt normaler Heaps) kann die Laufzeit von O((m + n) log n) verbessert werden zu O(m + n log n)

Nachteile

Der kürzeste Weg wird immer gefunden, aber es werden viele unnötige und sinnlose Wege gegangen. Bei negativen Kanten resultieren auch falsche Ergebnisse.

Bellmann-Ford

Auf dieser Seite wird der Bellmann-Ford Algorithmus behandelt. Bei Dijkstra dürfen nur nichtnegative Gewichte benutzt werden. Doch gibt es auch eine Variante mit negativen Gewichten? Das würde nur bei gerichteten Graphen Sinn machen. Das Problem sind Zyklen mit negativem Gesamtgewicht. Ein Beispiel für Gewinn statt Kosten ist beispielsweise ein Verbindungsnetz mit Bonus Gewinnen für bestimmte Verbindungen um Auslastungen zu erhöhen. Dies ist bei Flügen mit Zwischenstopps der Fall, die oft billiger sind. Dieser Algorithmus löst ebenfalls das SSSP Problem.

Prinzip

Der Algorithmus erfolgt in mehreren Durchläufen. Es wird zunächst die bisher beste mögliche Verbindung bestimmtl, die die um eine Kante länger ist. Der i-te Durchlauf berechnet korrekt alle Pfade vom Startknoten der Länge i. Der längste Pfad ohne Zyklus hat eine Länge kleiner als |V|-1, somit hat man spätestens nach |V|-1 Durchläufen ein stabiles Ergebnis. Sollte das Ergebnis nach |V|-1 Durchläufen nicht stabil sein, so ist ein negativ bewerteter Zyklus enthalten. Hierbei wird das Prinzip der dynamischen Programmierung verwendet.

Algorithmus

algorithm BF(G, s)
   Eingabe: ein Graph G mit Startknoten s

   D[s] = 0
   D[t] = ∞ for all other t
   for i := 1 to |V|-1 do
      for each (u,v)∈ E do
         if D[u]+γ((u,v)) < D[v] then
            D[v] := D[u] + γ((u,v))
         fi
      od
   od

Beispiel

Bei der Initialisierung wird der Startknoten auf den Wert 0 gesetzt und alle weiteren Knoten erhalten den Wert ∞.

Beim ersten Schleifendurchlauf bekommt x den Wert 5 und u den Wert 10 zugewiesen.

Im zweiten Schleifendurchlauf werden alle weiteren Verbindungen aktualisiert, sowohl von u als auch von x. Dabei ändern sich die Werte von v, y und auch u. Die Änderung an u wird aber erst im nächsten Schritt an v propagiert.

Im dritten, i=3, Schleifendurchlauf verändern sich diesmal nur noch die Werte der Knoten v und y. Der neue Wert aus y berechnet sich durch den vorherigen Wert aus v=11 und der negativ gewichteten Kante -5. Hier wird also die negativ gewichtete Kante (v,y) zur Berechnung von D[y] genutzt.

Im vierten, i=4, Schleifendurchlauf wird nochmals die negativ gewichtete Kante (v,y) zur Berechnung von D[y] genutzt. Das Greedy-Verfahren, das jeden Knoten nur einmal besucht, hätte für y den in jedem Schritt lokal optimalen Pfas $<s,x,y>$ gewählt und nicht das beste Ergebnis geliefert.

Analyse

Terminierungstheorem

Der Algorithmus BF(G,s) terminiert für eine endliche Eingabe G in endlicher Zeit.

Beweis

Alle Schleifen sind endlich.

Korrektheitstheorem

Ist G ein Graph, der keinen Zyklus mit negativem Gewicht hat, so enthält D nach Aufruf BF(G,s) die Distanzwerte von s zu allen Knoten.

Beweis

Wir zeigen, dass die folgenden Aussagen Schleifeninvariante der for‐ Schleife (Schleifenvariable i) sind:

Ist D[v] < ∞, so ist D[v] der Wert eines Pfades von s nach v
Ist D[v] < ∞, so ist D[v] der kleinste Wert eines Pfades von s nach v mit maximal i Kanten
D[v] < ∞ gdw. es einen Pfad von s nach v mit gleich oder weniger als i Kanten gibt

Da G keine Zyklen mit negativem Gewicht hat, ist die Länge des längsten kürzesten Pfades maximal |Anzahl Knoten|‐1 (jeder Knoten wird auf diesem Pfad einmal besucht). Also gilt nach dem letzten Schleifendurchlauf nach 2 und 3. die Aussage des Theorems. Wir zeigen diese Aussagen durch Induktion nach i(=#Schleifendurchläufe).

Bei i=0 gilt vor dem ersten Schleifendurchlauf nur D[s]=0 < ∞. Daraus folgt direkt 1., 2., 3.
Bei i -> i+1 beweisen wir zunächst Aussage 3.
- War D[v] schon vorher endlich, so gilt die Aussage nach IV.
- Ist D[v] in diesem Schritt auf einen endlichen Wert gesetzt worden, so gab es ein u, so dass D[u] vorher schon endlich war und D[v]=D[u]+γ(u,v). Nach IV gibt es einen Pfad von s nach u der Länge i. Damit gibt es einen Pfad der Länge i+1 von s nach v.
- Umgekehrt wird bei Existenz eines Pfades der Länge i+1 dieser auch gefunden und D[v] auf einen endlichen Wert gesetzt.

Die Aussage 1 wird dadurch bewiesen, dass nach IV der Wert eines Pfades von s nach u D[u] ist. Wird D[v]=D[u]+γ(u,v) gesetzt so ist somit D[v] der Wert des Pfades von s nach v über u.
Die Aussage 2 wird dadurch bewiesen, dass nach IV der kleinste Wert eines Pfades von s nach v mit maximal i Kanten D[v] ist. Mache folgende Fallunterscheidung:
- 1.Fall: Es existiere ein Pfad P1 von s nach v mit i+1 Kanten, der minimalen Wert unter allen Pfaden von s nach v mit gleich oder weniger als i+1 Kanten hat. Betrachte den vorletzten Knoten u auf diesem Pfad und den Teilpfad P2 von P1 von s nach u. Dieser Teilpfad hat minimalen Wert unter allen Pfaden der maximalen Länge i von s nach u (ansonsten wäre P1 kein Pfad mit minimalem Wert). Nach IV ist D[u] genau dieser Wert und D[u]+γ(u,v) der Wert von P1, der dann im i+1ten Durchgang aktualisiert wird.
- 2.Fall: Es existiere kein Pfad von s nach v mit i+1 Kanten, der minimalen Wert unter allen Pfaden von s nach v mit gleich oder weniger als i+1 Kanten hat.
  - 1. Unterfall: Es existiert kein Pfad von s nach v mit maximal i+1 Kanten. Dann bleibt nach 3. D[v]=∞.
  - 2. Unterfall: Es existiert ein Pfad von s nach v mit k<i+1 Kanten, der minimalen Wert unter allen Pfaden von s nach v mit gleich oder weniger als i+1 Kanten hat. Dann ist nach IV D[v] genau dieser Wert und wird im i+1ten Durchgang auch nicht aktualisiert.

Graph mit negativ gewichtetem Zyklus

Betrachten wir die Situation nach |V|-1 Iterationen. Eine Kante könnte noch verbessert werden genau dann wenn der Graph einen Zyklus negativer Länge enthält. Der Zyklus s,x,u,v,y,s hat die Kosten 5+3+1-5-7=-3. Jeder Durchlauf durch den Zyklus erzeugt also einen Gewinn. Es gibt hier keinen günstigen Pfad endlicher Länge!

Laufzeittheorem

Sei G=(V,E,g) ein gerichteter Graph. Der Laufzeitaufwand vom Algorithmus von Bellmann‐Ford für einen beliebigen Knoten s in G ist O(|V||E|).

Beweis

Einfache Schleifenanalyse.

Floyd-Warshall

Auf dieser Seite wird der Floyd-Warshall Algorithmus behandelt. Der Dijkstras Algorithmus und Bellman-Ford berechnen zu einem gegebenen Startknoten die kürzesten Wege zu allen anderen Knoten (Single Source Shortest Paths – SSSP. Aber wie kann man die kürzesten Wege zwischen zwei Knoten v und w berechnen? Man könnte die bereits kennengelernten Algorithmen für jeden einzelnen Startknoten neu aufrufen, doch das geht auch geschickter. Hier kommt der Floyd-Warshall Algorithmus ins Spiel, welcher das All Pairs Shortest Path Problem löst. Zwar nicht unbedingt effizienter, aber eleganter. Dies geschieht nach dem Prinzip der dynamischen Programmierung.

Problemdefinition

Gegeben ist ein Graph G=(V,E). Wir möchten für jedes Paar $(v,w)\in V\times V$ den Wert D(v,w) eines kürzesten Pfades finden. Wir nehmen an, dass es keine negativen Kreise gibt.

D	s	u	v	x	y
s	0	8	9	5	4
u	3	0	1	-2	-4
v	2	10	0	7	-5
x	6	3	4	0	-1
y	7	15	6	12	0

Idee

Die Grundidee des Floyd-Warshall Algorithmus ist, dass wenn ein kürzester Weg $\{(v,a_{1}),...,(a_{n},k),(k,a_{n+1}),...,(a_{m},w)\}$ von v nach w über k geht, dann gilt:

$\{(v,a_{1}),...,(a_{n},k)\}$ ist ein kürzester Weg von v nach k
$\{(k,a_{n+1}),...,(a_{m},w)\}$ ist ein kürzester Weg von k nach w

Im obigen Beispiel gilt folgendes:

$s\to y:\{(s,x),(x,u),(u,v),(v,y)\}$
$s\to u:\{(s,x),(x,u)\}$
$u\to y:\{(u,v),(v,y)\}$

Die Umkehrung gilt jedoch nicht. Ist $\{(v,a_{1}),...,(a_{n},k)\}$ ein kürzester Weg von v nach k und ist $\{(k,a_{n+1}),...,(a_{m},w)\}$ ein kürzester Weg von k nach w dann gilt nicht notwendigerweise, dass $\{(v,a_{1}),...,(a_{n},k),(k,a_{n+1}),...,(a_{m},w)\}$ ein kürzester Weg von v nach w ist!

Im obigen Beispiel bedeutet dies:

$x\to y:\{(x,y)\}$
$y\to v:\{(y,v)\}$
$x\to v:\{(x,y),(y,v)\}$ ist nicht der kürzeste Weg!

Jedoch gilt, wenn bekannt ist, dass ein kürzester Weg zwischen v und w nur Knoten aus $V'\subseteq V$ enthält, so gilt entweder der kürzeste Weg zwischen v und w benutzt nur Knoten aus $V'\backslash \{k\}$ oder der kürzeste Weg zwischen v und w ist Konkatenation aus dem kürzesten Weg zwischen v und k und dem kürzesten Weg zwischen k und w und beide Wege enthalten nur Knoten aus $V'\backslash \{k\}$ .

$D^{V'}[i,j]=fac(x):=\left\{{\begin{array}{ll}\gamma (i,j)&falls~k=0\\min\{D^{V'\backslash \{k\}}[i,j],D^{V'\backslash \{k\}}[i,k]+D^{V'\backslash \{k\}}[k,j]\}&falls~k\geq 1\end{array}}\right.$

Algorithmus

algorithm FW(G)
   Eingabe: ein Graph G

   for each v,v‘∈V
      D[v,v‘] = γ((v,v‘)) (or ∞)
   for each k ∈ V do
      for each i ∈ V do
         for each j ∈ V do
            if D[i,k]+D[k,j] < D[i,j] then
               D[i,j] := D[i,k]+D[k,j]
            fi
         od
      od
   od

Beispiel

Initialisiere D mit den Kantengewichten. Nicht vorhandene Kanten haben das Gewicht $\infty$ . Die Kantengewichte zum Knoten selber sind 0. Im folgenden betrachten wir nur Schleifendurchgänge mit $k\neq i,k\neq j,i\neq j$

D	s	u	v	x	y
s	0	10	$\infty$	5	$\infty$
u	$\infty$	0	1	-2	$\infty$
v	$\infty$	$\infty$	0	$\infty$	-5
x	$\infty$	3	$\infty$	0	2
y	7	$\infty$	6	$\infty$	0

D	s	u	v	x	y
s	0	10	$\infty$	5	$\infty$
u	$\infty$	0	1	-2	$\infty$
v	$\infty$	$\infty$	0	$\infty$	-5
x	$\infty$	3	$\infty$	0	2
y	7	17	6	$\infty$	0

D	s	u	v	x	y
s	0	10	$\infty$	5	$\infty$
u	$\infty$	0	1	-2	$\infty$
v	$\infty$	$\infty$	0	$\infty$	-5
x	$\infty$	3	$\infty$	0	2
y	7	17	6	12	0

Führt man den Algorithmus weiter durch, kommt man zu folgendem Endergebnis:

D	s	u	v	x	y
s	0	8	9	5	4
u	3	0	1	-2	-4
v	2	10	0	7	-5
x	6	3	4	0	-1
y	7	15	6	12	0

Analyse

Terminierungstheorem

Der Algorithmus FW(G) terminiert für eine endliche Eingabe G in endlicher Zeit.

Beweis

Alle Schleifen sind endlich.

Korrektheitstheorem

Ist G ein Graph, der keinen Zyklus mit negativem Gewicht hat, so enthält D nach Aufruf FW(G) die Distanzwerte von allen Knoten zu allen anderen Knoten.

Beweis

Betrachte dazu folgende Schleifeninvariante, die äußerste for-Schleife mit der Laufvariablen k): Nach der k-ten Schleifeniteration gilt, dass D[v,w], für alle v,w, der Wert eines kürzesten Pfades ist, der nur Knoten 1,...,k benutzt. Wenn der Algorithmus endet, gilt damit die Aussage des Theorems. Dies zeigen wir durch Induktion.

k=0 (bei der Initialisierung): Nach der Initialisierung gilt D[v,w]= ∞ gdw. es keine Kante von v nach w gibt. Das bedeutet, dass jeder Pfad zwischen v und w mindestens einen anderen Knoten enthalten haben muss. Ist D[v,w] endlich, so ist dies genau der Wert der Kante. Dann gibt es also einen Pfad, der keine weiteren Knoten beinhaltet.
k -> k+1: Nach der Induktionsannahme ist D[v,w] der Wert eines kürzestens Pfades, der nur Knoten aus 1,...,k enthält. Im k+1-Schleifendurchgang wird überprüft, ob es einen kürzeren Weg über k+1 gibt und ggfs. aktualisiert. Es wird also genau folgende Gleichung ausgenutzt:

$D^{V'}[i,j]=\left\{{\begin{array}{ll}\gamma (i,j)&{\text{falls}}\ V'=\emptyset \\min\{D^{V'\backslash \{k\}}[i,j],D^{V'\backslash \{k\}}[i,k]+D^{V'\backslash \{k\}}[k,j]\}&{\text{für}}\ k\in V'\end{array}}\right.$

Anschließend ist also D[v,w] der Wert eines kürzestens Pfades, der nur Knoten 1,...,k+1 benutzt.

Ein anderer Ansatz ist dies per Induktion nach der kürzesten Länge eines kürzesten Weges für jedes Knotenpaar (v,w) zu zeigen. Anmerkung: zwischen v und w können mehrere Wege mit minimalem Gewicht existieren, diese können auch unterschiedliche Länge haben. Angenommen zwischen v und w existiert ein kürzester Weg der Länge 1, dann ist der Wert dieses Weges gleich dem Wert der Kante (die existieren muss. Dieser wird in der Initialisierungsphase gesetzt und später nicht mehr geändert. Angenommen zwischen v und w gibt es einen kürzesten Pfad (=minimales Gewicht) der Länge l≥ 2 , dann gibt es einen Knoten k auf diesem Pfad, so dass zum einen der Teilpfad von v nach k ein kürzester Weg von v nach k ist und zum anderen, dass der Teilpfad von k nach w ein kürzester Weg von k nach w ist. Somit haben beide Pfade haben Länge < l, d.h. die Werte D[v,k] und D[k,w] müssen schon korrekt berechnet sein (die Induktionsvoraussetzung greift). Da alle potentiellen “Mi5elknoten” überprüft werden, wird ein geeignetes k gefunden und der Wert D[v,w] aktualisiert.

Laufzeittheorem

Sei G=(V,E,g) ein gerichteter Graph. Der Laufzeitaufwand vom Algorithmus von Floyd‐Warshall auf G ist $O(\mid V\mid ^{3}$ ).

Beweis

Einfache Schleifenanalyse.

Flussproblem

Auf dieser Seite wird das Flussproblem behandelt. Die Bestimmung des maximalen Flusses muss in vielen logischen Aufgaben angewandt werden. Beispielsweise bei Verteilungsnetzen mit Kapazitäten wie Wasserrohren, Förderbändern oder Paketvermittlungen mit Rechnernetzen. Die Quellen liefert beliebig viele Objekte pro Zeiteinheit und die Senke verbraucht diese. Jede Verbindung hat eine maximale Kapazität c und einen aktuellen Fluss f. Wie hoch ist nun die Übertragungskapazität?

Definition Fluss

Ein Fluss f von $q\in V$ nach $z\in V$ ist eine Funktion $f_{q,z}:E\to \mathbb {R}$ . Für diese Funktion $f_{q,z}$ gelten folgende zwei Bedingungen:

Die Kapazitäten werden eingehalten: $\forall e\in E:f_{q,z}(e)\leq c(e)$
Was in einen Knoten hereinfließt, muss wieder herausfließen, mit Ausnahme von q und z: $\forall v\in V\backslash \{q,z\}:\sum _{u\in P(v)}f((u,v))=\sum _{w\in S(v)}f((v,w))$ , wobei $P(v)=\{u|(u,v)\in E\}$ der Vorgänger von v ist und $S(v)=\{w|(v,w)\in E\}$ der Nachfolger von v ist.

Einschränkungen der Kapazität der Kanten werden eingehalten, auch bei negativem Fluss:

 $|f_{q,z}(u,v)|\leq c((u,v))$

Außerdem ist der Fluss konsistent. Bei in beiden Richtungen nutzbaren Verbindungen wird als Nettoeffekt nur in eine Richtung gesendet und der entstehende negative Fluss nimmt den korrekten Wert an:

 $f_{q,z}(u,v)=-f_{q,z}(v,u)$

Der Fluss wird für jeden Knoten $v\in V\backslash \{q,z\}$ mit Ausnahme der Quelle q und des Ziels z bewahrt:

 $\sum _{u\in V}f_{q,z}(v,u)=0$

Der Wert eines Flusses beträgt:

 $val(G,f_{q,z})=\sum _{u\in S(q)}f_{q,z}(q,u)$

Gesucht wird der maximale Fluss:

 $max\{val(G,f)|$  f ist korrekter Fluss von q nach z}

Beispiel

Definiere $f_{1}$ durch

$f_{1}((1,2))=2,\ f_{1}((1,3))=4,\ f_{1}((2,4))=1,\ f_{1}((2,5))=1,\ f_{1}((3,2))=0,\ f_{1}((3,5))=4,\ f_{1}((4,5))=0,\ f_{1}((4,6))=1,\ f_{1}((5,6))=5$ .

Daraus folgt, dass der Wert des Flusses 6 ist: $val(G,f_{1})=6$ .

Definiere $f_{2}$ durch

$f_{2}((1,2))=5,\ f_{2}((1,3))=3,\ f_{2}((2,4))=4,\ f_{2}((2,5))=1,\ f_{2}((3,2))=2,\ f_{2}((3,5))=1,\ f_{2}((4,5))=1,\ f_{2}((4,6))=3,\ f_{2}((5,6))=3$ .

Daraus folgt, dass $f_{2}$ kein Fluss ist.

Definiere $f_{3}$ durch

$f_{3}((1,2))=5,\ f_{3}((1,3))=9,\ f_{3}((2,4))=4,\ f_{3}((2,5))=5,\ f_{3}((3,2))=4,\ f_{3}((3,5))=5,\ f_{3}((4,5))=0,\ f_{3}((4,6))=4,\ f_{3}((5,6))=10$ .

Daraus folgt, dass der Wert des Flusses 14 ist: $val(G,f_{3})=14$ . Damit ist der Fluss $f_{3}$ maximal.

Ford-Fulkerson

Auf dieser Seite wird der Ford Fulkerson Algorithmus zur Berechnung des maximalen Flusses behandelt.

Berechnung des maximalen Flusses

Der Ford-Fulkerson Algorithmus ist ein effizienter Algorithmus zur Bestimmung eines maximalen Flusses von q nach z. Dabei wird der Greedy Algorithmus mit Zufallsauswahlen gemischt. Hier wird das Prinzip "Füge so lange verfügbare Pfade zum Gesamtfluss hinzu wie möglich" verfolgt. Zuerst soll ein nutzbarere Pfad durch Tiefensuche gefunden werden. Für die Kanten werden dann drei Werte notiert. Zum einen der aktuellen Fluss entlang der Kante. Im initialisierten Graphen ist dieser Wert überall 0. Zudem wird die vorgegebene Kapazität c notiert und die abgeleitete noch verfügbare Restkapazität von c-f.

Algorithmus

initialisiere Graph mit leerem Fluss;
do
   wähle nutzbaren Pfad aus;
   füge Fluss des Pfades zum Gesamtfluss hinzu;
while noch nutzbarer Pfad verfügbar

Ein nutzbarere Pfad ist ein zyklenfreier Pfad von der Quelle q zum Ziel z, der an allen Kanten eine verfügbare Kapazität hat. Ein nutzbarer Fluss ist das Minimum der verfügbaren Kapazitäten der einzelnen Kanten.

Der nachfolgende Pseudocode realisiert das Problem mit zusätzlichen Rückkanten.

für jede Kante(u,v) füge Kante (v,u) mit Kapazität 0 ein;
initialisiere Graph mit leerem Fluss;
do
   wähle nutzbaren Pfad aus;
   füge Fluss des Pfades zum Gesamtfluss hinzu;
while noch nutzbarer Pfad verfügbar

Beispiele

Wir haben einen Graph mit Kapazitäten gegeben

Es wird mit dem Fluss 0 initialisiert. Notation: <aktueller Fluss f> / <Kapazität c> / <verfügbare Kapazität c-f>

Die Auswahl der nutzbaren Pfade geschieht zufällig oder durch geeignete Heuristik. Es gibt auch kürzere Pfade mit höheren Kapazitäten. Die Rückkanten werden mit der Kapazität 0 eingefügt. Die Auswahl eines Pfades geschieht durch $1\to 2\to 4\to 5\to 6$ Der nutzbare Fluss beträgt 4.

Der Fluss wird aktualisiert. Die Auswahl des Pfades ist nun : $1\to 3\to 5\to 6$ . Der nutzbare Fluss beträgt 5.

Der Fluss wird aktualisiert. Die Auswahl des Pfades ist nun : $1\to 3\to 2\to 5\to 6$ . Der nutzbare Fluss beträgt 3.

Der Fluss wird aktualisiert. Die Auswahl des Pfades ist nun : $1\to 3\to 2\to 5\to 4\to 6$ . Der nutzbare Fluss beträgt 2.

An dieser Stelle sind keine Kapazitäten mehr über und die Berechnung wir beendet. Der maximale Fluss beträgt 14.

Der Algorithmus kann dabei auf verschiedene Ergebnisse kommen, jedoch ist der maximale Fluss immer gleich. Eine weitere Lösung ist folgende:

Zunächst wird der Pfad $1\rightarrow 2\rightarrow 5\rightarrow 6$ mit dem nutzbaren Fluss 5 ausgewählt.

Anschließend wird der Fluss aktualisiert. Im nächsten Schritt wird dann der Pfad $1\rightarrow 3\rightarrow 5\rightarrow 6$ gewählt. Ebenfalls ist hier wieder ein nutzbarer Fluss von 5.

Nach der zweiten Aktualisierung ist nur noch ein Pfad vom Start zum Ziel möglich. Also wird der Pfad $1\rightarrow 3\rightarrow 2\rightarrow 4\rightarrow 6$ ausgewählt. Dieser Fluss enthält allerdings nur noch einen nutzbaren Fluss von 4.

Nach dem Aktualisieren des Flusses ist es nicht mehr möglich einen Pfad vom Start zum Ziel zu finden. Damit ist die Berechnung beendet. Wie zuvor berechnet ist der maximale Fluss 14.

Problem: Ungünstige Pfadwahl

Die bisher betrachtete Version des Algorithmus ist nicht immer optimal.

Wählen der Pfad $1\rightarrow 3\rightarrow 2\rightarrow 4$ ausgewählt, besitzt dieser Pfad einen nutzbaren Fluss von 5.

Nun wird der Fluss aktualisiert. Daraus folgt, dass keine weitere Pfadwahl mehr möglich ist. Dabei wäre die optimale Lösung über die Pfade $1\rightarrow 2\rightarrow 4$ und $1\rightarrow 3\rightarrow 4$ .

Das Problem ist, dass der Fluss nicht zurückgenommen werden kann. Die Lösung dazu ist, dass man entgegengesetzte Flussrichtung durch Rückkanten erlaubt. Auch hier wird wieder der ungünstige Pfad $1\rightarrow 3\rightarrow 2\rightarrow 4$ mit einem nutzbaren Fluss von 5 im ersten Schritt ausgewählt.

Anschließend wird der Fluss aktualisiert. Dabei wird der Pfad $1\rightarrow 2\rightarrow 3\rightarrow 4$ mit dem nutzbaren Fluss von 5 ausgewählt.

Beim erneuten aktualisieren des Flusses, stellt sich heraus, dass keine weiteren Pfade möglich sind. Damit ist die Berechnung, bei einem maximalen Fluss von 10, beendet.

Analyse

Terminierungstheorem

Sind alle Kapazitäten in G nicht-negativ und rational, dann terminiert der Algorithmus von Ford‐Fulkerson nach endlicher Zeit.

Laufzeittheorem

Ist X der Wert eines maximales Flusses in G=(V,E) und sind alle Kapazitäten in G nicht-negativ und ganzzahlig, so hat der Algorithmus von Ford‐Fulkerson eine Laufzeit von O(|E|X).

Korrektheitstheorem

Sind alle Kapazitäten in G nicht‐negativ und rational, dann berechnet der Algorithmus von Ford‐Fulkerson den Wert eines maximalen Flusses.

Anmerkung

Die Wahl des Pfades beeinflusst die Anzahl benötigter Iteratoren. Bei dem Verfahren von Edmons und Karp muss die Anzahl der Pfade die in einem Graphen G = (V,E) bis zum Finden des maximalen Flusses verfolgt werden, kleiner sein als |V||E|, wenn jeweils der kürzeste Pfad von Quelle q zu Ziel z gewählt wird. Daher kann die Auswahl des nächsten kürzesten Pfades basierend auf einer Variante der Breitensuche erfolgen. Dadurch wird die Laufzeit auf $O(\mid V\mid \mid E\mid ^{2})$ verbessert.

Spannbäume

Auf dieser Seite werden Spannbäume und in diesem Zusammenhang der Algorithmus von Prim behandelt.

Beispiel Kommunikationsnetz

Zwischen n Knotenpunkten $v_{1}...v_{n}$ soll ein möglichst billiges Kommunikationsnetz geschaltet werden, so dass jeder Knotenpunkt mit jedem anderen verbunden ist, ggf. auf einem Umweg über andere Knotenpunkte. Bekannt sind die Kosten $c_{ij}$ für die direkte Verbindung zwischen $v_{i}$ und $v_{j}1\leq i,j\leq n$ . Alle Kosten $c_{ij}$ seien verschieden und größer Null. Die Modellierung geschieht somit als gewichteter, ungerichteter und vollständiger Graph mit einer Gewichtungsfunktion c.

$G=(V,E)$

$V=\{v_{1},...,v_{5}\}$

$E=\{(v_{1},v_{2}),(v_{1},v_{3}),(v_{1},v_{4}),(v_{1},v_{5}),(v_{2},v_{3}),(v_{2},v_{4}),(v_{2},v_{5}),(v_{3},v_{4}),(v_{3},v_{5}),(v_{4},v_{5})\}$

$c((v_{1},v_{2}))=6,c((v_{1},v_{3}))=7$ etc; abgekürzt $c_{1,2}=6,c_{1,3}=7$ etc

Problemstellung: Finde minimal aufspannenden Baum

Einige Definitionen für ungerichtete Graphen:

Ein Graph G=(V,E) heißt zusammenhängend, wenn für alle v,w∈V ein Pfad von v nach w in G existiert.

Ein Graph G=(V,E) enthält einen Zyklus, wenn es unterschiedliche Knoten $v_{1},...,v_{n}\in V$ gibt, so dass $\{v_{1},v_{2}\},...,\{v_{n-1},v_{n}\},\{v_{n},v_{1}\}\in E$ . Ein Graph G=(V,E) heißt Baum, wenn er zusammenhängend ist und keinen Zyklus enthält.

Ein Graph G’=(V’,E’) heißt Teilgraph von G=(V,E), wenn $V'\subseteq V$ und $E'\subseteq E\cap (V'xV')$ .

Ein Graph G’=(V’,E’) heißt induzierter Teilgraph von G=(V,E) bzgl. $V'\subseteq V$ , wenn $E'=E\cap (V'xV')$

Ein Graph G‘=(V‘,E‘) heißt Spannbaum von G=(V,E), wenn V'=V und G' ein Teilgraph von G und ein Baum ist.

Das Gewicht einen Graphen G=(V,E) ist $C(G)=\sum _{(i,j)\in E}c_{i,j}$ .

Ein Graph G'=(V',E') ist ein minimaler Spannbaum von G=(V,E), wenn G' ein Spannbaum von G ist und G' unter allen Spannbäumen von G das minimalste Gewicht hat.

Algorithmus von Prim

Der Algorithmus wird schrittweise verfeinert und der Aufbau eines aufgespannten Baumes erfolgt durch das Hinzufügen von Kanten. Das Greedy Muster, also jeweils die Wahl der kostengünstigsten Kante als Erweiterung, wird hier benutzt.

Aufspannender minimaler Baum

//Teilbaum B besteht anfangs aus einem beliebigen Knoten
while [ B noch nicht GV aufspannt ]
do [ suche kostengünstige von B ausgehende Kante ];
     [ füge diese Kante zu B hinzu ];
od

Eine Verfeinerung der Suche nach der kostengünstigsten Kante ist notwendig!

Suche nach kostengünstigster Kante

Die intuitive Vorgehensweise erfordert jeweils |W|(|V|-|W|) Vergleiche für ein gegebenes W. Das ganze |V| mal, also eine Gesamtlaufzeit von $O(n^{3})$ . Man kann die Suche auf die Teilmengen $F\subseteq E$ beschränken, so dass F immer die günstigste aus b ausgehende Kante enthält, wesentlich weniger Kanten hat als |W|(|V|-|W|) und im Verlauf des Algorithmus einfach anpassbar ist.

Wahl von F

Alternativen:

a) F enthält für jeden Knoten v in B die günstigste von v aus B herausführende Kante

b) F enthält für jeden Knoten v außerhalb B die günstigste von v in B hineinführende Kante

Bewertung:

a) Mehrere Kanten können zum gleichen Knoten herausführen – redundant und änderungsaufwändig (bei Wahl dieses Knotens darf er nicht mehr verwendet werden und alle Verbindungen zu diesem Knoten müssen gelöscht werden)

b) Daher: Wahl von b)

Erste Verfeinerung

// Teilbaum B 
		[ B:= ({ beliebiger Knoten v }, {}) ]

		// Menge der Kandidatenkanten F
		[ F:= alle nach v führenden Kanten ]

		// alle Knoten betrachten
		for i := 1 to |V|-1
		do 	[ suche günstigste Kante f=(u,w) in F ];
			[ Füge f zu B hinzu (natürlich auch w) ];
		     	[ Aktualisiere F ];
		od

F muss nach jedem Durchlauf angepasst werden. Wenn f aus F entfernt wird erkennt man, dass der Teilgraph B tatsächlich ein Baum ist. Nun haben wir den neu verbundenen Knoten w. Jeder noch nicht verbundene Knoten x hat nun eine günstigste Verbindung entweder wie zuvor, oder aber mit dem neu hinzugefügten Knoten w!

Zweite Verfeinerung

// Teilbaum B 
		[ B:= ({ beliebiger Knoten v },{}) ]
		// Menge der Kandidatenkanten F
		[ F:= alle nach v führenden Kanten ]
		
		for i := 1 to |V|-1
		do 	
			// Sei v∈B, w∈B
			[ suche günstigste Kante f=(v,w) in F ];
			[ Füge f zu B hinzu ];
			// Aktualisiere F	
		     	[ Entferne f aus F ];
			// x in B, w neuerdings in B, y noch nicht in B
			for [ alle Kanten e=(x,y)∈F]
			do 
				if [ c((w,y))<c(e)] then [ Ersetze e durch (w,y) ] fi
			od	
		od

Kommunikationsnetz

i:

$B_{0}=(\{A\},\{\})$

$F_{0}=\{(A,E),(A,D),(A,C),(A,B)\}$

$f_{1}=(A,E)$ ist am günstigsten

$B_{1}=(\{A,E\},\{(A,E)\})$

$F_{1}=\{(A,D),(A,C),(A,B)\}$

$(A,D):F_{1}^{1}=\{(D,E),(A,C),(A,B)\}$

$(A,C):F_{1}^{2}=\{(D,E),(C,E),(A,B)\}$

$(A,B):F_{1}^{3}=\{(D,E),(C,E),(B,E)\}$

$f_{2}=(E,B)$

….

Analyse

Terminierungstheorem

Der Algorithmus von Prim terminiert nach endlicher Zeit.

Beweis

Einfache Schleifenanalyse

Laufzeittheorem

Wird für die Implementierung von F ein Fibonacci‐Heap benutzt, so hat der Algorithmus von Prim eine Laufzeit von O(|E| + |V| log |V|).

Korrektheitstheorem

Ist G ein verbundener ungerichteter gewichteter Graph, so berechnet der Algorithmus von Prim einen minimalen Spannbaum von G.

Beweis

Wir betrachten eine einfache Version des Algorithmus.

while [ B noch nicht GV aufspannt ]
do [ suche kostengünstige von B ausgehende Kante ]; 
     [ füge diese Kante zu B hinzu ];
od

Wir beobachten, dass B am Ende ein Spannbaum ist. Jetzt ist noch zu zeigen, dass B am Ende ein minimaler Spannbaum ist.

Sei B‘ ein minimaler Spannbaum von G und B≠B‘. Betrachte den Zeitpunkt in der Hauptschleife, an dem sich die Konstruktion von B von B‘ unterscheidet. Sei e die Kante, die dann zu B hinzugefügt wird. Sei $V_{1}$ die Menge der Knoten, die schon in B sind und $V_{2}=V$ \ $V_{1}$ Da B‘ ein minimaler Spannbaum ist, gibt es eine Kante e', die $V_{1}$ mit $V_{2}$ verbindet. Da im Algorithmus stets eine günstigste Kante gewählt wird, muss gelten g(e)≤g(e‘). Tauschen wir in B‘ die Kante e‘ durch e erhalten wir also einen minimalen Spannbaum, der nicht mehr kostet als B‘, es folgt g(e)=g(e‘). Induktiv folgt damit die Korrektheit.

Grundlagen

Grundlagen der Optimierung

Auf dieser Seite gibt es eine Einführung in das Thema Optimierung.

Die (Mathematische) Optimierung beschreibt eine Familie von Lösungsstrategien zur Maximierung/Minimierung einer Zielfunktion unter Nebenbedingungen. Viele der bisher untersuchten Probleme können als Optimierungsproblem modelliert werden. Zum Beispiel das Kürzeste Wege Problem: Minimiere die Länge eines Pfades unter der Nebenbedingung, dass der Pfad zwei gegebene Knoten verbindet. Oder das Rucksackproblem: Maximiere den Gesamtnutzen der Gegenstände unter der Nebenbedingung, dass die Kapazität des Rucksacks eingehalten wird. Oder das Flussprobleme: Maximiere den Fluss unter der Nebenbedingung, dass Kantenkapazitäten eingehalten werden.

Algorithmen wie Djikstra und Ford-Fulkerson sind domänenspeziﬁsche Algorithmen zur Lösung ihrer jeweiligen Optimierungsprobleme. Mathematische Optimierungsverfahren sind allgemeine Verfahren, die auf eine Vielzahl von Problemen anwendbar sind, dabei aber eventuell nicht immer so effizient wie speziellere Algorithmen sind.

Optimierung ist eine weites Feld, wir werden uns in dieser Vorlesung auf einen kleinen Ausschnitt konzentrieren:

Grundlagen der Optimierung
Kombinatorische Optimierung
Lineare Optimierung
Das Simplex‐Verfahren

Begriffe

Ein allgemeines (reelles) Optimierungsproblem ist gegeben durch P: Minimiere f(x)unter der Nebenbedingung $x\in X~mitX\subseteq \mathbb {R} ^{n}~und~f:X\to \mathbb {R}$ . f ist dabei die Zielfunktion. $x\in \mathbb {R} ^{n}$ heißt zulässig für P, falls $x\in X$ . X ist die zulässige Menge und $x'\in X$ heißt globales Minimum von P, falls $\forall x\in X:f(x')\leq f(x)$ . Äquivalent gilt P: Minimiere f(x) unter der Nebenbedingung $x\in X$ und P': Maximiere -f(x) unter der Nebenbedingung $x\in X$ .

Beispiel Gewinnmaximierung

Eine Firma produziert zwei verschiedene Waren. Ware x1 erbringt einen Gewinn von einem Euro. Ware x2 erbringt einen Gewinn von 6 Euro.

Frage: Welches Verhältnis von x1 und x2 führt zum größten Gewinn?

Nebenbedingungen:

Die Firma kann täglich maximal 200 Einheiten der Ware x1 produzieren und maximal 300 Einheiten der Ware x2 .

Insgesamt kann die Firma maximal 400 Einheiten pro Tag produzieren.

Zuerst wird nun die Zielfunktion formuliert: Maximiere Gewinn (1 Euro pro $x_{1}$ , 6 Euro pro $x_{2}$ ) : $max~x_{1}+6\cdot x_{2}$ .

Anschließend werden die Nebenbedingungen formuliert.

Maximal 200 Exemplare von x1 $x_{1}\leq 200$

Maximal 300 Exemplare von x2 $x_{2}\leq 300$

Insgesamt maximal 400 Exemplare $x_{1}+x_{2}\leq 400$

Es müssen Waren produziert werden $x_{1},x_{2}\geq 0$

Der Punkt $(0,0)\in \mathbb {R} ^{2}(x_{1}=0,x_{2}=0)$ ist zulässig mit Funktionswert 0 $maxx_{1}+6\cdot x_{2}$

Der Punkt $(100,200)\in \mathbb {R} ^{2}$ ist zulässig mit Funktionswert 1400 $x_{2}\leq 200$

Der Punkt $(100,300)\in \mathbb {R} ^{2}$ ist zulässig mit Funktionswert 1900 und globales Maximum $x_{1}+x_{2}\leq 400$

Der Punkt $(200,300)\in \mathbb {R} ^{2}$ ist unzulässig $x_{1},x_{2}\geq 0$

Dieses Beispiel ist ein lineares Optimierungsproblem.

Beispiel Kürzester Weg

Es soll die Distanz von s nach y bestimmt werden. Dafür sollen folgende Variablen und Bezeichner betrachtet werden.

$e_{a,b}\in \{0,1\}$ : die Kante von a nach b ist Teil des kürzesten Pfades von s nach y für alle Kanten (a,b)
$w_{a,b}$ : Das Gewicht der Kante von a nach b, zum Beispiel $w_{s,u}=10$
Die Zielfunktion ist $min~e_{s,u}w_{s,u}+e_{s,x}w_{s,x}+...+e_{v,y}w_{v,y}$

Es gelten folgende Nebenbedingungen:

Die Gewichte müssen wie im Graph sein $w_{s,u}=10,w_{s,u}=5,...$
Alle Kanten (a,b) mit $e_{a,b}=1$ $e_{a,b}=1$ müssen einen Pfad von s nach y bilden:
1. Es gibt genau eine Kante mit Startpunkt s: $e_{s,u}+e_{s,x}=1$
2. Es gibt genau eine Kante mit Zielpunkt y: $e_{v,y}+e_{x,y}=1$
3. Für jeden anderen Knoten gilt, falls eine Kante in diesen Knoten reinführt, muss er auch wieder eine rausführen, zum Beispiel für $x:e_{s,x}+e_{u,x}=e_{x,u}+e_{x,y}$

Beachte durch die Minimierung werden Kreise auf dem Pfad automatisch verhindert.

Vollständiges Optimierungsproblem für ein kleines Beispiel von u nach x:

$min~e_{u,v}w_{u,v}+e_{u,w}w_{u,w}+e_{v,w}w_{v,w}+e_{w,x}w_{w,x}$

$w_{u,v}=4$

$w_{u,w}=6$

$w_{v,w}=1$

$w_{w,x}=2$

$e_{u,v}+e_{u,w}=1$

$e_{w,x}=1$

$e_{u,v}=e_{v,w}$

$e_{u,w}+e_{v,w}=e_{w,x}$

$e_{u,v},e_{u,w},e_{v,w},e_{w,x}\in \{0,1\}$

Das Problem der Kürzesten-Wegfindung ist ein ganzzahliges Optimierungsproblem, allgemeiner ein kombinatorisches Optimierungsproblem.

Problemklassen

Optimierungsprobleme sind unterschiedlich schwer lösbar $max,min~f(x_{1},...x_{n})$

lineare Probleme: f,h sind linear, z.B. f/x,y)=3x+4y. Diese sind einfach zu lösen $h_{1}(x_{1},...,x_{n})\leq b_{1}$
Quadratische Probleme: z.B. $f(x,y)=x^{2}+xy$ sind auch noch einfach zu lösen. $h_{m_{1}}(x_{1},...,x_{n})\leq b_{m_{1}}$
Konvexe Probleme: z.B. min $f(x,y)=log(x)+log(y)$ sind schon schwerer zu lösen. $i_{1}(x_{1},...,x_{n})<c_{1}$
Nicht-konvexe Probleme: z.B. $f(x,y)=x~sin(x)$ sind ziemlich schwer zu lösen. $i_{m-2}(x_{1},...,x_{n})<c_{m-2}$
Ganzzahlige Probleme: $x_{1},...,x_{n}\in \mathbb {Z}$ sind überraschenderweise schwerer zu lösen als reelle Probleme. Etwa allgemeiner handelt es sich hier um kombinatorische Probleme (diskrete Elemente, nicht notwendigerweise Zahlen)
Weitere Parameter
- Restringierte Probleme: zulässige Menge ist beschränkt
- Unrestringierte Probleme: zulässige Menge ist unbeschränkt

Hier werden wir uns aber nur mit linearer Optimierung befassen.

Kombinatorische Optimierung

Auf dieser Seite wird die kombinatorische Optimierung behandelt. Kombinatorische Optimierungsprobleme sind im allgemeinen sehr schwer. Beispielsweise das Travelling Salesman Problem, oder die Knotenüberdeckung( Vertex Cover). Allgemeine Algorithmen sind meist sehr ineffizient. Deswegen benutzt man meistens domänenspezifische Algorithmen, so wie bei unseren bisherigen Beispielen. Wir schauen und jetzt noch ein weiteres Beispiel an.

Das Rucksackproblem

Hierbei handelt es sich um ein einfaches kombinatorisches Optimierungsproblem. Gegeben ist ein Rucksack mit der maximalen Kapazität C und n Gegenstände mit jeweils dem Gewicht $g_{i}$ und dem Wert $w_{i}$ . Gesucht wird die Auswahl der Gegenstände, so dass das Gesamtgewicht die Kapazität nicht überschreitet $\sum _{i\in I}g_{i}\leq C$ und die Summe der Werte maximal ist $\sum _{i\in I}w_{i}$ ist maximal. Es gibt dafür $2^{n}$ Möglichkeiten.

Generieren

zunächst werden die Objekte generiert:

 
public class Ding {
   public int gewicht, nutzen; 
   static private java.util.Random ra = new java.util.Random(); 

   // generieren
   Ding() { 
      gewicht = ra.nextInt(MAX_GEWICHT) + 1;
      nutzen = ra.nextInt(MAX_NUTZEN) + 1; 
   }
}

Es werden statische Variablen für die Problembeschreibung genutzt. Das Gewicht und der Nutzen der Objekte werden in einem eindimensionalem Array der Größe anzahlObjekte erstellt.

 
public class Rucksack {
   static int anzahlObjekte=10; 
   static ding [ ] auswahlObjekte = null; 
   …

Die Gewichte und Nutzwerte werden zufällig zwischen 1 und dem jeweiligem Maximalwert generiert.

 
static final int MAX_GEWICHT = 10;
static final int MAX_NUTZEN = 10;

Generierung der Auswahlobjekte:

 
static Ding [ ] erzeugeObjekte() {
   Ding[] r = new Ding[anzahlObjekte]; 
   for (int i = 0; i < anzahlObjekte; i++ ) {
      r[i] = new ding(); 
   } 
   return r;  
}
 …

Die Kapazität der Rucksäcke ist eine weitere statische Variable.

 
 static int kapazitaet;

Eine willkürlich gewählte Initialisierung der Main Methode ist:

 
kapazitaet = (int) (anzahlObjekte * MAX_GEWICHT / 4);

Dadurch passen im Schnitt nur die Hälfte der Gegenstände in den Rucksack.

Nun wird ein Rucksack als Auswahl der vorgegebene Dinge Implementiert, hierbei handelt es sich um die einzige nicht statische Variable.

 
 boolean[] auswahl = null;

Der Konstruktor zum Erzeugen einen leeren Rucksacks lautet:

 
Rucksack () {
   auswahl = new boolean [anzahlObjekte]; 
   for (int i = 0; i < anzahlObjekte; i++ ){
      auswahl[i] = false; 
   }
}

Es gibt einen Copy-Konstruktor zum Erzeugen einer Kopie eines existierenden Rucksacks. Die toString() Methode wird zur Ausgabe eines Rucksacks benutzt. Eine Methode zum Berechnen des Gesamtgewichts und des Gesamtnutzens lautet zum Beispiel:

 
int gewicht () {
   int g = 0; 
   for (int i=0; i < auswahl.length; i++ )
      if (auswahl[i] == true) 
         g = g + auswahlObjekte[i].gewicht; 
   return g; 
}

Index i	0	1	2	3	4	5
Gewicht	7	5	8	3	3	2
Nutzen	1	5	2	2	1	9

Rucksack 1 beinhaltet die Gegenstände 0,2 und 3, hatte ein Gesamtgewicht von 18 und einen Gesamtnutzen von 5.

Rucksack 1	T	F	T	T	F	F

Rucksack 2 beinhaltet die Gegenstände 1,2 und 5, hatte ein Gesamtgewicht von 15 und einen Gesamtnutzen von 16.

Rucksack 2	F	T	T	F	F	T

Das Rucksackproblem als Greedy Algorithmus

Nun wird das Rucksackproblem mit dem Greedy Algorithmus gelöst. Wir erinnern uns, das Greedy-Grundprinzip ist es in jedem Berechnungsschritt die jeweils aktuell geeignetste Zwischenlösung zu verwenden. Angewandt auf unser Rucksackproblem bedeutet das, lege von den noch nicht im Rucksack befindlichen Gegenständen jeweils den „besten“ hinzu. Doch was ist der beste Gegenstand? Der nützlichste? Der leichteste? Der mit dem besten Verhältnis aus Nutzen und Gewicht?

Algorithmus nach Nutzen

static Rucksack packeGierigNachNutzen() {
	Rucksack r = new Rucksack();
	while (true) {
		int pos=-1; int besterNutzen = 0;
		for (int i=0; i<auswahlObjekte.length; i++)
			if (r.auswahl[i] == false &&
				auswahlObjekte[i].nutzen > besterNutzen &&
				r.gewicht() + auswahlObjekte[i].gewicht <= 
					kapazitaet) {
			   besterNutzen = auswahlObjekte[i].nutzen;
			   pos = i;
			}
		if (pos == -1) break;
		else r.auswahl[pos] = true;
	}
	return r;
}

Algorithmus nach Gewicht

static Rucksack packeGierigNachGewicht() {
	Rucksack r = new Rucksack();
	while (true) {
		int pos=-1; int bestesGewicht = MAX_GEWICHT+1;
		for (int i=0; i<auswahlObjekte.length; i++)
			if (r.auswahl[i] == false &&
				auswahlObjekte[i].gewicht < bestesGewicht &&
				r.gewicht() + auswahlObjekte[i].gewicht <= 
					kapazitaet) {
			   bestesGewicht = auswahlObjekte[i].gewicht;
			   pos = i;
			}
		if (pos == -1) break;
		else r.auswahl[pos] = true;
	}
	return r;
}

Aufruf in main()

public static void main (String args[]) {
	if (args.length == 1)
		anzahlObjekte = Integer.parseInt(args[0]);
	kapazitaet = (int) (anzahlObjekte * MAX_GEWICHT / 4);
	auswahlObjekte = erzeugeObjekte();

	Rucksack r1 = packeGierigNachGewicht();
	System.out.println(„Greedy Gewicht: „ + r1);

	Rucksack r2 = packeGierigNachNutzen();
	System.out.println(„Greedy Nutzen: „ + r2);
	…

Analyse

Der Vorteil ist der relativ geringe Berechnungsaufwand durch die quadratische Komplexität $O(n^{2})$ . Das Problem ist aber, dass nicht die optimale Lösung gefunden wird.

Rucksackproblem als Backtracking

Nun wird das Rucksackproblem mit Backtracking gelöst. Das Grundprinzip ist es, die optimale Lösung durch systematisches Absuchen des gesamten Lösungsraums zu finden. Angewandt auf unser Rucksackproblem bedeutet das, es gibt $2^{n}$ verschiedene Möglichkeiten, wir generieren und testen alle möglichen Rucksäcke und wir wenden Rekursion an.

Rekursionseinstieg

static Rucksack packeOptimalmitBacktracking() {
   return rucksackRekursiv(0, new Rucksack());
}

Erster Parameter: Level i – Entscheidung, ob Objekt i in den Rucksack kommt
Durchlaufen des Auswahl-Arrays von links nach rechts
Aufrufgraph: Aufspannen eines binären Baumes durch ja/nein-Entscheidungen

Rekursion

static rucksackRekursiv(int i, Rucksack r) {
		if (i==auswahlObjekte.length) return r;
		// Objekt i nicht nehmen und rekurrieren
		Rucksack r1 = new Rucksack(r);
		r1 = rucksackRekursiv(i+1, r1);
		// Objekt i – falls moeglich – nehmen und rekurrieren
		if (r.gewicht()+auswahlObjekte[i].gewicht<=kapazitaet){
			Rucksack r2 = new Rucksack(r);
			r2.auswahl[i] = true;
			r2 = rucksackRekursiv(i+1,r2);
			// Den besseren Rucksack immer zurueckgeben
			if (r2.nutzen() > r1.nutzen()) 
				return r2;
		}	
		return r1; 
	}

Analyse

Das Problem ist hier, dass es einen extrem hohen Berechnungsaufwand für die große Auswahl an Objekten gibt. Die Komplexität liegt bei $O(2^{n})$ . Der Vorteil ist, dass man garantiert die optimale Lösung finden, da im schlimmsten Fall jede Möglichkeit ausprobiert wird. Also wird in jedem Fall ein Optimum gefunden.

Rucksackproblem als dynamische Programmierung

Nun wird das Rucksackproblem mit dynamischer Programmierung gelöst. Wir erinnern uns, dass das Grundprinzip der dynamischen Programmierung die Wiederverwendung von bereits berechneten Teillösungen ist. Aber an dieser Stelle ist Vorsicht geboten mit den anderen Lösungen aus den vorherigen Seiten, wo Teillösungen Bottom up zusammengesetzt wurden. Hier basieren die Lösungen auf der Backtracking Variante. Teillösungen werden zwischengespeichert. Die Existenz von Teillösungen wird als Abbruchkriterium für die Rekursion verwendet.

Rekursionseinstieg

static Rucksack packeMitDynamischerProgrammierung()
   Rucksack [][] zwischenErgebnisse=
      new Rucksack[kapazitaet+1][anzahlObjekte];
   return rucksackRekursivDP (0, new Rucksack(), zwischenErgebnisse);
}

Ein Eintrag zwischenErgebnisse[g][i] bedeutet, dass wir schon ein mal dabei waren, das Objekt i in einen Rucksack mit dem Gewicht g zu legen. In diesem Fall können wir alle vor berechneten Entscheidungen für die Objekte i bis anzahlObjekte −1 wiederverwenden, da diese bereits optimal sind (Backtracking: äquivalenter Teilbaum).

Rekursion

static Rucksack rucksackRekursivDP (int i, Rucksack r, Rucksack [][] zwischenErgebnisse){
   if (i == auswahlObjekte.length) return r;
   int gewicht = r.gewicht();
   // Wiederverwendung von Teillösungen:
   if (zwischenErgebnisse[gewicht][i] != null}{
      for (int j = i; j < anzahlObjekte; j++)
         r.auswahl[j] = zwischenErgebnisse[gewicht][i].auswahl[j];
      return r;
   }
   Rucksack r1 = new Rucksack (r);
   r1 = rucksackRekursivDP(i+1, r1, zwischenErgbenisse);
   if (gewicht+auswahlObjekte[i].gewicht <= kapazitaet){
      Rucksack r2 = new Rucksack (r);
      r2.auswahl[i] = true;
     
      if (r2.nutzen() > r1.nutzen()) r1 = r2;
   }
   // Merken von Teillösungen:
   zwischenErgebnisse[gewicht][i] = r1;
   return r1;
}

Analyse

Die Vorteile der dynamischen Programmierung sind, dass auf jeden Fall die optimale Lösung gefunden wird. In vielen Fällen hat sie auch einen geringeren Aufwand als Backtracking. Das Problem ist allerdings, dass die Anwendbarkeit und der Aufwand abhängig von der Größe und der Struktur des Suchraums sind. Die Komplexität beträgt O(z), wobei z die Anzahl der möglichen Zwischenergebnisse ist. Zum Beispiel: bei vielen unterschiedlichen Gewichtskombinationen kaum Ersparnis (Erhöhen von MAX_GEWICHT). Außerdem existieren polynomielle Approximationen!

Lineare Optimierung

Auf dieser Seite wird die lineare Optimierung behandelt. Eine lineare Optimierungsaufgabe ist: Maximiere eine lineare Funktion in mehreren Variablen

$max~c_{1}x_{1}+...+c_{n}x_{n}\ c_{i},x_{i}\in \mathbb {R} \Leftrightarrow maxc^{T}x$ .

Die lineare Nebenbedingung sind gegeben als lineare Gleichungen:

$a_{11}x_{1}+...a_{1n}x_{n}=b_{1}$

...

$a_{m1}x_{1}+...a_{mn}x_{n}=b_{m}$

$\forall i=1,...,n:x_{i}\geq 0$

Dies entspricht dem Gleichungssystem:

$Ax=b,x\geq 0,a\in \mathbb {R} ^{mxn},b\in \mathbb {R} ^{m},x\in \mathbb {R} ^{n}$

Doch ist das ausdrucksstark genug für unsere Probleme?

Umformung von Gleichungssystemen

Beliebige Systeme lassen sich in die Standardform übertragen.

Minimieren ist wie maximieren: $min~c^{T}x=max-c^{T}x$
$\geq$ Bedingungen statt $\leq$ Bedingungen: $a_{i}^{T}x\leq b_{i}\Leftrightarrow -a_{i}^{T}x\geq -b$
Gleichung zu Ungleichung: $a_{i}^{T}x=b_{i}\Leftrightarrow a_{i}^{T}x\geq b\land a_{i}^{T}x\leq b_{i}$
Ungleichung zu Gleichung (Schlupfvariablen einführen): $a_{i}^{T}x\leq b_{i}\Leftrightarrow a_{i}^{T}x+s=b,s\geq 0$
$x_{i}$ kann negativ sein: $x_{i}=s-t,s\geq 0,t\geq 0$

Beispiel Gewinnmaximierung

Eine Firma produziert zwei verschiedene Waren. Ware $x_{1}$ erbringt einen Gewinn von einem Euro. Ware $x_{2}$ erbringt einen Gewinn von 6 Euro. Die Frage hierzu lautet, welches Verhältnis von $x_{1}$ und $x_{2}$ führt zum größten Gewinn? Dazu gibt es zwei Nebenbedingungen:

Die Firma kann täglich maximal 200 Einheiten der Ware $x_{1}$ produzieren und maximal 300 Einheiten der Ware $x_{2}$
Insgesamt kann die Firma maximal 400 Einheiten pro Tag produzieren

Die Firma beschließt eine weitere Ware zu produzieren.

Die Ware $x_{3}$ bringt einen Gewinn von 13 Euro.
Die maximale Tagesproduktion liegt weiterhin bei 400 Einheiten.
Für die Produktion von Ware $x_{2}$ und Ware $x_{3}$ wird dieselbe Maschine verwendet, allerdings ist der Produktionsaufwand für $x_{3}$ dreimal höher. Insgesamt kann die Maschine 600 Arbeitsschritte leisten.

Formuliere, die Zielfunktion: $max~x_{1}+6\cdot x_{2}+13\cdot x_{3}$ .

Anschließend formuliere die Nebenbedingungen:

$x_{1}\leq 200$

$x_{2}\leq 300$

$x_{1}+x_{2}+x_{3}\leq 400$

$x_{2}+3\cdot x_{3}\leq 600$

$x_{1},x_{2},x_{3}\geq 0$

Die Nebenbedingungen definieren ein drei-dimensionales Polyeder, in dem die optimale Lösung liegt.

Nun formen wir in die Normalform um:

$max~x_{1}+6\cdot x_{2}+13\cdot x_{3}\to max~x_{1}+6\cdot x_{2}+13\cdot x_{3}$

$x_{1}\leq 200\to x_{1}+s_{1}=200$

$x_{2}\leq 300\to x_{2}+s_{2}=300$

$x_{1}+x_{2}+x_{3}\leq 400\to x_{1}+x_{2}+x_{3}+s_{3}=400$

$x_{2}+3\cdot x_{3}\leq 600\to x_{2}+3\cdot x_{3}+s_{4}=600$

$x_{1},x_{2},x_{3}\geq 0\to x_{1},x_{2},x_{3},s_{1}.s_{2}.s_{3},s_{4}\geq 0$

Die Nebenbedingungen definieren nun ein Polyeder, in dem die optimale Lösung liegt.

Die Zielfunktion $c=x_{1}+6\cdot x_{2}$ ist eine Gerade. Nun wird die Gerade verschoben, bis das Maximum erreicht ist.

Die Linearen Optimierungsprobleme der Form

$max~c^{T}x$

$(1)Ax=b;\ x\geq 0~$

$(2)Ax\leq b;\ x\geq 0$

besitzen genau dann eine endliche Optimallösung, wenn sie eine optimale Ecklösung (= „Ecke“ des zugehörigen Polyeders) besitzen. D.h. man muss zur Lösungsfindung nur die Ecken des Polyeders betrachten.

Simplex Verfahren

Auf dieser Seite wird das Simplex Verfahren behandelt.

Idee

Es wird in einer beliebigen Ecke des Polyeders begonnen. Dann wird verglichen, ob einer der Nachbarn eine bessere Lösung für die Optimierung bietet und anschließend wird dieser Knoten betrachtet. Am Ende erreichen wir eine Ecke, die keinen Nachbarn mit einer besseren Lösung hat. Die Lösung ist nun ein lokales Optimum. Bei der linearen Optimierung gilt, dass ein lokales Optimum automatisch ein globales Optimum ist, da der Polyeder eine konvexe Menge ist. Graphisch kann mit dieser Idee jedes lineare Optimierungsproblem gelöst werden. Dies wird aber sehr schnell unübersichtlich (und kann schlecht implementiert werden). Wir benötigen eine einfache Charakterisierung der “Ecken” des Polyeders. Diese erhalten wir durch Betrachtung der Basen der Matrix A.

Das Simplex-Verfahren löst ein lineares Programm in endlich vielen Schritten oder stellt seine Unlösbarkeit oder Unbeschränktheit fest. Im Worstcase hat es exponentielle Laufzeit unabhängig von den gewählten Pivotregeln, in der Praxis ist es sehr effizient. Das Simplex-Verfahren berechnet auch die Lösung für das duale Problem zu einem linearen Programm.

Wiederholung algebraischer Grundlagen

Seien $v_{1},...,v_{n}\in \mathbb {R} ^{m}$ .

Die Linearkombination von $v_{1},...,v_{n}$ mit den Koeffizienten $\alpha _{1},...,\alpha _{n}\in \mathbb {R} ^{m}$ ist der Vektor $\alpha _{1}v_{1}+...+\alpha _{n}v_{n}$ .
Die Vektoren $v_{1},...,v_{n}$ sind linear abhängig, wenn es ein $i\in \{1,...,n\}$ gibt, so dass sich $v_{i}$ als Linearkombination von $v_{1},...,v_{i-1},v_{i+1},...,v_{n}$ darstellen lässt.
Eine maximale Menge linear unabhängiger Vektoren heißt Basis des zugehörigen Raumes. Eine Basis des $\mathbb {R} ^{m}$ besteht beispielsweise aus m linear unabhängigen Vektoren.
Der Rang einer Matrix A ist die maximale Anzahl linear unabhängiger Spaltenvektoren.

Matrix lineares Optimierungsproblem

$max~x_{1}+6\cdot x_{2}$

$x_{1}+s_{1}=200$

$x_{2}+s_{2}=300$

$x_{1}+x_{2}+s_{3}=400$

$A={\begin{pmatrix}1&0&1&0&0\\0&1&0&1&0\\1&1&0&0&1\end{pmatrix}}$ , $b={\begin{pmatrix}200\\300\\400\end{pmatrix}}$

Da wir für jede unserer ursprünglichen Ungleichungen eine Schlupfvariable eingeführt haben, gilt stets Rang(A)=m (=Anzahl der Gleichungen=Länge des Vektors b).

Basis und Basislösung

Auf dieser Seite werden die Basen und Basislösungen beim Simplex Verfahren behandelt. Gegeben ist ein lineares Gleichungssystem $ax=b,A\in \mathbb {R} ^{mxn},b\in \mathbb {R} ^{m},Rang(A)=m$ .

Dann bilden m lineare unabhängige Spaltenvektoren aus A eine Basis von A. Diese wird mit $A_{B}$ bezeichnet. B enthält die Indices der Basisvektoren. N enthält die Indices der Nichtbasisvektoren. Die Basislösung $x_{B}~von~A_{B}$ ist gegeben durch: $A_{B}x_{B}=b$ dies gilt genau dann wenn: $x_{B}=A_{B}^{-1}b$ . $A_{B}$ ist eine zulässige Basis von A, wenn gilt $A_{B}^{-1}b\geq 0$ . Wenn $(X_{B}X_{N})~mit~X_{N}=0$ ist, dann ist es eine zulässige Basislösung von A.

Beispiel 1

${\begin{pmatrix}1&0&1&0&0\\0&1&0&1&0\\1&1&0&0&1\end{pmatrix}}{\begin{pmatrix}x_{1}\\x_{2}\\s_{1}\\s_{2}\\s_{3}\end{pmatrix}}={\begin{pmatrix}200\\300\\400\end{pmatrix}}$

$B1=\{3,4,5\}~N1=\{1,2\}$

$A_{B1}={\begin{pmatrix}1&0&0\\0&1&0\\0&0&1\end{pmatrix}}$ $X_{B1}={\begin{pmatrix}s_{1}\\s_{2}\\s_{3}\end{pmatrix}}$

$A_{B1}X_{B1}=b\Rightarrow {\begin{pmatrix}1&0&0\\0&1&0\\0&0&1\end{pmatrix}}{\begin{pmatrix}s_{1}\\s_{2}\\s_{3}\end{pmatrix}}={\begin{pmatrix}200\\300\\400\end{pmatrix}}\Rightarrow s_{1}=200,s_{2}=300;s_{3}=400$

Nicht-Basisvariablen werden stets auf 0 gesetzt. Die zulässige Basislösung von A mit Zielfunktionswert 0, die man durch einsetzen erhält ist dann (0,0,200,300,400).

Beispiel 2

${\begin{pmatrix}1&0&1&0&0\\0&1&0&1&0\\1&1&0&0&1\end{pmatrix}}{\begin{pmatrix}x_{1}\\x_{2}\\s_{1}\\s_{2}\\s_{3}\end{pmatrix}}={\begin{pmatrix}200\\300\\400\end{pmatrix}}$

$B2=\{1,4,5\}~N2=\{2,3\}$

$A_{B2}={\begin{pmatrix}1&0&0\\0&1&0\\1&0&1\end{pmatrix}}$ $X_{B2}={\begin{pmatrix}x_{1}\\s_{2}\\s_{3}\end{pmatrix}}$

$A_{B2}X_{B2}=b\Rightarrow {\begin{pmatrix}1&0&0\\0&1&0\\1&0&1\end{pmatrix}}{\begin{pmatrix}x_{1}\\s_{2}\\s_{3}\end{pmatrix}}={\begin{pmatrix}200\\300\\400\end{pmatrix}}\Rightarrow x_{1}=200,s_{2}=300;s_{3}=200$

Nicht-Basisvariablen werden stets auf 0 gesetzt.

Die zulässige Basislösung von A, die man durch einsetzen erhält ist dann (200,0,0,300,200) mit dem Zielfunktionswert 200.

Basen von A

Hier gibt es eine Übersicht der Basen von A mit dessen zulässigen Lösungen.

$A_{B}$	$x_{B}$	$x_{N}$	x
$A_{B1}={\begin{pmatrix}1&0&0\\0&1&0\\0&0&1\end{pmatrix}}$	$(s_{1},s_{2},s_{3})=(200,300,400)$	$(x_{1},x_{2})$	$(0,0,200,300,400)$
$A_{B2}={\begin{pmatrix}1&0&0\\0&1&0\\1&0&1\end{pmatrix}}$	$(x_{1},s_{2},s_{3})=(200,300,200)$	$(x_{2},s_{1})$	$(200,0,0,300,200)$
$A_{B3}={\begin{pmatrix}1&0&0\\0&1&1\\1&1&0\end{pmatrix}}$	$(x_{1},x_{2},s_{2})=(200,200,100)$	$(s_{1},s_{3})$	$(200,200,000,100,0)$
$A_{B4}={\begin{pmatrix}1&0&1\\0&1&0\\1&1&0\end{pmatrix}}$	$(x_{1},x_{2},s_{1})=(100,300,100)$	$(s_{2},s_{3})$	$(100,300,100,0,0)$
$A_{B5}={\begin{pmatrix}0&1&0\\1&0&0\\1&0&1\end{pmatrix}}$	$(x_{2},s_{1},s_{3})=(300,200,100)$	$(x_{1},s_{3})$	$(0,300,200,0,100)$

$b={\begin{pmatrix}200\\300\\400\end{pmatrix}}$

Basen von A- mit unzulässigen Lösung

Hier gibt es eine Übersicht der Basen von A mit unzulässigen Lösungen.

$A_{B}$	$x_{B}$	$x_{N}$	x
$A_{B6}={\begin{pmatrix}1&0&0\\0&1&0\\1&1&1\end{pmatrix}}$	$(x_{1},x_{2},s_{3})=(100,300,-100)$	$(s_{1},s_{2})$	$(200,300,0,0,-100)$
$A_{B7}={\begin{pmatrix}0&1&0\\1&0&1\\1&0&0\end{pmatrix}}$	$(x_{2},s_{1},s_{2})=(400,200,-100)$	$(x_{1},s_{3})$	$(0,400,200,-100,0)$
$A_{B8}={\begin{pmatrix}1&1&0\\0&0&1\\1&0&0\end{pmatrix}}$	$(x_{2},s_{1},s_{2})=(400,-200,300)$	$(x_{1},x_{3})$	$(200,200,000,100,0)$
$A_{B4}={\begin{pmatrix}1&0&1\\0&1&0\\1&1&0\end{pmatrix}}$	$(x_{1},x_{2},s_{1})=(100,300,100)$	$(s_{2},s_{3})$	$(100,300,100,0,0)$
$A_{B5}={\begin{pmatrix}0&1&0\\1&0&0\\1&0&1\end{pmatrix}}$	$(x_{2},s_{1},s_{3})=(300,200,100)$	$(x_{1},x_{3})$	$(0,400,-200,300,0)$

Diese Basen haben keine zulässige Lösungen, da $x_{B}$ negative Werte enthält.

Die Teilmengen ${\begin{pmatrix}1&1&0\\0&0&0\\1&0&1\end{pmatrix}}{\begin{pmatrix}0&0&0\\1&1&0\\1&0&1\end{pmatrix}}$ von A sind keine Basen von A, da die Vektoren jeweils linear abhängig sind.

Charakterisierung von Polyederecken

Warum schauen wir uns Basen und Basislösungen an? Wir waren doch an Ecken des Polyeders interessiert...

Sei das System $Ax=b,x\geq 0$ gegeben, $Rang(A)=m<n$ . Dann sind äquivalent:

x ist eine Ecke des zugehörigen Polyeders
x ist eine zulässige Basislösung von Ax=b

Wir wissen, dass die optimale Lösung in einem Eckpunkt liegen muss, falls sie existiert. D.h. wir müssen nur über die Basen von A optimieren (diese bestimmen ja die zulässigen Basislösungen von Ax=b). Dies erfolgt mit sogenannten Tableaus.

Das Simplex-Verfahren besteht aus einer Folge von Basen bzw. Tableus.

Zuerst wird die zulässige Basis $A_{B}$ gefunden und daraus das Starttableau konstruiert.
Anschließend wir eine neue zulässige Basis $A_{B'}$ aus $A_{B}$ konstruiert, so dass die zulässige Basislösung von $A_{B'}$ besser ist, als die von $A_{B}$ . Das Tableau wird nun aktualisiert.
Wenn es keine bessere Basislösung mehr gibt, dann ist die letzte optimal.

Ein Tableau entspricht dem Gleichungssystem ${\begin{pmatrix}c^{T}\\A\end{pmatrix}}x={\begin{pmatrix}c^{T}x\\b\end{pmatrix}}$ mit $max~c^{T}x,Ax=b~und~x\geq 0$ .

$T_{B}$ ist ein Simplextableau zur Basis $A_{B}$

$T_{B}={\begin{pmatrix}c_{N}^{T}-c_{B}^{T}A_{B}^{-1}A_{N}&-c_{B}^{T}A_{B}^{-1}b\\A_{B}^{-1}A_{N}&A_{B}^{-1}b\end{pmatrix}}$ mit $A=(A_{B}A_{N}),x=(x_{B}x_{N}),c^{T}=(c_{N}^{T}c_{B}^{T})$

Beispiel Gewinnmaximierung

Nun wird der Simplex Algorithmus anhand des Beispiels der Gewinnmaximierung Schritt für Schritt durchgegangen.

Zielfunktion:

$max~x_{1}+6\cdot x_{2}+13\cdot x_{3}$ .

Nebenbedingungen:

$x_{1}\leq 200$

$x_{2}\leq 300$

$x_{1}+x_{2}+x_{3}\leq 400$

$x_{2}+3\cdot x_{3}\leq 600$

$x_{1},x_{2},x_{3}\geq 0$

Das System lässt sich umschreiben zu:

$x_{1}+6\cdot x_{2}+13\cdot x_{3}=z$

$x_{1}+s_{1}=200$

$x_{2}+s_{2}=300$

$x_{1}+x_{2}+x_{3}+s_{3}=400$

$x_{2}+3\cdot x_{3}+s_{4}=600$

$x_{1},x_{2},x_{3},s_{1},s_{2},s_{3},s_{4}\geq 0$

$A={\begin{pmatrix}1&0&0&1&0&0&0\\0&1&0&0&1&0&0\\1&1&1&0&0&1&0\\0&1&3&0&0&0&1\end{pmatrix}},b={\begin{pmatrix}200\\300\\400\\600\end{pmatrix}}$

Initialisierung

Gestartet wird mit der Basislösung, die durch die Schlupfvariable gegeben ist.

$A_{B}=(s_{1}\ s_{2}\ s_{3}\ s_{4})={\begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&1&0\\0&0&0&1\end{pmatrix}}=A_{B}^{-1}$

$A_{N}=(x_{1}\ x_{2}\ x_{3})={\begin{pmatrix}1&0&0\\0&1&0\\1&1&1\\0&1&3\end{pmatrix}}$ $b={\begin{pmatrix}200\\300\\400\\600\end{pmatrix}}$

$c^{T}={\begin{pmatrix}1&6&13&0&0&0&0\end{pmatrix}}={\begin{pmatrix}c_{N}^{T}&c_{B}^{T}\end{pmatrix}}$

$A_{B}^{-1}A_{N}={\begin{pmatrix}1&0&0\\0&1&0\\1&1&1\\0&1&3\end{pmatrix}}$ $A_{B}^{-1}b={\begin{pmatrix}200\\300\\400\\600\end{pmatrix}}$

Starttableau

	$x_{1}$	$x_{2}$	$x_{3}$	b
z	1	6	13	0
$s_{1}$	1	0	0	200
$s_{2}$	0	1	0	300
$s_{3}$	1	1	1	400
$s_{4}$	0	1	3	600

$x_{1},x_{2},x_{3}$ sind Nichtbasiselemente, Z ist die Zielfunktion und $s_{1},s_{2},s_{3},s_{4}$ sind Basiselemente. Dabei sind die blau hinterlegten Felder das $c_{N}^{T}-c_{N}^{T}A_{B}^{-1}A_{N}$ , die gelb hinterlegten Felder stellen den Teil von $A_{B}^{-1}A_{N}$ dar und die grünen Felder sind $A_{B}^{-1}b$ . Das nicht markierte Feld ist dabei der negative Zielfunktionswert $-c_{B}^{T}A_{B}^{-1}b$ .

Update eines Tableau

Für das Update eines Tableau wird eine neue zulässige Basis bestimmt, indem ein Basisvektor durch einen Nichtbasisvektor ausgetauscht wird. Die Menge der Nichtbasisvektoren, die getauscht werden können, ist über die positiven Koeffizienten c der Zielfunktion definiert als: $E=\{j|c_{x}x_{j}>0\}$ . Wenn $E=\emptyset$ dann breche ab und gebe x zurück. Die Menge der Basisvektoren, die getauscht werden können, ist über ihre j-te Komponente bestimmt: $L_{j}=\{i|x_{j}^{i}>0\}$ . Wenn $L_{j}=\emptyset$ für alle $j\in E$ dann ist das LP unbeschränkt, da die Zielfunktion $c^{T}x$ durch $x_{j}$ unbeschränkt wächst.

Optimierungsphase

Berechne für eine zulässige Basis, das zugehörige Tableau. Nun wird E bestimmt. Wenn $E=\emptyset$ dann wird abgebrochen und x zurückgegeben. Ansonsten wird $j\in E$ durch eine geeignete Pivotregel gewählt. Als nächstes wird $L_{j}$ bestimmt. Wenn $L_{j}=\emptyset$ dann wird zurückgegeben, dass LP unbeschränkt ist. Ansonsten wird $i\in L_{j}$ durch eine geeignete Pivotregel gewählt. Führe nun einen Basiswechsel durch und starte wieder oben.

Beispiel

	$x_{1}$	$x_{2}$	$x_{3}$	b
z	1	6	13	0
$s_{1}$	1	0	0	200
$s_{2}$	0	1	0	300
$s_{3}$	1	1	1	400
$s_{4}$	0	1	3	600

$E=\{j|c_{x}x_{j}>0\}=\{1,2,3\}~\{x_{1},x_{2},x_{3}\}$

$L_{1}=\{i|x_{1}^{i}>0\}=\{1,3\}~\{s_{1},s_{3}\}$

$L_{2}=\{i|x_{2}^{i}>0\}=\{2,3,4\}~\{s_{2},s_{3},s_{4}\}$

$L_{3}=\{i|x_{3}^{i}>0\}=\{3,4\}~\{s_{3},s_{4}\}$

Heuristik für die Auswahl der Tauschvektoren

Als erstes werden die größten Koeffizienten in der Zielfunktion gewählt (Dantzig). Eine andere Möglichkeit ist das steepest-edge pricing, welches die Kombination aus Spalten- und Zeilenvektor wählt, die den größten Zuwachs für die Zielfunktion bringt. Oder der kleinste Index wird gewählt. Die letzte Möglichkeit ist eine zufällige Auswahl.

Erste Iteration

Heuristik: Ersetze einen Basisvektor durch den Nichtbasisvektor, der den größten Zugewinn für die Zielfunktion bringt.

$x_{1}$

$0\leq s_{1}=200-x_{1}$

$0\leq s_{3}=400-x_{1}$

$x_{1}=min(200,400)=200\Rightarrow z=200$

Hier wird die Zeile von $s_{1}~und~s_{3}$ betrachtet und die Spalte von $x_{1}$ . Der alte Wert ist 0. Der Koeffizient von $x_{1}$ in der Zielfunktion ist 1 und der Zugewinn durch $x_{1}$ ist 200.

$x_{2}$

$0\leq s_{2}=300-x_{2}$

$0\leq s_{3}=400-x_{2}$

$0\leq s_{4}=600-x_{2}$

$x_{2}=min(300,400,600)=300\Rightarrow z=1800$

Hier wird die Zeile von $s_{2},s_{3}~und~s_{4}$ betrachtet und die Spalte von $x_{2}$ . Der alte Wert ist 0. Der Koeffizient von $x_{2}$ in der Zielfunktion ist 6 und der Zugewinn durch $x_{2}$ ist 1800.

$x_{3}$

$0\leq s_{3}=400-x_{3}$

$0\leq s_{4}=600-3x_{3}$

$x_{3}=min(400,200)=200\Rightarrow z=2600$

Hier wird die Zeile von $s_{3}~und~s_{4}$ betrachtet und die Spalte von $x_{3}$ . Der alte Wert ist 0. Der Koeffizient von $x_{3}$ in der Zielfunktion ist 13 und der Zugewinn durch $x_{3}$ ist 2600. Nun wird $s_{4}$ durch $x_{3}$ ersetzt.

Update des Tableaus

Der neue Wert von $x_{3}$ wird nun berechnet.

$s_{4}=600-x_{2}-3x_{3}\Leftrightarrow x_{3}=200-{\frac {x_{2}}{3}}-{\frac {s_{4}}{3}}$ .

Dieser Wert wird nun eingesetzt.

$z=x_{1}+6_{x_{2}}+13\cdot (200-{\frac {x_{2}}{3}}-{\frac {s_{4}}{3}})=x_{1}+{\frac {5}{3}}x_{2}-{\frac {13}{3}}s_{4}+2600$

$s_{3}=400-x_{1}-x_{2}-(200-{\frac {x_{2}}{3}}-{\frac {s_{4}}{3}})=200-x_{1}-{\frac {2}{3}}x_{2}+{\frac {s_{4}}{3}}$

$x_{3}=200-{\frac {x_{2}}{3}}-{\frac {s_{4}}{3}}$

Das neue Tableau sieht nun so aus:

	$x_{1}$	$x_{2}$	$s_{4}$	b
z	1	${\frac {5}{3}}$	$-{\frac {13}{3}}$	-2600
$s_{1}$	1	0	0	200
$s_{2}$	0	1	0	300
$s_{3}$	1	${\frac {2}{3}}$	$-{\frac {1}{3}}$	200
$x_{3}$	0	${\frac {1}{3}}$	${\frac {1}{3}}$	200

Was haben wir nun gemacht? Von der Basis $B=(s_{1},s_{2},s_{3},s_{4})$ haben wir zu der Basis $B'=(s_{1},s_{2},s_{3},x_{3})$ gewechselt und zu der neuen Basis haben wir das entsprechende Tableau bestimmt.

$T_{B}'={\begin{pmatrix}c_{N'}^{T}-c_{B'}^{T}A_{B'}^{-1}A_{N'}&-c_{B'}^{T}A_{B'}^{-1}b\\A_{B'}^{-1}A_{N'}&A_{B'}^{-1}b\end{pmatrix}}$

$A_{B'}={\begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&1&1\\0&0&0&3\end{pmatrix}}$ $A_{B'}^{-1}={\begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&1&-{\frac {1}{3}}\\0&0&0&{\frac {1}{3}}\end{pmatrix}}$ ${A_{N}}={\begin{pmatrix}1&0&0\\0&1&0\\1&1&0\\0&1&1\end{pmatrix}}$ $A_{B'}^{-1}A_{N}={\begin{pmatrix}1&0&0\\0&1&0\\1&{\frac {2}{3}}&-{\frac {1}{3}}\\0&{\frac {1}{3}}&{\frac {1}{3}}\end{pmatrix}}$ ${A_{B'}^{-1}b}={\begin{pmatrix}200\\300\\200\\200\end{pmatrix}}$

$c^{T}={\begin{pmatrix}1&6&0&0&0&0&13\end{pmatrix}}={\begin{pmatrix}c_{N'}^{T}&c_{B'}^{T}\end{pmatrix}}$

$c_{N'}^{T}-c_{B'}^{T}A_{B'}^{-1}A_{N'}={\begin{pmatrix}1&{\frac {5}{3}}&-{\frac {13}{3}}\end{pmatrix}}$

$-c_{B}^{T}A_{B}^{-1}b=-2600$

Zweite Iteration

$E=\{j|c_{x}x_{j}>0\}=\{1,2\}~\{x_{1},x_{2}\}$

$L_{1}=\{i|x_{1}^{i}>0\}=\{1,3\}~\{s_{1},s_{3}\}$

$L_{2}=\{i|x_{2}^{i}>0\}=\{2,3,4\}~\{s_{2},s_{3},x_{3}\}$

Heuristik: Ersetze einen Basisvektor durch den Nichtbasisvektor, der den größten Zugewinn für die Zielfunktion bringt.

$x_{1}$

$0\leq s_{1}=200-x_{1}$

$0\leq s_{3}=200-x_{1}$

$x_{1}=200\Rightarrow z=2800$

Hier wird die Zeile von $s_{1}~und~s_{3}$ betrachtet und die Spalte von $x_{1}$ . Der alte Wert ist 2600. Der Koeffizient von $x_{1}$ in der Zielfunktion ist 1 und der Zugewinn durch $x_{1}$ ist 200.

$x_{2}$

$0\leq s_{2}=300-x_{2}$

$0\leq s_{2}=200-{\frac {2}{3}}x_{2}$

$0\leq x_{2}=200-{\frac {1}{3}}x_{2}$

$x_{2}=min(300,600)=300\Rightarrow z=4400$

Hier wird die Zeile von $s_{2},s_{3}~und~x_{3}$ betrachtet und die Spalte von $x_{2}$ . Der alte Wert ist 2600. Der Koeffizient von $x_{2}$ in der Zielfunktion ist 6 und der Zugewinn durch $x_{2}$ ist 1800. Nun wird $s_{2}$ durch $x_{2}$ ersetzt.

Update des Tableaus

Der neue Wert von $x_{2}$ wird nun berechnet.

$s_{2}=300-x_{2}\Leftrightarrow x_{2}=300-s_{2}$ . Dieser Wert wird nun eingesetzt.

$z=x_{1}+{\frac {5}{3}}\cdot (300-s_{2})-{\frac {13}{3}}s_{4}+2600=x_{1}-{\frac {5}{3}}s_{2}-{\frac {13}{3}}s_{4}+3100$

$s_{3}=200-x_{1}+{\frac {2}{3}}\cdot (300-s_{2})+{\frac {s_{4}}{3}}=-x_{1}+{\frac {2}{3}}s_{2}+{\frac {s_{4}}{3}}$

$x_{3}=200-{\frac {1}{3}}\cdot (300-s_{2})-{\frac {s_{4}}{3}}=100+{\frac {1}{3}}s_{2}-{\frac {s_{4}}{3}}$

Das neue Tableau sieht nun so aus:

	$x_{1}$	$s_{2}$	$s_{4}$	b
z	1	$-{\frac {5}{3}}$	$-{\frac {13}{3}}$	-3100
$s_{1}$	1	0	0	200
$x_{2}$	0	1	0	300
$s_{3}$	1	$-{\frac {2}{3}}$	$-{\frac {1}{3}}$	0
$x_{3}$	0	$-{\frac {1}{3}}$	${\frac {1}{3}}$	100

Dritte Iteration

$E=\{j|c_{x}x_{j}>0\}=\{1\}~\{x_{1}\}$

$L_{1}=\{i|x_{1}^{i}>0\}=\{1,3\}~\{s_{1},s_{3}\}$

Ersetze einen Basisvektor durch den Nichtbasisvektor, der den größten Zugewinn für die Zielfunktion bringt. Es müssen nur Terme aus z mit positivem Vorzeichen betrachtet werden, d.h. es bleibt nur noch $x_{1}$ übrig.

$x_{1}$

$0\leq s_{1}=200-x_{1}$

$0\leq s_{3}=0-x_{1}$

$x_{1}=min(200,0)\Rightarrow z=3100$

Update des Tableaus

Nun wird $s_{3}$ durch $x_{1}$ ersetzt.

$s_{3}=-x_{1}+{\frac {2}{3}}s_{2}+{\frac {s_{4}}{3}}\Leftrightarrow x_{1}=-s_{3}+{\frac {2}{3}}s_{2}+{\frac {s_{4}}{3}}$ . Dieser Wert wird nun eingesetzt.

$z=-s_{3}+{\frac {2}{3}}s_{2}+{\frac {s_{4}}{3}}-{\frac {5}{3}}s_{2}-{\frac {13}{3}}s_{4}+3100=-s_{3}-s_{2}-4s_{4}+3100$

$s_{1}=200-(-s_{3}-{\frac {2}{3}}s_{2}-{\frac {s_{4}}{3}})=200+s_{3}+{\frac {2}{3}}s_{2}+{\frac {s_{4}}{3}}$

Das neue Tableau sieht nun so aus:

	$s_{3}$	$s_{2}$	$s_{4}$	b
z	-1	-1	-4	-3100
$s_{1}$	-1	${\frac {2}{3}}$	${\frac {1}{3}}$	200
$x_{2}$	0	1	0	300
$x_{1}$	1	$-{\frac {2}{3}}$	${\frac {1}{3}}$	0
$x_{3}$	0	$-{\frac {1}{3}}$	${\frac {1}{3}}$	100

Die Zielfunktion kann nun nicht weiter verbessert werden. Unser x ist nun (0,300,100) und unser z ist 3100.

Analyse

Das Simplex-Verfahren löst ein lineares Programm in endlich vielen Schritten oder stellt seine Unlösbarkeit oder Unbeschränktheit fest. Im Worstcare hat es eine exponentielle Laufzeit, unabhängig von den gewählten Pivotregeln. In der Praxis ist es sehr effizient.

Kurs:Algorithmen und Datenstrukturen/Druckversion

Einleitung

Algorithmen im Alltag

Intuitive Begriffserklärung Algorithmus

Definitionen

Transformationelle Probleme

Literatur

Eigenschaften von Algorithmen

Literatur

Algorithmenentwurf

Vom Algorithmus zur Programmausführung

Vorgehensweise Algorithmus-Entwurf

Literatur

Größter gemeinsamer Teiler

Hintergrundwissen

Problem definieren

Algorithmus entwerfen

Programm erstellen

Algorithmenanalyse

Fazit

Literatur

Berechenbarkeitsbegriff

Church-Turing-These

Beispiele

Literatur

Überblick Theoretische Grundlagen

Literatur

Paradigmenbegriff

Definition

Paradigmen zur Algorithmenkonstruktion

Paradigmen und Programmiersprachen

Literatur

Funktionale Algorithmen

Grundidee

Beispiele für Terme

Definition

Literatur

Funktionsdefinition und Signatur

Funktionsdefinition

Termdefinition

Beispiel Terme natürlicher Zahlen

Beispiel Bool´sche Terme

Beispiel

Signatur einer Funktion

Beispiel einer Funktionsdefinition

Literatur

Auswertung von Funktionen

Beispiel

Literatur

Auswertung von Funktionen

Beispiel

Literatur

Auswertung rekursiver Funktionen

Erweiterung der Funktionsdefinition

Auswertung rekursive Funktionsdefinition

Definiertheit

Literatur

Definiertheit der Fakultätsfunktion

Literatur

Größter gemeinsamer Teiler - funktional

Hintergrundwissen

Auswertung

Abbruchbedingungen und Rekursion

Programm

Literatur

Fibonacci Zahlen - funktional

Hintergrundwissen

Programm

Literatur

Logische Algorithmen

Literatur

Prädikatenlogik und Hornlogik

Grundlagen

Literatur

Prolog

Beispiel 1

Beispiel 2

Anfragen

Beispiel

Logische vs. Funktionale Programmierung

$\Omega$ -Notation

$\Theta$ -Notation