Algorithmische Geometrie - Vorlesungsskript

Algorithmische Geometrie
Oliver Karch
Entwurf vom 4. Februar 2000
Vorlesung im Wintersemester 1998/99
Lehrstuhl für Informatik I

ii
Dies ist das vorläufige Skript zur Vorlesung »Algorithmische
Geometrie« (10703) im Wintersemester
1998/99. Über Kritik, Verbesserungsvorschläge
oder gefundene Tippfehler würde ich
mich sehr freuen!
¡
Oliver Karch
���������������������������������

Inhaltsverzeichnis
1 Einleitung 1
1.1 Was ist »Algorithmische Geometrie«? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Beispiele geometrischer Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Informationsquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 WWW-Seiten zur Vorlesung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Grundbegriffe 5
2.1 Topologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Der Abstandsbegriff und innere Punkte . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Stetigkeit, Wege und Zusammenhang . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Graphentheorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.1 Gerichtete Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.2 Ungerichtete Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.3 Wege und Kreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.4 Geometrische Realisierungen und Planarität . . . . . . . . . . . . . . . . . . . . 14
2.3 Komplexität von Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.1 Größenordnung von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.2 Berechnungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.3 Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.4 Das Entscheidungsbaummodell . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Grundlegende Geometrie in der Ebene 23
3.1 Elementare geometrische Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Elementare Lokationsprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Point-in-half-plane-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.2 Lage eines Punktes bezüglich eines Strahls . . . . . . . . . . . . . . . . . . . . . 25
3.2.3 Schnitt zweier Strecken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.4 Die angulare Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.5 Sektorbestimmung – Single-shot-Anfrage . . . . . . . . . . . . . . . . . . . . . . 30
3.2.6 Sektorbestimmung – Multiple-shot-Anfrage . . . . . . . . . . . . . . . . . . . . 30

iv
4 Polygone 33
4.1 Spezialfall »Konvexe Polygone« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.1.1 Test auf Konvexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.1.2 Point-in-polygon-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2 Spezialfall »Sternförmige Polygone« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.2.1 Point-in-polygon-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2.2 Erzeugen eines (sternförmigen) Polygons mit vorgegebener Eckenmenge . . . 43
4.3 Point-in-polygon-Test bei allgemeinen Polygonen . . . . . . . . . . . . . . . . . . . . . 44
5 Das Plane-sweep-Paradigma 47
5.1 Das Problem des dichtesten Punktepaares . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2 Schnitt konvexer Polygone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.3 Anwendung »Schnitt von Halbebenen« . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.4 Schnitt von Liniensegmenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.4.1 Schnittest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.4.2 Bestimmen aller Schnittpunkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.5 Anwendung »Test auf Einfachheit« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.6 Anwendung »Überlagerung von PSLGs« und »Arrangement-Berechnung« . . . . . . 62
6 Konvexe Hüllen ebener Punktmengen 67
6.1 Eigenschaften und untere Schranke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2 Inkrementelle Konstruktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.3 Jarvis’s march . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.4 Graham’s scan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.5 Konstruktion mittels Divide-and-conquer . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.6 Quickhull . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.7 Dynamische Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
7 Lokationsprobleme in der Ebene 79
7.1 Die Slab-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
7.2 Das Verfahren der verfeinerten Triangulationen . . . . . . . . . . . . . . . . . . . . . . 81
7.2.1 Einschub »Die Eulersche Formel« . . . . . . . . . . . . . . . . . . . . . . . . . . 81
7.2.2 Die Methode von Kirkpatrick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
7.2.3 Subdivision-Hierarchien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
8 Nachbarschaftsprobleme 89
8.1 Definition und Eigenschaften des Voronoi-Diagramms . . . . . . . . . . . . . . . . . . 89
8.2 Der Delaunay-Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8.3 Verallgemeinerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.4 Konstruktion des Voronoi-Diagramms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.4.1 Divide-and-conquer-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.4.2 Sweep-line-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
A Abkürzungen und Symbole 103
Literaturverzeichnis 107

Einleitung
1.1 Was ist »Algorithmische Geometrie«?
Die Algorithmische Geometrie (engl. computational geometry) ist ein Teilgebiet
der theoretischen Informatik, welches sich mit geometrischen Objekten
(wie z. B. Punkten, Linien, Kreisen, Ebenen) beschäftigt.
Die Ziele und Aufgabenstellungen hierbei sind
• der Entwurf von effizienten Algorithmen zur Lösung geometrischer
Probleme, bei denen sehr oft große Mengen geometrischer Objekte
involviert sind,
• die Bestimmung der algorithmischen Komplexität geometrischer
Probleme, d. h. die Beantwortung von Fragen wie z. B. »Was sind
untere Schranken für die Laufzeit und den Speicherbedarf eines
Algorithmus?« oder »Gibt es zur Lösung eines Problems überhaupt
einen praktikablen Algorithmus?«.
Hierdurch grenzt sich die Algorithmische Geometrie von anderen Gebieten
ab, die sich ebenfalls mit geometrischen Objekten beschäftigen
(z. B. die Algebraische Geometrie oder die Differentialgeometrie). Als eigenständiges
Gebiet der Informatik hat sich die Algorithmische Geometrie
Ende der 70er Jahre etabliert und spielt mittlerweile in vielen realen Anwendungen
eine große Rolle:
Computergrafik Möglichst realistische Berechnung von Bildern oder
Filmen geometrisch modellierter Szenen, z. B. mittels Ray Tracingund
Radiosity-Verfahren (Schlagwort Virtual Reality)
1
CAD/CAM (engl. computer aided design/manufacturing) Erzeugung
geometrischer Objekte, beispielsweise mittels Vereinigung und
Durchschnitt von Grundobjekten (z. B. Quader, Kugel usw.) oder
mittels interpolierender Flächen durch vorgegebene Stützpunkte.
Bekanntes Beispiel ist die Dresdner Frauenkirche, die im Zweiten Dresdner Frauenkirche
Weltkrieg fast vollständig zerstört und zunächst am Computer
realitätsgetreu rekonstruiert wurde (siehe z. B. ���������������
�������������������). Weitere Schlagworte: Assemblierpla- WWW☞

2 Einleitung
Map Overlay
Industrieroboter
KUKA KR 125/1
konvexe Hülle
nung und Digital Mock-Up bei der Fertigung von aus mehreren
Teilen bestehenden Gütern (z. B. den Motorraum eines Autos), die
in der richtigen Reihenfolge zusammengesetzt werden müssen
Geographische Informationssysteme (GIS) Ein geographisches Informationssystem
speichert geographische Daten (z. B. Länderkonturen,
Flüsse, Bevölkerungsdichten usw.) und dient dazu, Anfragen
zu beantworten, bei denen geometrische Eigenschaften miteinander
kombiniert werden müssen. Beispielsweise könnte man
einen Platz für ein neues Naherholungsgebiet suchen: ein günstiges
Stück Land (Quadratmeterpreis ≤ x DM) einer gewissen Mindestfläche
≥ y km 2 , das außerdem von den zu versorgenden Städten
gut zu erreichen ist (Entfernung ≤ z km). Dies würde drei
Anfragen an verschiedene geographische Datenbanken nach sich
ziehen; die resultierenden Gebiete, welche die Kriterien erfüllen,
müssen dann noch überlagert werden; ihre Schnittmenge (Stichwort
Map Overlay) beantwortet dann die ursprüngliche Anfrage.
Robotik (engl. robotics) Roboter sind meist Fahrzeuge (Fahrerlose
Transportsysteme, FTS) oder mit Manipulatoren ausgestattete
Industrieroboter. Typische Problemstellungen für solche Roboter
sind
• die Bewegungs- bzw. Bahnplanung, d. h. das Finden einer Bewegung
von einer Anfangskonfiguration in eine Endkonfiguration,
die zum einen Kollisionen mit der Umgebung vermeidet
und zum anderen möglichst effizient ist,
• die Lokalisation, d. h. die Bestimmung der eigenen Position anhand
von Sensoren und Karten,
• die Exploration einer unbekannten Umgebung, um z. B. eine
Karte zu generieren.
1.2 Beispiele geometrischer Fragestellungen
Die folgenden realen Probleme lassen sich jeweils als geometrische Fragestellung
modellieren und motivieren eine theoretische Untersuchung
des jeweiligen Gebietes:
Einzäunen von Apfelbäumen Auf einem Feld stehen einige Apfelbäume,
die eingezäunt werden sollen.
Frage: Wieviel Meter Zaun braucht man mindestens, um alle Bäume
einzuzäunen? Wie muß der Zaun verlaufen?
Geometrische Formulierung: Modelliere die Bäume als Punkte in
der Ebene und bestimme die konvexe Hülle (siehe Kapitel 6) dieser
Punktmenge.
Christos Reichstag Gegeben die Pläne des Berliner Reichstages.

1.3 Literatur 3
Frage: Wieviel Stoff wird mindestens benötigt, um den Reichstag
zu verhüllen? Wie muß der Stoff zugeschnitten werden?
Geometrische Formulierung: Bestimme die dreidimensionale konvexe
Hülle des Reichstages.
Nähestes Telefon Sie sind auf dem Unicampus und wollen telefonieren.
Frage: Welches Telefon ist das näheste?
Geometrische Formulierung: Modelliere die Telefone wieder als
Punkte in der Ebene und bestimme eine Einteilung in Regionen
mit gleichem nähesten Telefon. Diese Karte nennt man das Voronoi-Diagramm
(siehe Kapitel 8). Voronoi-Diagramm
Versorgung Mit einem Sender möglichst geringer Leistung wollen Sie
eine Menge von Haushalten erreichen.
Frage: Wo soll der Sender plaziert werden? Welche Leistung muß
der Sender besitzen?
Geometrische Formulierung: Suche die kleinste Kreisscheibe
(engl. smallest enclosing circle), die alle Häuser überdeckt. smallest enclosing circle
1.3 Literatur
Lehrbücher zum Thema sind
Buch Preis
[5] M. de Berg, M. v. Kreveld, M. Overmars,
O. Schwarzkopf. Computational Geometry: Algorithms
and Applications.
[8] H. Edelsbrunner. Algorithms in Combinatorial
Geometry.
54,– DM
102,– DM
[14] R. Klein. Algorithmische Geometrie. 58,– DM
[19] J. O’Rourke. Computational Geometry in C. ca. 50,– DM
[22] F. P. Preparata, M. I. Shamos. Computational Geometry:
An Introduction.
102,– DM
Das Buch von Preparata und Shamos [22] zählt hierbei sicherlich zu
den „Klassikern“ der Algorithmischen Geometrie und gibt einen guten
Überblick über das Stoffgebiet. Es ist allerdings schon etwas in die Jahre
gekommen; randomisierte Algorithmen werden dort beispielsweise
überhaupt nicht behandelt.
Einen aktuelleren Querschnitt erhält man in den Büchern von de Berg
et al. [5] (jeweils anhand motivierender Beispiele und Anwendungen)
und Klein [14], die beide sehr empfehlenswert sind. Das Buch von

4 Einleitung
☞ WWW
☞ WWW
☞ WWW
☞ WWW
Edelsbrunner [8] ist ebenfalls ein „Klassiker“, behandelt aber mehr kombinatorische
Aspekte der Algorithmischen Geometrie.
Im Buch von O’Rourke [19], dessen überarbeitete zweite Auflage gerade
erschienen ist, wird besonders auf die Implementierung geometrischer
Algorithmen in C (und auch in Java) eingegangen.
1.4 Informationsquellen
Nützliche Informationen (z. B. zu Tagungen, Literaturdatenbanken,
Mailinglisten usw.) finden sich auf der Homepage der GI-
Fachgruppe 0. 1. 2 unter
�������������������������������������������������
Darüberhinaus sind die WWW-Seiten von Jeff Erickson (»Computational
Geometry Pages«) unter
�������������������������������������������
und von David Eppstein (»Geometry in Action«) unter
������������������������������������������
sehr empfehlenswert.
1.5 WWW-Seiten zur Vorlesung
Die WWW-Seiten zur Vorlesung sind zu erreichen unter
���������������������������������������������
��������������������������������������

2.1 Topologie
Referenzwerke: [9, 11, 23]
Grundbegriffe
In vielen Bereichen der Algorithmischen Geometrie spielen Abstände
geometrischer Objekte eine Rolle, deshalb soll dieser Begriff zunächst
formal dargestellt werden, um danach Begriffe wie »Stetigkeit«, »Weg«
usw. ableiten zu können.
2.1.1 Der Abstandsbegriff und innere Punkte
Definition 2.1 (Metrik) Sei X eine Menge und d: X × X → R≥0 eine
Abbildung, die je zwei Elementen x und y aus X einen Abstand d(x, y)
zuordnet.
Die Abbildung d ist eine Metrik, falls für alle x, y, z aus X folgendes gilt: Metrik
d(x, y) = 0 ⇐⇒ x = y
d(x, y) = d(y, x) (Symmetrie)
d(x, z) ≤ d(x, y) + d(y, z) (Dreiecksungleichung)
Das Paar (X, d) heißt dann metrischer Raum. metrischer Raum
Befinden wir uns im d-dimensionalen reellen Raum R d , dann ist für zwei
Punkte x = (x1, . . . , xd) und y = (y1, . . . , yd) die euklidische Metrik euklidische Metrik
�
�
�
|x y| := � d �
(xi − yi) 2 (2.1)
i=1
definiert. Der Einfachheit halber bezeichnet man den R d zusammen
mit der euklidischen Metrik auch als den d-dimensionalen euklidischen
Raum, oder kurz E d . Im Rahmen dieser Vorlesung wird für uns fast ausschließlich
der E 2 oder der E 3 eine Rolle spielen. Hier beschreibt die euklidische
Metrik den gewohnten (euklidischen) Abstand zweier Punkte
in der Ebene bzw. im Raum.
2

6 Grundbegriffe
Skalarprodukt
Minkowski-Metriken
x
ε
U ε(x)
ε-Umgebung
innerer Punkt
Berührpunkt
Randpunkt
Bemerkung 2.2 Eine andere Möglichkeit die euklidische Metrik zu definieren,
ist mittels des kanonischen Skalarprodukts des R d ,
〈x, y〉 :=
d�
i=1
xiyi .
Bekanntlich ist das Skalarprodukt 〈x, y〉 = |x| |y| cos α, wobei |x| die euklidische
Länge des Vektors x bezeichnet und α der Winkel zwischen den
beiden Vektoren x und y ist.
Somit gilt dann für die euklidische Distanz |x y| = |x − y| =
� 〈x − y, x − y〉. ⊳
Die euklidische Metrik ist nur ein spezielles Mitglied aus der Familie der
Minkowski-Metriken Lp(x, y), die folgendermaßen definiert sind:
Lp(x, y) :=
und
� d�
i=1
|xi − yi| p
L∞(x, y) := d
max
i=1 |xi − yi|
�1/p
für 1 ≤ p < ∞
(2.2)
Für p = 2 erhält man also die euklidische Metrik, für p = 1 die sog.
Manhattan-Metrik und für p = ∞ die sog. Maximum-Metrik.
Mittels des Metrikbegriffes können nun auch die üblichen topologischen
Begriffe definiert werden.
Definition 2.3 Sei x ∈ X ein Punkt und A ⊆ X eine Teilmenge eines
metrischen Raumes (X, d).
• Für eine reelle Zahl ε > 0 heißt die Menge
die ε-Umgebung von x.
U ε(x) := { y ∈ X � � d(x, y) < ε } (2.3)
• Ein Punkt x ∈ X heißt innerer Punkt von A, wenn es eine
ε-Umgebung Uε(x) von x gibt, die ganz in A enthalten ist. Die
Menge aller inneren Punkte von A heißt das Innere oder der offene
Kern von A und wird mit A ◦ bezeichnet.
• Ein Punkt x ∈ X heißt Berührpunkt von A, wenn in jeder
ε-Umgebung Uε(x) von x ein Punkt aus A liegt. Die Menge aller
Berührpunkte von A heißt die abgeschlossene Hülle von A und
wird mit A bezeichnet.
• Ein Punkt x ∈ X heißt Randpunkt von A, wenn in jeder
ε-Umgebung Uε(x) von x sowohl ein Punkt aus A als auch ein
Punkt aus dem Komplement A c := X \ A liegt, d. h. wenn x Berührpunkt
von A und von A c ist. Die Menge aller Randpunkte
von A heißt der Rand von A und wird mit ∂A bezeichnet.

2.1 Topologie 7
• Die Menge A heißt offen (in X), falls jeder ihrer Punkte ein innerer offen und abgeschlossen
Punkt ist. Sie heißt abgeschlossen (in X), falls ihr Komplement A c
offen ist. Die Familie aller offenen Teilmengen eines metrischen
Raumes (X, d) bezeichnet man auch als eine Topologie von X.
Für eine Menge A ⊆ X erhalten wir hieraus einige einfache Folgerungen:
• Die Menge A ist genau dann abgeschlossen, wenn sie alle ihre Berührpunkte
enthält. Denn es gilt
A ist abgeschlossen ⇐⇒ A c = X \ A ist offen
⇐⇒ ∀ x∈X\A ∃ε>0 U ε(x) ⊆ X \ A
⇐⇒ ∀ x∈X\A ∃ε>0 U ε(x) ∩ A = ∅
⇐⇒ ∀ x∈X\A x ist kein Berührpunkt von A
⇐⇒ (X \ A) ∩ A = ∅
⇐⇒ A ⊆ A .
• Es gilt immer die Inklusion A ◦ ⊆ A ⊆ A, denn jede
ε-Umgebung U ε(x) für einen Punkt x enthält diesen selbst.
Daraus folgt
A ist offen ⇐⇒ A = A ◦ ∧ A ist abgeschlossen
⇐⇒ A = A .
• Es gelten die beiden Dualitätsbeziehungen
(A ◦ ) c = X \ A ◦ = X \ A = A c , und
(A) c = X \ A = (X \ A) ◦ = (A c ) ◦ , wegen
x ∈ X \ A ◦ ⇐⇒ ∄ε>0 U ε(x) ⊆ A
⇐⇒ ∀ε>0 U ε(x) � A
⇐⇒ ∀ε>0 U ε(x) ∩ X \ A �= ∅
⇐⇒ x ∈ X \ A , und
x ∈ X \ A ⇐⇒ x /∈ A
⇐⇒ ¬∀ε>0 U ε(x) ∩ A �= ∅
⇐⇒ ¬∀ε>0 U ε(x) � X \ A
⇐⇒ ∃ε>0 U ε(x) ⊆ X \ A
⇐⇒ x ∈ (X \ A) ◦ .
Damit erhält man dann für den Rand ∂A einer Menge A
∂A = A ∩ A c = A ∩ (A ◦ ) c = A \ A ◦ .

8 Grundbegriffe
E 2
1
U ε
−1 S 1 E
−1
Relativtopologie
stetig
Weg
einfacher Weg
Beispiel 2.4 Die Strecke S = [−1, 1] ist in E abgeschlossen, ihr Rand ist
die Menge R = {−1, 1} und ihr Inneres die Menge I = (−1, 1). Die punktierte
Strecke S ′ = S \ {0} ist weder abgeschlossen noch offen und ihr
Rand ist die Menge R ′ = {−1, 0, 1}.
Faßt man E als Teilmenge des E 2 auf (in der Form E × {0} ⊆ E 2 ), dann
ist S (genauer, die Menge S × {0}) immer noch abgeschlossen. Im E 2
besitzt S aber keine inneren Punkte mehr, denn eine ε-Umgebung im E 2
ist eine (offene) Kreisfläche, die in S keinen Platz findet. ⊳
Oft möchte man über das Innere einer Menge reden können, auch wenn
diese wie im letzten Beispiel in einen höherdimensionalen Raum eingebettet
ist.
Definition 2.5 (Relativtopologie) Sei R ⊆ X eine Teilmenge eines metrischen
Raumes (X, d), dann ist für einen Punkt x ∈ R dessen ε-Umgebung
in R definiert durch
U R ε (x) := { y ∈ R � � d(x, y) < ε } = U ε(x) ∩ R . (2.4)
Die hierdurch auf R entstehende Topologie heißt die von X induzierte
Topologie oder Relativtopologie.
Die übrigen Definitionen übertragen sich, indem man jeweils U ε(x)
durch U R ε (x) und X durch R ersetzt. Im obigen Beispiel verwenden
wir R = E × {0} und erhalten dann – wie erwartet – für das relative Innere
von S × {0} die Menge (−1, 1) × {0} in Analogie zu Beispiel 2.4.
2.1.2 Stetigkeit, Wege und Zusammenhang
Mit Hilfe des durch die Metrik festgelegten Abstandsmaßes können wir
nun definieren, wann eine Abbildung von einem metrischen Raum in
einen anderen stetig ist und darauf aufbauend den Begriff des Weges
einführen.
Definition 2.6 (Stetigkeit) Seien (X, d) und (Y, e) metrische Räume
und f: X → Y eine Abbildung. f ist genau dann im Punkt ˜x ∈ X stetig,
wenn zu jedem ε > 0 ein δ > 0 existiert, so daß
e(f(x), f(˜x)) < ε für alle x ∈ X mit d(x, ˜x) < δ .
Definition 2.7 (Wege und Zusammenhang)
Unter einem Weg w von a ∈ X nach b ∈ X verstehen wir das Bild einer
stetigen Abbildung
�w: [0, 1] → X mit �w(0) = a und �w(1) = b
und nennen �w eine Parametrisierung des Weges w.
• Der Weg w heißt geschlossen, wenn �w(0) = �w(1) gilt.
• Der Weg w heißt einfach oder doppelpunktfrei, wenn �w auf [0, 1)
injektiv ist.

2.1 Topologie 9
• Eine Menge A ⊆ X heißt wegzusammenhängend, wenn je zwei wegzusammenhängend
Punkte von A durch einen Weg verbunden werden können, der
ganz in A verläuft.
»Wegzusammenhang« ist eine Äquivalenzrelation und induziert
eine Zerlegung von A in disjunkte Zusammenhangskomponenten.
Abbildung 2.1 zeigt einige Beispiele für Wege in der Ebene: Alle vier
Wege mit Ausnahme von w1 sind geschlossen; nur die Wege w1 und w4
sind doppelpunktfrei.
Bemerkung 2.8 Zu jedem Weg w (außer zum trivialen Weg �w([0, 1]) ≡
a) gibt es unendlich viele Parametrisierungen. Wir können uns eine Parametrisierung
vorstellen als die Art und Weise, wie der Weg abgelaufen
wird. Die Ableitung �w ′ entspräche dann der „Geschwindigkeit“ beim
Ablaufen des Weges. ⊳
Zusammenhangskomponenten
Für einen einfachen geschlossenen Weg w im E 2 (wie z. B. der Weg w4
in Abbildung 2.1) besagt der Jordansche Kurvensatz, daß R 2 \ w aus ge- Jordanscher Kurvensatz
nau zwei Gebieten (offene und wegzusammenhängende Mengen) besteht,
deren Rand w ist: einem von w umschlossenen inneren und einem
unbeschränkten äußeren Gebiet. Der Beweis dieser alles andere als
trivialen Aussage findet sich für Interessierte z. B. in [17].
Definition 2.9 (Einfacher Wegzusammenhang) Eine wegzusammenhängende
Menge A ⊆ E2 heißt einfach-wegzusammenhängend, wenn
für jeden in A verlaufenden einfachen geschlossenen Weg sein inneres
Gebiet ebenfalls in A enthalten ist.
Anschaulich bedeutet der einfache Wegzusammenhang einer Menge,
daß sie keine „Löcher“ besitzt. Siehe hierzu das Beispiel in Abbildung
2.2 auf der folgenden Seite.
Beim Umgang mit den oben definierten Wegen interessiert natürlich
auch deren Länge. Diese kann man durch Approximation mit Streckenzügen
definieren: Man wählt n Stützstellen 0 = t1 < . . . < tn = 1
und bildet die Summe �i=n−1 i=1 d( �w(ti), �w(ti+1) über alle Abstände. Der
Limes für n → ∞ des Supremums dieser Summe für alle möglichen
Wahlen von n aufeinanderfolgenden Stützstellen im Intervall [0, 1] bezeichnet
man als die Länge des Weges w. Wenn dieser Wert endlich ist,
nennt man w rektifizierbar.
Für einen Weg w im E 2 , der durch �w(t) = (x(t), y(t)) parametrisiert ist,
kann man die Integralformel für die Weglänge
a
w1
b
a = b
w2
a = b
w3
a = b
w4
einfachwegzusammenhängend
a
Weglänge mittels
Approximation durch
Streckenzüge
Integralformel für die
Weglänge
b
Abbildung 2.1
Die Wege w1 und w4 sind
einfach, w2, w3, w4 sind
geschlossen

10 Grundbegriffe
Abbildung 2.2
Menge A ist einfach
wegzusammenhängend,
Menge B nicht
gerichteter Graph
Schlinge
A
w
Länge(w) =
� 1
0
B
�
x ′ (t) 2 + y ′ (t) 2 dt (2.5)
benutzen, sofern die Koordinatenfunktionen stetig differenzierbar sind.
2.2 Graphentheorie
Referenzwerke: [12, 15, 18]
Für viele Aufgabenstellungen in der Algorithmischen Geometrie ist eine
Modellierung mittels eines Graphen hilfreich oder die auftretenden Objekte
selbst sind Graphen bzw. durch solche beschreibbar (siehe z. B. das
Voronoi-Diagramm und der dazu duale Delaunay-Graph in Kapitel 8).
2.2.1 Gerichtete Graphen
Definition 2.10 (Gerichteter Graph) Ein Quadrupel G = (V, R, α, ω) ist
ein gerichteter Graph (oder kurz Graph), wenn folgendes gilt:
1. Die Eckenmenge V �= ∅ und die Pfeilmenge R des Graphen sind
disjunkt, V ∩ R = ∅.
2. Die Abbildungen α: R → V und ω: R → V weisen jedem Pfeil r ∈
R eine Anfangsecke α(r) und eine Endecke ω(r) zu.
Der Graph G heißt endlich, wenn |V ∪ R| < ∞ gilt.
Definition 2.11 Sei G = (V, R, α, ω) ein Graph. Ein Pfeil r ∈ R heißt
Schlinge, wenn α(r) = ω(r). Der Graph G heißt schlingenfrei, wenn er
keine Schlingen enthält.
Zwei Pfeile r �= r ′ heißen parallel, wenn α(r) = α(r ′ ) und ω(r) = ω(r ′ ).
Die Pfeile r �= r ′ heißen invers, wenn α(r) = ω(r ′ ) und ω(r) = α(r ′ ).
w

2.2 Graphentheorie 11
α ω
r1 v1 v2
r2 v1 v2
r3 v2 v3
r4 v3 v3
r5 v4 v3
r6 v3 v4 v1 v5
r1
r2
Der Graph G heißt einfach oder schlicht, wenn er schlingenfrei ist und einfach
keine Parallelen enthält. In diesem Fall ist jeder Pfeil r eindeutig durch
das Paar (α(r), ω(r)) charakterisiert. Man kann dann auch einfach G =
(V, R) schreiben, mit R ⊆ V × V.
Beispiel 2.12 Der in Abbildung 2.3 dargestellte Graph besitzt eine
Schlinge (r4), zwei parallele Pfeile (r1 und r2), sowie zwei inverse Pfeile
(r5 und r6). Aufgrund der Schlinge und der beiden Parallelen ist er also
nicht einfach. ⊳
v2
r3
r5
v3
v4
r4
r6
Abbildung 2.3
Ein Graph und seine
geometrische Realisierung
im E 2
Definition 2.13 Sei G = (V, R, α, ω) ein Graph. Zwei Ecken u und v
heißen adjazent oder benachbart, wenn es einen Pfeil r ∈ R gibt mit adjazente Ecken
α(r) = u ∧ ω(r) = v oder α(r) = v ∧ ω(r) = u.
Eine Ecke u und ein Pfeil r heißen inzident, wenn u ∈ {α(r), ω(r)}. Zwei inzident
Pfeile r und r ′ heißen inzident, wenn es eine Ecke v gibt, die mit r und
mit r ′ inzidiert.
Für eine Ecke v ∈ V heißt
B + (v) := { r ∈ R � � α(r) = v }
das von v ausgehende Pfeilbüschel,
B − (v) := { r ∈ R � � ω(r) = v }
das in v mündende Pfeilbüschel,
N(v) := { u ∈ V � � ∃r∈R α(r) = v ∧ ω(r) = u }
die Nachfolgermenge von v,
V(v) := { u ∈ V � � ∃r∈R α(r) = u ∧ ω(r) = v }
die Vorgängermenge von v,
g + (v) := |B + (v)| der Außengrad von v,
g − (v) := |B − (v)| der Innengrad von v,
g(v) := g + (v) + g − (v) der Grad von v.
Beispiel 2.14 Im Graph von Abbildung 2.3 münden in die Ecke v2 zwei
Pfeile (r1 und r2) und ihr Innengrad ist somit gleich 2. Ihre Vorgängermenge
enthält dagegen nur die eine Ecke v1.
Für die isolierte Ecke v5 gilt: B + (v5) = B − (v5) = N(v5) = V(v5) = ∅
und g + (v5) = g − (v5) = g(v5) = 0. ⊳

12 Grundbegriffe
Teilgraph
Obergraph
Partialgraph
Subgraph
ungerichteter Graph
Bemerkung 2.15 Für Graphen mit endlicher Pfeilmenge, d. h. |R| < ∞,
gilt
1. �
v∈V g+ (v) = �
v∈V g− (v) = |R| und
2. �
v∈V g(v) = 2 |R|. ⊳
Definition 2.16 (Teilgraph und Obergraph)
Ein Graph G ′ = (V ′ , R ′ , α ′ , ω ′ ) heißt Teilgraph eines Graphen G =
(V, R, α, ω) (i. Z. G ′ ⊑ G), wenn gilt
1. V ′ ⊆ V und R ′ ⊆ R sowie
2. α|R ′ = α ′ und ω|R ′ = ω ′ .
In diesem Fall heißt G dann Obergraph von G ′ (i. Z. G ⊒ G ′ ).
Bemerkung 2.17 Die Relation „⊑“ ist (ebenso wie „⊒“)
1. reflexiv (G ⊑ G),
2. antisymmetrisch (G ⊑ G ′ ∧ G ′ ⊑ G =⇒ G = G ′ ) und
3. transitiv (G ⊑ G ′ ∧ G ′ ⊑ G ′′ =⇒ G ⊑ G ′′ ). ⊳
Definition 2.18 (Partialgraph und Subgraph)
Sei G = (V, R, α, ω) ein Graph und R ′ ⊆ R eine Kantenteilmenge.
Der durch R ′ induzierte Partialgraph GR ′ ist definiert durch GR ′
(V, R
:=
′ , α|R ′, ωR ′).
Für eine Eckenteilmenge V ′ ⊆ V ist der durch V ′ induzierte Subgraph
definiert durch G[V ′ ] := (V ′ , RV ′, α|R V ′ , ωR V ′ ) mit RV ′ := { r ∈ R � �
α(r) ∈ V ′ ∧ ω(r) ∈ V ′ }.
Ein Graph H heißt Partialgraph (bzw. Subgraph) von G, wenn es eine
Kantenteilmenge R ′ ⊆ R (bzw. Eckenteilmenge V ′ ⊆ V) gibt, so daß
H = GR ′ (bzw. H = G[V ′ ]) gilt.
2.2.2 Ungerichtete Graphen
Definition 2.19 (Ungerichteter Graph) Ein Tripel G = (V, E, γ) ist ein
ungerichteter Graph, wenn folgendes gilt:
1. Die Eckenmenge V �= ∅ und die Kantenmenge E des Graphen
sind disjunkt, V ∩ E = ∅.
2. Die Abbildung γ: E → { X � � X ⊆ V ∧ 1 ≤ |X| ≤ 2 } weist jeder
Kante zwei Endpunkte zu (bzw. einen Endpunkt im Fall einer
Schlinge).
Der Graph G heißt endlich, wenn |V ∪ R| < ∞ gilt.

2.2 Graphentheorie 13
Begriffe wie parallel, einfach, Adjazenz, Inzidenz usw. sind analog zu den
Begriffen in gerichteten Graphen definiert.
Im Falle eines einfachen Graphen G = (V, E, γ), der also weder Schlingen
noch Parallelen enthält, ist jede Kante e ∈ E eindeutig durch die zweielementige
Menge γ(e) = {u, v} ihrer Endpunkte charakterisiert. Man
kann dann auch G = (V, E) für den ungerichteten Graphen schreiben.
Bemerkung 2.20 Oft werden wir unter leichtem Mißbrauch der Notation
auch (u, v) anstelle von {u, v} für eine ungerichtete Kante schreiben.
⊳
2.2.3 Wege und Kreise
Definition 2.21 (Weg und Kreis) Ein Weg w in einem Graphen G = Weg
(V, R, α, ω) ist eine endliche Folge w = (r1, . . . , rn), n ≥ 1, von Pfeilen
ri ∈ R (für i = 1, . . . , n), für die gilt
ω(ri) = α(ri+1) für i = 1, . . . , n − 1.
Die Startecke des Weges ist α(w) := α(r1) und die Endecke ist ω(w) :=
ω(rn). Die Länge |w| des Weges w ist die Anzahl n der durchlaufenen
Pfeile.
Ein Weg w mit α(w) = ω(w) heißt Kreis. Kreis
Die Eckenmenge s(w) := {α(r1), . . . , α(rn), ω(rn)} bezeichnen wir als
die Spur des Weges w. Eine Ecke v wird von w berührt, wenn v ∈ s(w)
gilt.
Ein Weg w heißt einfach, wenn ri �= rj für i �= j, d. h. wenn er keinen
Pfeil mehr als einmal durchläuft.
Ein Weg w heißt elementar, wenn α(ri) �= α(rj) und ω(ri) �= ω(rj)
für i �= j, d. h. wenn er keine Ecke mehr als einmal durchläuft – mit
Ausnahme des Falles, daß Anfangs- und Endecke übereinstimmen.
Beispiel 2.22 In Abbildung 2.3 auf Seite 11 ist der Weg w =
(r1, r3, r6, r5) zwar einfach, aber nicht elementar, da die Ecke v3 zweimal
besucht wird.
Der Weg w = (r5, r6) ist ein elementarer (und damit auch einfacher)
Kreis. ⊳
Definition 2.23 (Weg und Kreis im ungerichteten Graphen)
Ein Weg w in einem ungerichteten Graphen G = (V, E, γ) ist eine endli- Weg
che Folge w = (e1, . . . , en), n ≥ 1, von Kanten ei ∈ E (für i = 1, . . . , n),
für die es Ecken v0, . . . , vn ∈ V gibt, so daß gilt
γ(ei) = {vi−1, vi} für i = 1, . . . , n.
Die Startecke des Weges ist α(w) := v0 und die Endecke ist ω(w) := vn.

14 Grundbegriffe
erreichbar
Zusammenhang
geometrische Realisierung
geometrischer Graph
Die Begriffe Länge, Spur, einfach und elementar sind analog zum gerichteten
Fall definiert.
Definition 2.24 (Erreichbarkeit) Eine Ecke v ′ in einem (gerichteten oder
ungerichteten) Graphen G heißt von einer Ecke v aus erreichbar, wenn
entweder v = v ′ gilt oder es einen Weg w gibt mit α(w) = v und ω(w) =
v ′ . Die (in G) von v aus erreichbaren Ecken werden mit EG(v) bezeichnet,
oder kurz E(v), wenn klar ist, um welchen Graphen es sich handelt.
Beispiel 2.25 In Abbildung 2.3 auf Seite 11 ist die Menge der von v2 erreichbaren
Ecken E(v2) = {v2, v3, v4} und die Menge der von v5 erreichbaren
Ecken E(v5) = {v5}. ⊳
Definition 2.26 (Zusammenhang)
Ein gerichteter Graph G = (V, R, α, ω) heißt (stark) zusammenhängend,
wenn für jede Ecke v ∈ V gilt EG(v) = V.
Ein ungerichteter Graph G = (V, E, γ) heißt zusammenhängend, wenn
für jede Ecke v ∈ V gilt EG(v) = V.
Anschaulich bedeutet also der (starke) Zusammenhang eines Graphen,
daß jede Ecke eines Graphens jede andere Ecke über einen Weg erreichen
kann.
2.2.4 Geometrische Realisierungen und Planarität
Einen Graphen durch Angabe seiner Ecken- und Pfeilmenge sowie der
Abbildungen α und ω zu beschreiben ist meist mühsam, wie Abbildung
2.3 auf Seite 11 (links) zeigt. Intuitiver ist eine geometrische Realisierung
des Graphen, z. B. in der Ebene (rechte Seite der Abbildung).
Definition 2.27 (Geometrischer Graph) Sei G = (V, R, α, ω) ein Graph
und (X, d) ein metrischer Raum. Eine geometrische Realisierung des
Graphen G bildet die Ecken auf paarweise verschiedene Punkte in X ab.
Die Pfeile werden auf einfache Wege abgebildet, welche die Bildpunkte
der entsprechenden Ecken verbinden und sonst keine Bildpunkte anderer
Ecken berühren. Das Ergebnis nennt man einen zu G gehörenden
geometrischen Graphen.
Bemerkung 2.28 Oftmals werden wir unter leichtem Mißbrauch der
Notation die beiden Begriff »(abstrakter) Graph« und »geometrischer
Graph« gleichsetzen und schlicht von einem Graphen sprechen. ⊳
Für uns spielen fast ausschließlich geometrische Realisierungen in der
Ebene E 2 (oder in anderen „flächigen“ Räumen, z. B. auf der Oberfläche
einer Kugel) eine Rolle. Besonders interessant sind hierbei solche
Realisierungen, bei denen sich keine Pfeile kreuzen.

2.3 Komplexität von Algorithmen 15
Definition 2.29 (Planarer Graph) Ein geometrischer Graph, dessen
Pfeile sich ausschließlich in den Endpunkten berühren, heißt
kreuzungsfrei. kreuzungsfrei
Ein Graph, der sich in der Ebene E 2 kreuzungsfrei realisieren läßt, heißt
planar. planar
Beispiel 2.30 In Abbildung 2.4 sehen wir links zwei verschiedende geometrische
Realisierungen desselben planaren Graphen: eine kreuzungsfreie
und eine, bei der der Pfeil r6 den Pfeil r5 schneidet. (Genauer: Das
Bild des Pfeiles r6 schneidet das Bild des Pfeiles r5.)
Der in der Abbildung rechts dargestellte Graph besitzt dagegen keine
geometrische Realisierung in der Ebene (wohl aber auf der Oberfläche
eines Torus) und ist somit nicht planar. ⊳
r1
v2
v1
r6
r5
r2
r4
r3
v3
v4
r1
v2
v1
2.3 Komplexität von Algorithmen
Referenzwerke: [21, 10, 4]
r5
r2
r4
Die Effizienz eines Algorithmus ermittelt man üblicherweise anhand
seines Verbrauchs an Rechenzeit und Speicherplatz. Außer bei ganz einfachen
Problemen hängt dieser Bedarf in irgendeiner Weise von der Problemgröße
ab, z. B. von der Anzahl n der einzuzäunenden Apfelbäume
in unserem Einführungsbeispiel in Abschnitt 1.2 auf Seite 2).
Beim Vergleich zweier Algorithmen interessiert uns hierbei nicht der
exakte Zeit- und Platzbedarf einer Implementation für eine konkrete
Eingabe. Stattdessen wollen wir für einen Algorithmus seine Laufzeit
und seinen Speicherplatzbedarf als Funktion der Eingabegröße darstellen
und diese – größenordnungsmäßig – mit den Zeit- und Speicheranforderungen
anderer Algorithmen vergleichen.
2.3.1 Größenordnung von Funktionen
Sei M die Menge aller reellwertigen Funktionen f: N → R auf den natürlichen
Zahlen.
r3
v3
v4
r6
Abbildung 2.4
Zwei geometrische
Realisierungen eines
planaren Graphen sowie
ein nicht-planarer Graph
Rechenzeit und
Speicherplatz

16 Grundbegriffe
O-Notation
Ω-Notation
Θ-Notation
o-Notation
anonyme Funktion
insertion sort
Definition 2.31 Für eine Funktion g ∈ M definieren wir die folgenden
Klassen von Funktionen:
• O(g) := { f ∈ M � � ∃c∈R≥0 ∃n0∈N ∀n≥n0 |f(n)| ≤ c · |g(n)| },
alle Funktionen höchstens von der Größenordnung von g
• Ω(g) := { f ∈ M � � ∃c∈R≥0 ∃n0∈N ∀n≥n0 |f(n)| ≥ c · |g(n)| },
alle Funktionen mindestens von der Größenordnung von g
• Θ(g) := O(g) ∩ Ω(g),
alle Funktionen genau von der Größenordnung von g
• o(g) := { f ∈ M � � ∀c∈R>0 ∃n0∈N ∀n≥n0 |f(n)| < c · |g(n)| },
alle Funktionen von geringerer Größenordnung als g
Am häufigsten wird uns die O-Notation zur Angabe von oberen Schranken
und die Ω-Notation zur Angabe von unteren Schranken (z. B. für die
Laufzeit eines Algorithmus) begegnen.
Bemerkung 2.32 Die oben definierten Klassen sind Mengen von Funktionen.
Deshalb sollte man korrekterweise für eine Funktion f(n) von
genau quadratischer Größenordnung auch schreiben f(n) ∈ Θ(n 2 ) und
nicht f(n) = Θ(n 2 ).
Manchmal möchte man aber auch mit dem Klassensymbol rechnen können,
z. B. um eine untere Schranke für die Funktion h(n) zu definieren:
h(n) = g(n) + Ω(f(n)). Das Symbol Ω(f(n)) spielt dann die Rolle ei-
ner anonymen Funktion mindestens von der Größenordnung von f(n),
die wir aber nicht genau spezifieren wollen (oder können). Beim Rechnen
mit solchen anonymen Funktionen, sollte man sich immer an die
zugrundeliegende Definition erinnern! ⊳
Beispiel 2.33 Der Ausdruck �n i=1 O(i) beschreibt eine obere Laufzeitschranke
für das naive Sortieren von n Zahlen durch Einfügen (engl. insertion
sort). Hier ist es nicht zulässig, die anonyme Funktion O(i) in der
Summe in n verschiedene anonyme Funktionen aufzuteilen. Dies würde
zum falschen Ergebnis �n i=1 O(i) = O(1) + O(2) + · · · + O(n) = O(n)
führen.
Denn in �n i=1 O(i) gibt es nur eine einzige anonyme Funktion, die von i
(und nicht von n) abhängt, nämlich i ↦→ i. Richtig ist deshalb
n�
n�
O(i) = { f ∈ M � � ∃c∈R≥0 ∃i0∈N ∀i≥i0 |f(i)| ≤ c · |i| }
i=1
i=1
= { f ∈ M � � ∃c∈R≥0 ∃n0∈N
n�
∀n≥n0 |f(n)| ≤ c · |i| }
i=1
= { f ∈ M � � ∃c∈R≥0 ∃n0∈N
� �
�
∀n≥n0 |f(n)| ≤ c · �
n(n + 1) �
�
� 2 � }
= O(n 2 ) .
Die Summation muß also in den O-Ausdruck „hineingezogen“ werden!
⊳

2.3 Komplexität von Algorithmen 17
2.3.2 Berechnungsmodell
Bei Laufzeitanalysen verwenden wir das Maschinenmodell der Unit-
Cost Real RAM (Random Access Machine), siehe [22,21]. Diese Maschine Unit-Cost Real RAM
verfügt über abzählbar unendlich viele Speicherzellen, die jeweils eine
beliebige reelle Zahl aufnehmen können. Folgende Operationen können
jeweils in einem Maschinentakt ausgeführt werden:
Ein- oder Ausgabe eines Registers, Vergleich zweier Register E/A, �, (+, −, ·, /),
und bedingte Verzweigung sowie die arithmetischen Operationen
Addition, Subtraktion, Multiplikation und Division.
if . . . then . . .
Die Speicherzellen können dabei jeweils direkt oder indirekt adressiert
werden.
Für bestimmte Fälle wird manchmal die Menge der erlaubten arithmetischen
Grundoperationen noch erweitert, so daß auch analytische Funktionen
(also z. B. das Ziehen der k-ten Wurzel, trigonometrische Funktionen
usw.) in einem Takt berechnet werden können. Hierauf wird dann
aber gesondert hingwiesen.
Obwohl die Arbeitsweise der Unit-Cost Real RAM derjenigen realer
Rechner sehr ähnlich ist, muß man beachten, daß sie in einem Takt Zah- reale Rechner
len beliebiger Größe verarbeiten kann. Auf diese Weise können ausgedehnte
Berechnungen durch eine geeignete Codierung in einem einzigen
Takt „versteckt“ werden. Damit ist dieses Modell echt mächtiger als
das der Turing-Maschine.
Um dieses Problem auszuschließen, kann man fordern, daß alle auftretenden
Zahlen eine nach oben beschränkte Codierungslänge besitzen,
d. h. rational sind in der Form p
q mit p, q ∈ Q und |p| , |q| ≤ C für eine
Konstante C. Dann kann die Real RAM mit polynomiellem Mehraufwand
auch auf einem realen Rechner simuliert werden. Der Einfachheit
halber bleiben wir aber beim Modell der Unit-Cost Real RAM.
2.3.3 Komplexitätsklassen
Sei Π ein Problem, welches ein Algorithmus1 A lösen kann (z. B. das
Sortieren einer Menge von Zahlen). Um die Komplexität des Algorith-
mus A zu beschreiben, sei die Funktion TA : Π → N definiert als die Zahl
der Taktzyklen, die zur Lösung einer konkreten Probleminstanz P ∈ Π
(z. B. das Sortieren der Zahlen {8.1, 24, −3.4, 56}) benötigt werden. Die
Funktion SA : Π → N sei hierbei die maximale Anzahl belegter Speicherzellen
während der Ausführung des Algorithmus. Die Größe der
Probleminstanz (d. h. die Anzahl der zu sortierenden Zahlen in obigem
Beispiel) bezeichnen wir mit |P|.
1 Ein solcher Algorithmus kann auch nichtdeterministisch sein, d. h. er kann seine Berechnung
in mehrere parallele Wege aufspalten, von denen nur einer das gewünschte Resultat
liefern muß. Bei einem deterministischen Algorithmus gibt es solche Verzweigungen nicht.
beschränkte
Codierungslänge
Instanz
Problem Π
Lösung
Algorithmus
A

18 Grundbegriffe
Worst-case-Laufzeit
Worst-case-Speicherbedarf
Average-case-Analyse
randomisierter
Algorithmus
Definition 2.34 (Worst-case-Laufzeit und -Speicherbedarf)
Sei A ein Algorithmus für ein Problem Π, dann bezeichnen
die Worst-case-Laufzeit und
tA(n) := max
P∈Π,|P|=n TA(P)
sA(n) := max
P∈Π,|P|=n SA(P)
den Worst-case-Speicherbedarf des Algorithmus A.
Bemerkung 2.35 Wir betrachten hier ausschließlich den Worst case, der
sich für die schlimmstmögliche Probleminstanz der Größe n ergibt und
unter Umständen nur in ganz wenigen Fällen auftritt. Hat man für die
auftretenden Probleminstanzen eine Wahrscheinlichkeitsverteilung zur
Hand, kann in obiger Definition anstelle des Maximums auch der Erwartungswert
der Laufzeit bzw. des Speicherbedarfs verwendet werden
und man erhält eine Average-case-Analyse.
Schließlich kann auch der Algorithmus selbst Zufallsentscheidungen
treffen, die seine weitere Ausführung bestimmen (z. B. die Reihenfolge,
in der die Zahlen beim Sortieren abgearbeitet werden). Für einen sol-
chen randomisierten Algorithmus gibt es nicht nur eine Möglichkeit die
korrekte Lösung des Problems zu berechnen (wie beim deterministischen
Algorithmus), sondern mehrere. Die Zahlen TA(P) und SA(P) ergeben
sich dann als Erwartungswert der entsprechenden Zahlen über alle
verschiedenen Möglichkeiten des Algorithmus ans Ziel zu gelangen.
Hierbei ist wichtig, daß diese Zahlen nicht von der Wahrscheinlichkeitsverteilung
der zu bearbeitenden Probleminstanzen abhängen. ⊳
Probleme mit vergleichbarer Komplexität können zu Komplexitätsklassen
zusammengefaßt werden. Einige wichtige Klassen (für Entscheidungsprobleme
2 ) sind
• P := { Π � � Π kann von einem deterministischen Algorithmus A
gelöst werden mit tA(n) ∈ O(n k ) für ein k ∈ N },
• NP := { Π � � Π kann von einem nichtdeterministischen Algorithmus
A gelöst werden mit tA(n) ∈ O(n k ) für ein k ∈ N } und
• PSPACE := { Π � � Π kann von einem deterministischen Algorithmus
A gelöst werden mit sA(n) ∈ O(n k ) für ein k ∈ N }.
Zwischen diesen Klassen gelten die Inklusionsbeziehungen
P ⊆ NP ⊆ PSPACE
und die Frage, ob diese Inklusionen echt sind (d. h., ob P = NP oder
P �= NP gilt), ist ein zentrales Problem der Theoretischen Informatik
und noch immer unbeantwortet, obwohl vieles auf P �= NP hindeutet.
Man vergleiche hierzu auch [21, 10].
2 Bei einem Entscheidungsproblem muß der Algorithmus nur eine Ja/Nein-Antwort
zurückliefern.

2.3 Komplexität von Algorithmen 19
Definition 2.36 (Reduktion) Seien Π1 und Π2 zwei Probleme. Wir sagen,
Problem Π1 ist auf Problem Π2 τ(n)-reduzierbar (i. Z. Π1 �τ(n) Π2)
für eine Funktion τ: N → R, wenn es Algorithmen A1→2 und A2→1
gibt mit tA1→2 (n), tA2→1 (n) ∈ O(τ(n)), so daß für alle Probleminstanzen
P1 ∈ Π1 folgendes gilt:
1. Algorithmus A1→2 transformiert die Probleminstanz P1 ∈ Π1 in
eine Instanz P2 des Problems Π2.
2. Algorithmus A2→1 transformiert die Lösung für die Probleminstanz
P2 ∈ Π2 zurück in eine korrekte Lösung der ursprünglichen
Instanz P1.
Die Idee einer solchen Reduktion besteht darin, ein Problem auf ein anderes
Problem zu reduzieren, um damit untere oder obere Schranken für
die Laufzeit eines der beiden Probleme zu erhalten:
Untere Schranken Falls wir wissen, daß jeder Algorithmus für ein Problem
Π1 mindestens einen Zeitbedarf von Ω(t1(n)) besitzt und Π1
auf das Problem Π2 τ(n)-reduziert werden kann, dann hat jeder
Algorithmus zur Lösung von Π2 mindestens einen Zeitbedarf
von Ω(t1(n) − τ(n)). Hierbei wird natürlich vorausgesetzt, daß
τ(n) ∈ O(t1(n)). Sonst wäre die Reduktion nämlich völlig nutzlos,
da der Zeitbedarf zum Transformieren des Problems Π1 größer
wäre als der zu seiner Lösung.
Π1
Π1
A1→2
τ(n)-Reduktion
A2→1
untere Schranke
τ(n)-Reduktion
obere Schranke
Durch die Reduktion von Π1 auf Π2 haben wir also aus einer unteren
Schranke für Π1 eine untere Schranke für Π2 erhalten. untere Laufzeitschranke
Obere Schranke Falls wir ein Problem Π2 mit einem Zeitbedarf
von O(t2(n)) lösen können und ein Problem Π1 auf Π2
τ(n)-reduziert werden kann, dann kann das Problem Π1 mit
einem Zeitbedarf von O(t2(n) + τ(n)) gelöst werden.
Durch die Reduktion von Π1 auf Π2 haben wir also aus einer oberen
Schranke für Π2 eine obere Schranke für Π1 erhalten. obere Laufzeitschranke
Beispiel 2.37 Das Problem des dichtesten Paares (engl. closest pair) closest pair
im E 1 besteht darin, für n reelle Zahlen x1, . . . , xn zwei Zahlen xi und xj
mit minimalem Abstand |xi − xj| (unter allen Zahlenpaaren) zu bestimmen.
Da wir hierzu nur solche Paare betrachten müssen, die der Größe
nach benachbart sind, können wir dieses Problem in linearer Zeit auf
das Sortierproblem reduzieren: Sortierproblem
1. Algorithmus A1→2 bleibt leer, da wir die n Zahlen direkt als Eingabe
für das Sortierproblem benutzen können.
2. Das Sortieren der n Zahlen hat einen Zeitbedarf von O(n log n),
indem wir beispielsweise Heapsort verwenden.
3. Algorithmus A2→1 durchläuft die sortierte Folge x ′ 1 ≤ . . . x ′ n in
einem Sweep vom kleinsten zum größten Element und bestimmt in Sweep
linearer Zeit das Paar (x ′ i , x ′ i+1 ) aufeinanderfolgender Zahlen mit
kleinstem Abstand.
Π2
Π2

20 Grundbegriffe
Entscheidungsbaum
algebraisches
Entscheidungsbaummodell
Somit haben wir auch für das Closest-pair-Problem eine obere Laufzeitschranke
von O(n log n) + O(n) = O(n log n) gewonnen. ⊳
2.3.4 Das Entscheidungsbaummodell
Die Ausführung eines (deterministischen) Algorithmus A auf unserem
Maschinenmodell der Unit-Cost Real RAM können wir uns vorstellen
als das Durchlaufen eines Baums von höchstens dem Grad 2, ausgehend
von der Wurzel bis zu einem Blatt. Die inneren Knoten entsprechen
dabei den durchzuführenden Aktionen:
• In Knoten der Ordnung 1 werden Ein-/Ausgabe- sowie arithmetische
Operationen durchgeführt.
• An einem Knoten der Ordnung 2 erfolgt eine bedingte Verzweigung
zu einem seiner beiden Söhne.
Jeder Eingabe P entspricht also einem Weg von der Wurzel des Baums
zu einem seiner Blätter, wobei die Länge des Weges der Zahl der benötigten
Taktzyklen TA(P) entspricht. Einen solchen Baum nennen wir
einen Entscheidungsbaum.
Bemerkung 2.38 Man kann den Entscheidungsbaum auch als reinen
Binärbaum, der ausschließlich aus Entscheidungsknoten besteht, definieren.
Die übrigen (Rechen-) Operationen werden denn vernachlässigt.
Ebenso kann man auch mächtigere Entscheidungsbaumkonzepte
betrachten, bei denen in den Entscheidungsknoten nicht nur
zwei Zahlen miteinander verglichen werden können, sondern beispielsweise
das Vorzeichen linearer oder algebraischer Ausdrücke ermittelt
werden kann. Dies führt dann zum linearen bzw. algebraischen
Entscheidungsbaummodell. Allerdings würde diesen Modellen auch ein
mächtigeres Maschinenmodell als das unsrige entsprechen. ⊳
Mit dem Konzept des Entscheidungsbaums können wir nun eine untere
Schranke für das Sortierproblem bestimmen:
Satz 2.39 Das Sortieren von n Zahlen durch Vergleichen hat im Entscheidungsbaummodell
die Komplexität Ω(n log n).
Beweis: Sei A ein Algorithmus, der das Sortierproblem löst. Für jede der
n! Permutationen der n Zahlen muß mindestens ein Blatt im Entscheidungsbaum
zu A vorhanden sein. Denn sonst gäbe es zwei verschiedene
Permutationen, die von dem Sortieralgorithmus nicht unterschieden
werden könnten, und der Algorithmus A wäre nicht korrekt. Somit können
wir die Höhe des Entscheidungsbaums folgendermaßen ganz grob

2.3 Komplexität von Algorithmen 21
nach unten abschätzen: 3
Höhe ≥ log2 (n!)
�
n
� n
2
≥ log2 2
≥ n
2 log �
n
�
2 2
∈ Ω(n log n)
Somit gibt es mindestens eine Permutation, für die der Algorithmus A
mindestens Ω(n log n) Vergleiche ausführen muß. ✷
3 Die Knoten der Ordnung 1 brauchen wir hier gar nicht zu betrachten, denn sie ver-
größern die Höhe ja nur.

Grundlegende Geometrie
in der Ebene
3.1 Elementare geometrische Objekte
Wir definieren zunächst einige wichtige geometrische Grundobjekte
im R d . 1
Definition 3.1 Seien p und q zwei verschiedene Punkte im R d .
• Das Liniensegment oder die Strecke zwischen den beiden Punk-
ten ist die Menge
[p q] := { p + λ(q − p) � � λ ∈ R mit 0 ≤ λ ≤ 1 } . (3.1)
• Der Halbstrahl (oder kurz Strahl) von p aus in Richtung q ist de-
finiert durch
[p q} := { p + λ(q − p) � � λ ∈ R mit λ ≥ 0 } . (3.2)
Analog ist der Strahl {p q] definiert, obwohl man dafür auch [q p}
schreiben kann.
• Die Gerade durch die beiden Punkte ist die Menge
p q := { p + λ(q − p) � � λ ∈ R } . (3.3)
Bemerkung 3.2 Neben der parametrisierten Zwei-Punkte-Darstellung in
obiger Definition läßt sich insbesondere die Gerade noch auf viele andere
Arten beschreiben. Eine wichtige Darstellung einer Geraden g im R 2
ist die Normalenform,
g(n, a) := { x ∈ R 2 � � n T x − a = 0 }
= { x ∈ R 2 � � 〈n, x〉 = a } .
(3.4)
1 Obwohl wir in diesem Kapitel und im Rahmen fast der gesamten Vorlesung nur zweidimensionale
Objekte benötigen, werden wir – wo dies ohne Mehraufwand möglich ist –
die Definitionen so allgemein wie möglich halten.
q
[p q]
p
Liniensegment
[p q}
p
Halbstrahl
p q
p
Gerade
3
q
q

24 Grundlegende Geometrie in der Ebene
Normalenvektor
n
g(n, a)
a
0
Hesseform einer Geraden
Abstand eines Punktes von
einer Geraden
H +
H −
positive und negative
Halbebene
Hierbei ist n ∈ R2 \ (0, 0) ein Normalenvektor der Geraden (d. h. n steht
senkrecht auf g) und a eine reelle Zahl.
Hat der Vektor n außerdem die Länge 1 und ist a ∈ R≥0 (d. h. der Vektor
n muß „vom Ursprung weg zeigen“), dann spricht man von der Hes-
seform der Geraden g. Die Zahl a gibt in diesem Fall den (euklidischen)
Abstand der Geraden zum Ursprung an. Eine einfache Merkregel für
die Richtung des Normalenvektors bei der Hesseform: Für jeden Vektor
x auf der Geraden muß das Skalarprodukt 〈n, x〉 = n T x positiv sein.
Mit Hilfe der Hesseform läßt sich sehr einfach der Abstand eines Punktes
p von einer Geraden g(n, a) bestimmen. Es gilt nämlich
dist(p, g) = � � n T p − a � � , (3.5)
wobei das Vorzeichen des Ausdrucks n T p − a darüber entscheidet, auf
welcher Seite der Geraden der Punkt p liegt:
positives Vorzeichen p liegt auf der Seite von g(n, a), in die auch der
Normalenvektor n zeigt; somit liegen p und der Koordinatenursprung
auf verschiedenen Seiten von g(n, a).
negatives Vorzeichen p liegt auf der dem Normalenvektor abgewandten
Seite von g; somit liegen p und der Koordinatenursprung auf
derselben Seite von g(n, a).
Ganz analog definiert man im R 3 die Normalenform einer Ebene
bzw. allgemein im R d die Normalenform einer (d − 1)-dimensionalen
Hyperebene (d. h. eines (d − 1)-dimensionalen affinen Unterraums
des R d ). ⊳
Definition 3.3 (Halbebene/Halbraum) Sei g(n, a) die Normalenform
einer Geraden im R 2 . Dann nennt man
• H + (n, a) := { x ∈ R 2 � � n T x − a ≥ 0 } = { x ∈ R 2 � � 〈n, x〉 ≥ a }
die (abgeschlossene) positive Halbebene (engl. positive halfplane)
zu g(n, a),
• H − (n, a) := { x ∈ R 2 � � n T x − a ≤ 0 } = { x ∈ R 2 � � 〈n, x〉 ≤ a }
die (abgeschlossene) negative Halbebene (engl. negative halfplane)
zu g(n, a).
Die offenen Halbebenen H + (n, a) ◦ und H − (n, a) ◦ erhält man, indem
man in obiger Definition anstelle von »≥« (bzw. »≤«) jeweils »>«
(bzw. »

3.2 Elementare Lokationsprobleme 25
3.2 Elementare Lokationsprobleme
3.2.1 Point-in-half-plane-Test
Gegeben eine (abgeschlossene positive) Halbebene H + (n, a) = { x ∈
R d � � n T x − a ≥ 0 } und ein Punkt p ∈ R d . Dann kann der Test
„p ∈ H + (n, a)?“ mit einem Zeitbedarf von O(d) beantwortet werden.
Denn aus der Definition von H + (n, a) folgt sofort „p ∈ H + (n, a) ⇐⇒
n T p − a ≥ 0“ und die Berechnung dieses Ausdrucks erfordert O(d)
Additionen und Multiplikationen. Da die Komplexität der Eingabe
»(n, a, p)« schon aus Ω(d) ist, ist diese Schranke scharf und der Zeitbedarf
ist aus Θ(d).
Ist die Dimension d fest, dann kann der Point-in-half-plane-Test also in
konstanter Zeit entschieden werden.
3.2.2 Lage eines Punktes bezüglich eines Strahls
Gegeben ein Strahl [p q} ⊂ R 2 (bzw. eine orientierte Strecke [p q] oder
eine orientierte Gerade p q) und ein Punkt r ∈ R 2 , dann interessiert uns,
ob r links oder rechts vom Strahl [p q} liegt (oder auf der vom Strahl induzierten
Geraden).
Ein naheliegender Ansatz ist, dieses Problem auf einen Point-in-halfplane-Test
zurückzuführen. Hierzu muß aber zunächst eine Normalenform
g(n, a) der durch den Strahl induzierten Geraden bestimmt werden,
und zwar so, daß der Normalenvektor n z. B. immer in die linke
Halbebene zeigt. Denn andernfalls wäre nicht sofort klar, ob auf eine
positive oder auf eine negative Halbebene hin getestet werden muß und
es wären Fallunterscheidungen nötig, um dies zu unterscheiden.
� � � �
p1
q1
Sei nun p = und q =
gegen den
p2
q2
, dann ist z. B. der um π
2
Uhrzeigersinn gedrehte Richtungsvektor des Strahls [p q},
� �
p2 − q2
n =
,
q1 − p1
ein Normalenvektor zu p q, der immer in die linke Halbebene zeigt.
Durch Auflösen der Normalenform nach a und Einsetzen eines Punktes,
der auf dem Strahl liegt (z. B. p), erhält man dann den passenden
Wert für a,
a = n T p
= (p2 − q2)p1 + (q1 − p1)p2
= p2q1 − p1q2 .
Nun kann man den im letzten Abschnitt beschriebenen Point-in-halfplane-Test
auf den Punkt r und die (offene) Halbebene H + (n, a) ◦ an-
konstanter Zeitbedarf bei
fester Dimension
p
links
rechts
q
Reduktion auf
Point-in-half-plane-Test

26 Grundlegende Geometrie in der Ebene
p
a × b
b
r1
a
r2
q
Vektorprodukt
wenden und erhält die Äquivalenz:
mit
„r liegt (echt) links von [p q}“
⇐⇒
r ∈ H + (n, a) ◦
⇐⇒
n T r − a > 0
n T r − a = (p2 − q2)r1 + (q1 − p1)r2 − p2q1 + p1q2
= p2r1 − q2r1 + q1r2 − p1r2 − p2q1 + p1q2 .
Bemerkung 3.4 Obige Formel zum Testen der Lage eines Punktes läßt
sich auch noch auf andere Weise herleiten, nämlich unter Verwendung
des Vektorprodukts:
Denn offensichtlich gilt folgender Zusammenhang:
„r liegt (echt) links von [p q}“
⇐⇒
„Die drei Punkte (p, q, r) sind im Gegenuhrzeigersinn orientiert“
Dies läßt sich mittels des Vektorprodukts auf einfache Weise testen. Für
zwei Vektoren a, b ∈ R3 ergibt nämlich das Vektorprodukt
⎛
a × b := ⎝
a2b3 − a3b2
a3b1 − a1b3
a1b2 − a2b1
⎞
(∗)
⎠ (3.6)
einen zu a und b senkrecht stehenden Vektor, dessen Länge dem Flächeninhalt
des von a und b aufgespannten Parallelogramms entspricht
und der so orientiert ist, daß (a, b, a × b) ein Rechtssystem 2 bilden.
Für zwei Vektoren a, b ∈ R 2 ergibt sich dann für das Vektorprodukt der
in die x1-x2-Ebene eingebetteten Vektoren
⎛
⎝ a1
a2
⎞
⎛
b1
⎞
⎛
⎠ × ⎝b2⎠
= ⎝
0 0
0
0
a1b2 − a2b1
und für die dritte Komponente des Vektorprodukts gilt die Äquivalenz:
„Die drei Punkte (0, a, b) sind im Gegenuhrzeigersinn orientiert“
⇐⇒
a1b2 − a2b1 > 0
2 Drei Vektoren bilden ein Rechtssystem, wenn sie die gleiche Orientierung zueinander
besitzen wie Daumen, Zeigefinger und Mittelfinger der rechten Hand.
⎞
⎠

3.2 Elementare Lokationsprobleme 27
Setzt man jetzt a = q − p und b = r − p, dann erhält man für diese dritte
Komponente des Vektorprodukts
a1b2 − a2b1 = (q1 − p1)(r2 − p2) − (q2 − p2)(r1 − p1)
= q1r2 − p2q1 − p1r2 + p1p2
− q2r1 + p1q2 + p2r1 − p1p2
= (p1q2 − p2q1) + (q1r2 − q2r1) + (p2r1 − p1r2)
(∗∗)
und kann damit die Orientierung der drei Punkte p, q und r bestimmen.
⊳
Die beiden identischen Ausdrücke (∗) und (∗∗) lassen sich auch als
Determinante einer 3×3-Matrix schreiben. Wir definieren deshalb die
Funktion ccw: R2 × R2 × R2 → R (von engl. counter clockwise)
� �
�p1
p2 � 1�
�
ccw(p, q, r) := �q1
q2 � 1�
� . (3.7)
� �
Somit gilt
ccw(p, q, r)
⎧
⎪⎨
⎪⎩
r1 r2 1
< 0 falls r (echt) rechts von [p q} liegt,
= 0 falls r auf p q liegt,
> 0 falls r (echt) links von [p q} liegt.
Der Zeitbedarf für diesen Test ist wiederum aus Θ(1).
(3.8)
Bemerkung 3.5 Aufgrund der Eigenschaft des Vektorprodukts hat
das Dreieck mit den Eckpunkten a, b und c gerade den Flächenin-
|ccw(a, b, c)|. ⊳
halt 1
2
3.2.3 Schnitt zweier Strecken
Gegeben zwei Strecken p := [p1 p2] und q := [q1 q2] im R2 , dann möch- p2
ten wir wissen, ob die beiden Strecken sich schneiden (und gegebenenfalls
die Schnittmenge p ∩ q bestimmen).
Offensichtlich ist „p und q schneiden sich“ äquivalent zu
1. Die Strecken p und q sind kollinear und überlappen sich, oder
2. die Strecken p und q sind nicht kollinear und es gilt
die Endpunkte von q liegen auf verschiedenen
Seiten von p
und
die Endpunkte von p liegen auf verschiedenen
Seiten von q.
(3.9)
Flächeninhalt eines
Dreiecks
q1
p1
q2

28 Grundlegende Geometrie in der Ebene
Abbildung 3.1
Sonderfälle beim Schnitt
zweier Strecken
Fall „p und q sind
kollinear“
Die verschiedenen Fälle können jeweils durch Verwendung der ccw-
Funktion getestet werden:
1. „p und q sind kollinear“ ⇐⇒
ccw(p1, p2, q1) = ccw(p1, p2, q2) = 0
(bzw. ccw(q1, q2, p1) = ccw(q1, q2, p2) = 0, aber es muß nur eine
der beiden Aussagen überprüft werden)
Der Test auf Überlappung (bzw. Inklusion, siehe Abbildung 3.1
links) soll hier nicht weiter ausgeführt werden, ist jedoch nicht
schwierig, z. B. indem man für die Punkte q1 und q2 die entsprechenden
λ-Werte in
q1 = p1 + λ1(p2 − p1) q2 = p1 + λ2(p2 − p1)
ausrechnet und das sich so ergebende [λ1, λ2]- bzw.
[λ2, λ1]-Intervall mit dem Intervall [0, 1] schneidet.
Fall „p und q sind nicht 2. Falls p und q nicht kollinear sind, ist Eigenschaft (3.9) auf der
kollinear“ vorhergehenden Seite äquivalent zu
konstanter Zeitbedarf für
Streckenschnitt
ccw(p1, p2, q1) · ccw(p1, p2, q2) ≤ 0
∧
ccw(q1, q2, p1) · ccw(q1, q2, p2) ≤ 0 .
(3.10)
Hierbei werden auch gleich die Sonderfälle berücksichtigt (durch
Verwendung von »≤« anstelle von »

3.2 Elementare Lokationsprobleme 29
welche Punkte gleichen Winkels zu Äquivalenzklassen („Richtungen“)
[a]R := { b ∈ R 2 \ (0, 0) � � a ∼R b }
zusammenfaßt und bezeichnen mit
�
W := { [a]R � a ∈ R 2 \ (0, 0) }
die Menge aller Äquivalenzklassen (bez. der Relation R).
Nun wählen wir eine beliebige Richtung [z] ∈ W als „minimales Element“
und definieren die Relation »� [z]« wie folgt:
[a] � [z] [b]
def
⇐⇒
ccw(a, z) ≤ 0 ∧ ccw(b, z) > 0 ∨
ccw(a, z) · ccw(b, z) > 0 ∧ ccw(a, b) ≥ 0 ∨
ccw(a, z) ≤ 0 ∧ ccw(b, z) = 0 ∧ 〈b, z〉 ≤ 0 ∨
ccw(a, z) = 0 ∧ ccw(b, z) ≤ 0 ∧ 〈a, z〉 ≥ 0 .
(3.12)
0
Die Menge W der
Äquivalenzklassen
Diese etwas längliche Definition ist notwendig, um auch alle Sonderfälle
(z. B. »a, b, z sind kollinear«) zu berücksichtigen: Vorsicht bei Sonderfällen!
• Die erste Zeile behandelt den Fall, daß a links von z und b (echt)
rechts von z liegt;
• die zweite Zeile ermittelt die Relation von a und b zueinander,
wenn beide Punkte auf derselben Seite von z liegen;
• die letzten beiden Zeilen behandeln die Sonderfälle, wenn (mindestens)
einer der beiden Punkte kollinear zu z liegt.
Die Relation »�« besitzt die folgenden Eigenschaften:
∀ [a] [a] � [a] (Reflexivität)
∀ [a],[b] [a] � [b] ∧ [b] � [a] =⇒ [a] = [b] (Antisymmetrie)
∀ [a],[b] [a] � [b] ∨ [b] � [a] (Linearität)
∀ [a],[b],[c] [a] � [b] ∧ [b] � [c] =⇒ [a] � [c] (Transitivität)
Somit ist »� [z]« eine Ordnungsrelation auf der Menge W der Richtungen,
die angulare Ordnung (bez. des Strahls [0 z}), und wir können »� [z]« angulare Ordnung
verwenden, um z. B. Punkte nach ihrem Winkel zu sortieren.
Bemerkung 3.6 Die Wahl des „minimalen Elements“ [z] hat keinen Wahl des „minimalen
Elements“ [z]
großen Einfluß auf die angulare Ordnung. Denn sei
[p1] � [z1] [p2] � [z1] · · · � [z1] [pn] ,
dann gibt es für jedes andere „minimale Element“ [z2] ein k ∈ {1, . . . , n−
1}, so daß gilt
[p1+k] � [z2] [p2+k] � [z2] · · · � [z2] [pn+k] ,
wobei [pn+1] = [p1], . . . , [p2n−1] = [pn−1] ist (siehe Abbildung 3.2 auf
der nächsten Seite; hier ist k = 8 beim Wechsel von [z1] zu [z2]). ⊳

30 Grundlegende Geometrie in der Ebene
Abbildung 3.2
Einfluß des „minimalen
Elements“ auf die angulare
Ordnung
0
pl
q
pr
Linearer Zeitbedarf bei
Single-shot-Anfrage
4
5
3
6
2
1
10
z1
0
9 7
0
7
8
Bemerkung 3.7 Im folgenden benutzen wir der Einfachheit halber beim
Vergleichen von Punkten anstelle der etwas umständlichen Notation
[a] � [z] [b] die intuitivere Schreibweise a �z b, sind uns dabei jedoch
im klaren, daß anstelle der Punkte eigentlich deren Äquivalenzklassen
gemeint sind. ⊳
Bemerkung 3.8 Oft ist es gar nicht notwendig, die Richtung [z] bezüglich
derer die angulare Ordnung bestimmt wird, besonders auszuzeichnen.
Deshalb verwenden wir im folgenden – wenn nicht anders angegeben
– die positive x-Achse als Referenzstrahl für die angulare Ordnung
und schreiben dafür kurz »�«. ⊳
3.2.5 Sektorbestimmung – Single-shot-Anfrage
Gegeben n Punkte p1, . . . , pn ∈ R 2 , die n Sektoren induzieren, sowie
ein weiterer Anfragepunkt q ∈ R 2 . In welchem Sektor befindet sich q?
Bei einer Single-shot-Anfrage wird für die gegebene Datenmenge (hier,
die n Punkte) nur eine einzige Anfrage gestellt, im Gegensatz zu einer
Multiple-shot-Anfrage, bei der für dieselbe Datenmenge mehrere Anfragen
bearbeitet werden müssen (z. B. hier, m Anfragepunkte q1, . . . , qm).
Eine evtl. aufwendige Vorverarbeitung (engl. preprocessing) lohnt sich also
in der Regel nicht.
Zur Lösung des Problems betrachten wir die angulare Ordnung »�q«
der Punkte bez. des Strahl [0 q}. Dann wird offensichtlich der gesuchte
Sektor von denjenigen Punkten pl und pr begrenzt, für die gilt
∀1≤i≤n pl �q pi und ∀1≤i≤n pi �q pr .
Diese beiden Punkte werden von Algorithmus 3.1 auf der folgenden Seite
mit einem Zeitaufwand von O(n) bestimmt.
3.2.6 Sektorbestimmung – Multiple-shot-Anfrage
Gegeben wiederum n Punkte p1, . . . , pn ∈ R 2 wie in Abschnitt 3.2.5.
Dieses Mal ist es uns jedoch erlaubt, einen gewissen Preprocessing-Aufwand
zu investieren, damit eine Folge von Anfragen schneller beantwortet
werden kann als in Abschnitt 3.2.5, d. h. schneller als in Ω(n) pro
Anfrage.
6
5
8
4
9
3
10
2
1
z2

3.2 Elementare Lokationsprobleme 31
Algorithmus 3.1 Sektorbestimmung – Single-shot-Anfrage
SEKTORSS(q)
Input: n Punkte p1, . . . , pn ∈ R 2
Anfragepunkt q
1 r ← 1 {pr ist der rechte Randpunkt des gesuchten Sektors}
2 l ← 1 {pl ist der linke Randpunkt des gesuchten Sektors}
3 for i ← 2, . . . , n do
4 if pi �q pl then
5 l ← i
6 end if
7 if pr �q pi then
8 r ← i
9 end if
10 end for
Output: q befindet sich im Sektor der beiden Punkte pl und pr
Hierzu sortieren wir in der Preprocessing-Phase die Punkte p1, . . . , pn Preprocessing
bez. ihrer angularen Ordnung »�«. Dies erfordert einen einmaligen Preprocessing-Zeitbedarf
von O(n log n).
Für einen Anfragepunkt q können wir dann denjenigen Sektor, der q
enthält, mittels binärer Suche gemäß Algorithmus 3.2 auf der folgenden binäre Suche
Seite bestimmen. Somit erhalten wir folgenden Satz:
Satz 3.9 Für n Punkte p1, . . . , pn ∈ R 2 , die gemäß ihrer angularen
Ordnung sortiert sind (d. h. p1 � · · · � pn), und einen Anfragepunkt
q ∈ R 2 kann der Sektor, in dem sich q befindet, mit einem Zeitbedarf
von O(log n) bestimmt werden.
logarithmischer Zeitbedarf
bei Multiple-shot-Anfrage

32 Grundlegende Geometrie in der Ebene
Algorithmus 3.2 Sektorbestimmung – Multiple-shot-Anfrage
SEKTORMS(q)
Input: n Punkte p1 � · · · � pn ∈ R 2
Anfragepunkt q
1 r ← 0 {pr ist der rechte Randpunkt des gesuchten Sektors}
2 l ← n + 1 {pl ist der linke Randpunkt des gesuchten Sektors}
3 while l − r > 1 do
4 m ← ⌊ l+r
2 ⌋
5 if q � pm then
6 l ← m {q ist „rechts“ von pm, also streiche linke Hälfte}
7 else
8 r ← m {q ist „links“ von pm, also streiche rechte Hälfte}
9 end if
10 end while
11 if r = 0 then
12 r ← n
13 end if
14 if l = n + 1 then
15 l ← 1
16 end if
Output: q befindet sich im Sektor der beiden Punkte pl und pr

Polygone
Definition 4.1 (Polygon) Ein Weg w ⊆ E d , der aus einer endlichen Folge
von Liniensegmenten [p1 p2], [p2 p3], . . . , [pn−1 pn] besteht, heißt eine
polygonale Kette. polygonale Kette
Für eine einfache, geschlossene polygonale Kette w ⊆ E 2 in der Ebene,
nennt man das von w umschlossene innere Gebiet zusammen mit w
selbst ein (einfaches) Polygon P. 1
Polygon
Die Liniensegmente s1 = [p1 p2], s2 = [p2 p3], . . . , sn = [pn p1] heißen
Kanten, ihre Endpunkte p1, . . . , pn Ecken des Polygons. Kanten und Ecken
O. B. d. A. gehen wir dabei davon aus, daß das Polygon entgegen dem
Uhrzeigersinn orientiert ist, d. h. das Polygoninnere liegt immer links
der (orientierten) Liniensegmente [p1 p2], . . . , [pn−1 pn].
Abbildung 4.1 auf der nächsten Seite zeigt links zwei polygonale Ketten,
die beide keine Polygone sind, weil sie entweder nicht geschlossen oder
nicht einfach sind.
Bemerkung 4.2 Ein Polygon speichern wir – wenn nicht ausdrücklich
anders angegeben – durch seine Kantenfolge (s1, s2, . . . , sn) oder seine
Eckenfolge (p1, p2, . . . , pn). Im Gegensatz zu einer Speicherung als Kan-
tenmenge hat dies z. B. den Vorteil, daß beim Zugriff auf das Polygon die
einzelnen Kanten nicht erst wieder einander zugeordnet werden müssen.
Eine Speicherung als Eckenmenge ist sowieso indiskutabel, da dann
das Polygon nur in wenigen Fällen eindeutig bestimmt wäre.
Offenbar sind i. allg. Kanten- und Eckenfolgen nicht ohne weiteres dazu
geeignet, um zu entscheiden, ob zwei Polygone identisch sind, denn
1. können die Folgen zyklisch permutiert sein, und
2. kann ein Polygon auch mehrere strukturell verschiedene Kantenund
Eckenfolgen besitzen, nämlich genau dann, wenn diese aufeinanderfolgende
kollineare Ecken enthalten.
1 Manchmal läßt man die Forderung, daß der Rand ∂P (also w) einfach sein muß, auch
fallen oder erlaubt sogar, daß ∂P unzusammenhängend ist, das Polygon also Löcher besitzen
darf. Um solche Fälle explizit auszuschließen, nennt man P oft ein einfaches Polygon.
4
Speicherung als Kantenoder
Eckenfolge
Nichteindeutige Kantenund
Eckenfolgen aufgrund
kollinearer Ecken

34 Polygone
Abbildung 4.1
Zwei polygonale Ketten
(links) und zwei einfache
Polygone (rechts)
< 0
> 0
Knickwinkel
konvex
konvexe Hülle
Solche Fälle müssen also gesondert behandelt werden, z. B. durch Eliminieren
kollinearer Ecken. ⊳
Um beim Aufzählen von Kanten- und Eckenfolgen nicht immer unnötige
Fallunterscheidungen machen zu müssen, numerieren wir in einem
Polygon mit n Ecken und Kanten diese immer „modulo n“, d. h. sn+1 =
s1, sn+2 = s2, . . . und s0 = sn, s−1 = sn−1, . . . sowie analog für die
Ecken.
Definition 4.3 (Knickwinkel) Für zwei aufeinanderfolgende Segmente
si = [pi pi+1] und si+1 = [pi+1 pi+2] einer polygonalen Kette ist de-
ren Knickwinkel α(si, si+1) ∈ (−π, π) definiert als der Drehwinkel, der
nötig ist, um den Strahl [0 (pi+1 − pi)} in den Strahl [0 (pi+2 − pi+1)} zu
überführen. Linksdrehungen werden hierbei positiv und Rechtsdrehungen
negativ gezählt.
Für j > i ist α(si, sj) := � j−1
k=i α(sk, sk+1) die Summe der Knickwinkel
vom i-ten bis zum j-ten Segment.
Für die Summe α(s1, sn+1) aller Knickwinkel in einem Polygon kann
nun folgendes bewiesen werden:
Satz 4.4 Sei P ein beliebiges Polygon mit n Ecken, dann gilt für die Gesamtsumme
aller Knickwinkel
α(s1, sn+1) = 2π . (4.1)
4.1 Spezialfall »Konvexe Polygone«
Definition 4.5 (Konvexität) Eine Menge A ⊆ Rd heißt konvex, wenn
für je zwei verschiedene Punkte a, b ∈ A auch die Strecke [a b] in A liegt
(siehe Abbildung 4.2 auf der folgenden Seite).
Für eine Menge A ⊆ R d heißt
CH(A) := �
K⊇A
K konvex
K (4.2)
die konvexe Hülle von A (engl. convex hull) und ist die kleinste konve-
xe Menge, die A enthält.

4.1 Spezialfall »Konvexe Polygone« 35
a
b
Bemerkung 4.6 Für konvexe Mengen und Polygone kann man folgendes
zeigen:
1. Der gemeinsame Schnitt endlich vieler konvexer Mengen ist wieder
konvex.
2. Eine Menge A ⊆ E d ist genau dann konvex, wenn es für jeden
Punkt p ∈ ∂A auf dem Rand von A eine (d − 1)-dimensionale
Hyperebene H(n, a) mit p ∈ H(n, a) gibt, so daß A ganz im Halbraum
H + (n, a) liegt.
3. Ein konvexes Polygon P = (p1, . . . , pn) ist gleich der konvexen
Hülle seiner Eckpunkte,
b
P = CH({p1, . . . , pn}) .
Umgekehrt ist die konvexe Hülle einer n-elementigen Punktmenge
(die nicht alle auf einer Geraden liegen) ein konvexes Polygon
mit höchstens n Ecken.
4. Ein konvexes Polygon P = (s1, . . . , sn) ist gleich dem Schnitt von
n Halbebenen,
P =
n�
H + (ni, ai) ,
i=1
wobei die Geraden g(ni, ai) von den Polygonkanten si induziert
werden; die Normalenvektoren ni zeigen dabei in Richtung des
Polygoninneren.
Umgekehrt ist der Schnitt von n Halbebenen – sofern dieser zweidimensional
(d. h. im E 2 innere Punkte besitzt) und beschränkt
(d. h. keinen Halbstrahl enthält) ist – ein konvexes Polygon mit
höchstens n Ecken.
5. Ein konvexes Polygon P = (p1, . . . , pn) ist das einzige Polygon, das
genau {p1, . . . , pn} als Eckenmenge besitzt.
Denn jede Kante [pi pi+k], die nicht zwei benachbarte Ecken verbindet
(d. h. k /∈ {1, n − 1}), trennt die Punkte pi+1, . . . , pi+k−1
von den übrigen Punkten pi+k+1, . . . , pi+n−1 ab, d. h. die Punkte
liegen jeweils auf verschieden Seiten der durch [pi pi+k] induzierten
Geraden. (Sonst wäre P entweder nicht konvex oder – im Fall
a
Abbildung 4.2
Eine konvexe (links) und
eine nicht-konvexe Menge
(rechts) im E 2
si
H + (ni, ai)
P

36 Polygone
a
b
notw. Voraussetzung:
positiver Knickwinkel
pi+2
pi+1
ccw(pi, pi+1,
pi+2) ≥ 0
pi
kollinearer Strecken – nicht einfach.) In jeder der beiden Eckenmengen
muß es jeweils genau eine Ecke geben, die mit [pi pi+k]
verbunden wird, und eine Ecke p, die mit einer Ecke q der anderen
Menge verbunden wird, sonst ergäbe sich keine geschlossene
Kette. Das Segment [p q] schneidet pi pi+k, da p und q auf verschiedenen
Seiten der Geraden liegen. Da aufgrund der Konvexität
von P gilt P ∩ pi pi+k = [pi pi+k], schneidet [p q] auch das
Segment [pi pi+k], denn andernfalls würde [p q] teilweise im Äußeren
von P verlaufen und P wäre nicht konvex.
Somit kann es nur eine einfache polygonale Kette geben, die alle
Punkte p1, . . . , pn verbindet, nämlich P. ⊳
4.1.1 Test auf Konvexität
Wenn wir ein beliebiges Polygon P (in Kanten- oder Eckendarstellung)
gegeben haben, auf welche Weise (und mit welchem Zeitaufwand) können
wir entscheiden, ob das Polygon konvex ist?
Eine notwendige Voraussetzung für die Konvexität ist offenbar, daß al-
le Knickwinkel des Polygons positiv sind (d. h. der Innenwinkel an der
betreffenden Ecke ist kleiner oder gleich π), 2 denn sonst findet man
leicht in der Umgebung der fraglichen Ecke zwei Punkte a und b, so
daß [a b] � P gilt. Mittels der ccw-Funktion (siehe Gleichung (3.7)) können
wir diese Eigenschaft leicht testen, denn für die n Ecken des Polygons
muß in diesem Fall gelten
∀1≤i≤n pi+2 liegt links vom Strahl [pi pi+1}
⇐⇒
∀1≤i≤n ccw(pi, pi+1, pi+2) ≥ 0 ,
wobei wieder pn+1 = p1 und pn+2 = p2 ist.
(4.3)
Es stellt sich nun die Frage, ob diese Eigenschaft auch hinreichend für
die Konvexität ist, d. h. ob jedes Polygon mit ausschließlich positiven
Knickwinkeln konvex ist. Folgendes Lemma beantwortet diese Frage:
Lemma 4.7 Sei P = (p1, . . . , pn) ein Polygon (in Eckendarstellung) mit
ausschließlich positiven Knickwinkeln, d. h. mit ccw(pi, pi+1, pi+2) ≥ 0
für i = 1, . . . , n. Dann ist P konvex.
Beweis: Wir zeigen, daß das gesamte Polygon P links von der Kante
s1 = [p1 p2] liegen muß. Angenommen, dem wäre nicht so, dann
müßte es einen Punkt p ′ ∈ p1 p2 geben, wo die polygonale Kette
[p1 p2], [p2 p3], . . . zum ersten Mal die von der Geraden p1 p2 induzierte
positive Halbebene H + verläßt (siehe Abbildung 4.3 links).
Zwei Fälle für die Lage von p ′ sind möglich: p ′ liegt entweder auf dem
Strahl [p1 p2} oder auf dem Strahl {p1 p2]. O. B. d. A. genügt es, den ersten
Fall zu betrachten, denn im anderen Fall können wir das Polygon
2 Solche Winkel nennt man auch konvex, im Gegensatz zu negativen Knickwinkeln (d. h.
der Innenwinkel ist größer als π), die reflex oder konkav heißen.

4.1 Spezialfall »Konvexe Polygone« 37
an der Normalen zu p1 p2 spiegeln und durch Umkehren des Durchlaufsinns
erhalten wir ein Polygon, auf welches der erste Fall zutrifft.
Sei dann si = [pi pi+1] diejenige Polygonkante, die p ′ enthält. Es kann
nicht sein, daß p ′ = pi = p2 gilt, da beide Knickwinkel (an p2 und an pi)
positiv sind und pi+1 echt rechts von der Geraden p1 p2 liegt.
Wir betrachten jetzt das Polygon P ′ = (p1, p2, p ′ , pi+1, . . . , pn), siehe
Abbildung 4.3 rechts. Da die Summe aller Knickwinkel in P und P ′ nach
Satz 4.4 auf Seite 34 gleich 2π ist, andererseits aber auch die Knickwinkelsummen
α(si, sn+1) (in P) bzw. α([p ′ pi+1], [p1 p2]) (in P ′ ) aufgrund
der Übereinstimmung der beiden Polygone gleich sind, muß gelten
α(s1, si) = α([p1 p2], [p ′ pi+1]) < 0 ,
da p ′ auf dem Strahl [p1 p2} und pi+1 echt rechts vom Strahl [p1 p2} liegt.
Somit muß das Polygon P zwischen den Kanten s1 und si mindestens
einen konkaven Winkel besitzen, im Widerspruch zur Annahme. Folglich
kann ein solcher Punkt p ′ nicht existieren und das Polygon P liegt
links von der Kante s1 = [p1 p2].
Dieselbe Argumentation können wir jetzt bei allen Kanten si (für i =
1, . . . , n) anwenden. Somit können wir zu jedem Punkt p ∈ ∂P auf dem
Rand des Polygons eine Gerade g(n, a) angeben (nämlich die von derjenigen
Kante si induzierte Gerade, auf der p liegt), mit p ∈ g(n, a)
und P ⊆ H + (n, a). Laut Bemerkung 4.6 (2) auf Seite 35 ist P also konvex.
✷
Zusammenfassend erhalten wir also den folgenden Satz:
Satz 4.8 Die Konvexität eines Polygons (mit n Ecken) kann mittels Beziehung
(4.3) auf der gegenüberliegenden Seite mit einem Zeitbedarf
von O(n) getestet werden.
P
H + H +
p1
pi
p2
p ′
pi+1
P ′
p1
p2
p ′
pi+1
linearer Zeitbedarf für
Konvexitätstest
Abbildung 4.3
Zwischen p2 und p ′ hat P
mindestens einen
konkaven Winkel

38 Polygone
linearer Zeitbedarf für
Point-in-polygon-Test
132
132
zyklische angulare
Ordnung
2
1
123
132
Abbildung 4.4
Gebiete gleicher zyklischer
angularer Ordnung
3
4.1.2 Point-in-polygon-Test
Für ein gegebenes konvexes Polygon P – z. B. in Eckendarstellung P =
(p1, . . . , pn) – und einen Anfragepunkt q ∈ E 2 möchten wir wissen, ob
sich q innerhalb oder außerhalb des Polygons befindet.
Aus Bemerkung 4.6 (4) auf Seite 35 folgen sofort die Äquivalenzen
q ∈ P
⇐⇒
∀1≤i≤n q ∈ H + (ni, ai) bzw. ∀1≤i≤n ccw(pi, pi+1, q) ≥ 0 ,
wobei die Geraden g(ni, ai) von den Polygonkanten si induziert werden.
Somit können wir mit einem Zeitbedarf von O(n) testen, ob q im
Polygon P liegt.
Diese Schranke kann jedoch noch unterboten werden, wenn – wie oben
angenommen – das Polygon in Ecken- (oder Kantendarstellung) gegeben
ist. Hierzu betrachten wir die angulare Ordnung der Polygonecken;
allerdings nicht – wie bisher – mit dem Koordinatenursprung als Bezugspunkt,
sondern mit einem variablen Bezugspunkt x. (Natürlich
muß gelten x /∈ {p1, . . . , pn}.) Außerdem verzichten wir aufgrund der
„Zyklizität“ (siehe Bemerkung 3.6 auf Seite 29) auf eine Referenzrichtung,
d. h. es kommt uns nur auf die zyklische angulare Ordnung der
Punkte an.
Auf diese Weise erhalten wir für jeden Bezugspunkt x eine zyklische
Ordnung der Polygonecken und wir können überlegen, welche Punkte
x identische Ordnungen induzieren (und auf diese Weise eine Äquivalenzrelation
auf der Menge R 2 \{p1, . . . , pn} definieren). Die zyklische
angulare Ordnung der Punkte ändert sich offensichtlich genau dann,
wenn der Punkt x einen Strahl [pi (2pi − pj)} (für i �= j) überschreitet,
d. h. einen Strahl der in einem Punkt pi startet und in die zu einem anderen
Punkt pj entgegengesetzte Richtung verläuft.
Abbildung 4.4 zeigt links eine Zerlegung der Ebene in Gebiete gleicher
zyklischer angularer Ordnung für eine sechselementige Punktmenge.
Falls die Punkte Ecken eines konvexen Polygons P sind (wie z. B. rechts
in der Abbildung), dann ist P offensichtlich immer eine Teilmenge des
in der Abbildung farbig markierten Gebietes, denn keiner der die Gebiete
begrenzenden Halbstrahlen schneidet P. Somit folgt für die angulare
Ordnung:

4.2 Spezialfall »Sternförmige Polygone« 39
Beobachtung 4.9 Für ein konvexes Polygon P induzieren alle Punkte
aus P ◦ dieselbe zyklische angulare Ordnung.
Somit können wir für das als Eckenfolge gegebene Polygon P =
(p1, . . . , pn) sofort eine angulare Ordnung »�z« angeben, so daß p1 �z
· · · �z pn gilt: Als Bezugspunkt x wählen wir einen beliebigen Punkt
aus dem Innern von P, z. B. den Schwerpunkt dreier Polygonecken,
pi+pj+pk
3 , und als Referenzrichtung z wählen wir einen beliebigen
Strahl, der rechts von [x p1} und links von [x pn} liegt, z. B. z = [x y}
mit y = p1+pn
2 .
Die durch den Punkt x und zwei jeweils aufeinanderfolgende Polygonecken
pi und pi+1 induzierte Zerlegung der Ebene in Sektoren zerlegt
auch das Polygon P. Aufgrund der angularen Ordnung der Polygonecken
(mit x als Bezugspunkt) ist der Schnitt eines Sektors mit P
jeweils ein Dreieck mit den Eckpunkten x, pi, pi+1. Für den Test, ob
der Anfragepunkt q im Polygon P liegt, genügt es somit, das Dreieck
desjenigen Sektors zu betrachten, in dem sich der Punkt q befindet. Diesen
Sektor können wir (bei angular sortierten Punkten p1 �z · · · �z pn)
nach Satz 3.9 auf Seite 31 mit einem Zeitbedarf von O(log n) bestimmen.
Der Test, ob q innerhalb des entsprechenden Dreiecks liegt, kann wieder
mittels der ccw-Funktion erfolgen (bei konstantem Zeitbedarf). Den für
die angulare Ordnung »�z« benötigten Strahl z können wir ebenfalls
mittels der oben beschriebenen Idee in konstanter Zeit bestimmen. Somit
erhalten wir zusammenfassend den folgenden Satz:
Satz 4.10 Für ein konvexes Polygon P = (p1, . . . , pn) in Eckendarstellung
und einen Anfragepunkt q ∈ E 2 kann der Point-in-polygon-Test
mit einem Zeitbedarf von O(log n) beantwortet werden.
Ist lediglich eine Darstellung des Polygons als Kantenmenge vorhanden,
so kann der Test mit einem Zeitbedarf von O(n) erfolgen.
4.2 Spezialfall »Sternförmige Polygone«
Definition 4.11 (Sichtbarkeitspolygon) Sei P ein Polygon und p, q ∈ P.
Die beiden Punkte p und q heißen füreinander sichtbar (in P), wenn das sichtbar
Liniensegment [p q] komplett im Polygon P enthalten ist, d. h. [p q] ⊂ P
gilt.
Für einen Punkt p ∈ P heißt die Menge
vis(p) := { q ∈ P � � q ist für p sichtbar }
z
p1
p7
y
p6
p2
x
x
pi
p5
p3
pi+1
q
p4
logarithmischer Zeitbedarf
für Point-in-polygon-Test
das Sichtbarkeitspolygon von p in P. Sichtbarkeitspolygon
Zum Experimentieren empfiehlt sich das Java-Applet »VIP 2.0« von
Th. Wolf, welches das Sichtbarkeitspolygon (in linearer Zeit) berechnet
und darstellt (��������������������������������������������������
������������������������� ). WWW☞

40 Polygone
sternförmig
Kern
Kern als Schnitt von
Halbebenen
Definition 4.12 (Sternförmigkeit und Kern eines Polygons)
Ein Polygon P heißt sternförmig, wenn es einen Punkt p ∈ P gibt mit
vis(p) = P .
Die Gesamtheit aller dieser Punkte heißt der Kern von P, d. h.
ker(P) := { p ∈ P � � vis(p) = P } .
Bemerkung 4.13 Offensichtlich gelten folgende Beziehungen:
1. Jedes Sichtbarkeitspolygon vis(p) ist sternförmig und es gilt immer
p ∈ ker(vis(p)).
2. Das Sichtbarkeitspolygon eines Polygon der Komplexität n (d. h. P
besitzt n Ecken) ist von der Komplexität O(n).
3. Jedes konvexe Polygon ist auch sternförmig und es gilt
P ist konvex ⇐⇒ ker(P) = P . ⊳
Der Kern eines Polygons kann auch noch anders charakterisiert werden
als in Definition 4.12, nämlich als Schnitt von Halbebenen:
Lemma 4.14 Sei P mit Kantenfolge (s1, . . . , sn) und g(ni, ai), die von
den Kanten si induzierten Geraden. O. B. d. A. zeigen die Normalenvektoren
ni wieder in das Polygoninnere. Dann gilt
ker(P) =
n�
H + (ni, ai) .
i=1
Beweis: Die »⊆«-Richtung des Beweises ist einfach, denn wäre ein
Punkt p ∈ ker(P) in irgendeiner positiven Halbebene H + (ni, ai) nicht
enthalten, dann würde jede Strecke, die p mit einem Punkt auf si (ausgenommen
deren Endpunkte) verbindet, zumindest teilweise im Äußeren
des Polygons P verlaufen.
Sei umgekehrt p in jeder positiven Halbebene enthalten, dann liegt p
im Polygon P, weil es im anderen Fall mindestens eine Strecke si geben
müßte, die p „von außen“ sieht. Dann müßte aber p in H − (ni, ai) liegen,
im Widerspruch zur Annahme. Läge jetzt p nicht im Kern von P, wäre
vis(p) eine echte Teilmenge von P und es müßte einen Punkt v ∈ P geben,
der von p nicht gesehen wird, d. h. die Strecke [p v] muß mindestens
eine Kante von P schneiden. Sei si die erste Kante, die der Strahl [v p} auf
dem Weg von v zu p schneidet. Dann liegt offensichtlich v in H + (ni, ai)
und p muß sich demnach in H − (ni, ai) befinden, im Widerspruch zu
unserer Annahme. ✷
Sofern ein Polygon also einen zweidimensionalen Kern besitzt, ist dieser
(unter Verwendung von Bemerkung 4.6 (4) auf Seite 35) ein konvexes
Polygon mit O(n) Ecken.

4.2 Spezialfall »Sternförmige Polygone« 41
Lemma 4.15 Für jeden Punkt p eines Polygons P gilt
ker(P) ⊆ ker(vis(p)) .
Beweis: Das Sichtbarkeitspolygon vis(p) besteht zum einen aus Polygonkanten
von P (bzw. Teilen davon) und zum anderen aus künstlichen
Kanten, die durch reflexe Ecken entstehen. Sei HP die Menge der von
Kanten des ersten Typs induzierten positiven Halbebenen und HR die
Menge der von den restlichen Kanten des Sichtbarkeitspolygons induzierten
Halbebenen. Dann gilt nach Lemma 4.14 auf der gegenüberliegenden
Seite für den Kern des Sichtbarkeitspolygons vis(p)
ker(vis(p)) = �
und für den Kern des Polygon P
H + ∈HP
ker(P) = �
H + ∈H
H + ∩ �
H + ,
H + ∈HR
wobei H die Menge aller durch Polygonkanten von P induzierten Halbebenen
darstellt.
Wegen HP ⊆ H folgt sofort ker(P) ⊆ �
H + . Sei nun [r q] irgendeine
∈HP
der künstlichen Kanten von einer reflexen Ecke r zu einem Punkt q auf
dem Polygonrand. Da eine solche Kante kollinear zu p liegen muß, kann
ein Punkt, der sich nicht in der zu dieser Kante gehörenden positiven
Halbebene H + befindet, nicht zugleich p und q sehen. Demzufolge kann
ein solcher Punkt auch nicht aus dem Kern ker(P) sein. Damit gilt also
auch ker(P) ⊆ �
H + und durch beide Inklusionen zusammen folgt
∈HR
die Behauptung. ✷
4.2.1 Point-in-polygon-Test
Wie beim Point-in-polygon-Test für konvexe Polygone (siehe Abschnitt
4.1.2 auf Seite 38) ist wieder ein – diesmal sternförmiges –
Polygon P = (p1, . . . , pn) in Eckendarstellung gegeben. Für einen Anfragepunkt
q soll dann wie zuvor getestet werden, ob sich q innerhalb
oder außerhalb des Polygons befindet.
Wenn wir zusätzlich annehmen, daß wir einen Punkt x ∈ ker(P) kennen,
dann kann der Point-in-polygon-Test ganz analog zum »konvexen
Fall« durchgeführt werden. Betrachten wir wieder die zyklische angulare
Ordnung der Polygonecken und die Zerlegung der Ebene in Gebiete
gleicher angularer Ordnung, dann können wir Beobachtung 4.9 auf
sternförmige Polygone erweitern:
Lemma 4.16 Für ein sternförmiges Polygon P induzieren alle Punkte
aus ker(P) ◦ dieselbe zyklische angulare Ordnung.
H +
q
r
p
H +
Gebiete gleicher zyklischer
angularer Ordnung

42 Polygone
logarithmischer Zeitbedarf
für Point-in-polygon-Test
linearer Zeitbedarf für
Bestimmung des Kerns
Abbildung 4.5
Ein Halbstrahl schneidet
das Innere des
Kerns ker(P)
Beweis: Würden nicht alle Punkte aus ker(P) ◦ dieselbe Ordnung induzieren,
müßte einer der die Gebiete gleicher Ordnung begrenzenden
Halbstrahlen das Innere von ker(P) schneiden (siehe Abbildung 4.5).
Sei p der Startpunkt dieses Halbstrahls und q der die Richtung bestimmende
Punkt. Aufgrund der Sternförmigkeit von P muß q vom Kern
aus sichtbar sein. Deshalb können die beiden mit p inzidenten Polygonkanten
nicht auf verschiedenen Seiten von [q p} liegen, da sonst die Sicht
auf q verdeckt wäre. Somit muß p also eine reflexe Ecke sein und der
in der Abbildung farbig markierte Bereich („zwischen“ p und q) kann
nicht vom ganzen Kern aus eingesehen werden, im Widerspruch zur
Sternförmigkeit von P. ✷
Somit können wir wiederum mit Hilfe des Punktes x (von dem wir jetzt
o. B. d. A. annehmen, daß er sogar im Innern des Kerns von P liegt) für
das als Eckenfolge gegebene Polygon P = (p1, . . . , pn) eine angulare
Ordnung »�z« angeben, so daß p1 �z · · · �z pn gilt: Als Referenzrichtung
z wählen wir wieder einen beliebigen Strahl, der rechts von [x p1}
und links von [x pn} liegt.
Für den Test, ob der Anfragepunkt q im sternförmigen Polygon P liegt,
genügt es jetzt wieder, das Dreieck desjenigen Sektors zu betrachten,
in dem sich der Punkt q befindet. Und dieser Sektor kann bekanntlich
nach Satz 3.9 auf Seite 31 mit einem Zeitbedarf von O(log n) bestimmt
werden. Zusammenfassend erhalten wir somit den folgenden Satz:
Satz 4.17 Für ein sternförmiges Polygon P = (p1, . . . , pn) in Eckendarstellung,
für das ein Punkt x ∈ ker(P) bekannt ist, und einen Anfragepunkt
q ∈ E 2 kann der Point-in-polygon-Test mit einem Zeitbedarf
von O(log n) beantwortet werden.
Für den Fall, daß kein Punkt aus dem Kern von P bekannt ist, sondern
dieser erst bestimmt werden muß, sei der folgende Satz – ohne Beweis –
zitiert:
Satz 4.18 Der Kern eines Polygons mit n Ecken kann mit einem Zeitbedarf
von O(n) berechnet werden.
Ein Beweis und ein Algorithmus zur Berechnung des Kerns finden sich
z. B. in [14, S. 204]. Mit Hilfe von Satz 4.18 können wir jetzt für jedes
sternförmige Polygon, das wir erhalten, in linearer Zeit (also in der Größenordnung
der Eingabekomplexität) einen Kernpunkt bestimmen und
ker(P) p
q
P

4.2 Spezialfall »Sternförmige Polygone« 43
Algorithmus 4.1 Erzeugen eines (sternförmigen) Polygons
STERNPOL(p1, . . . , pn)
Input: n Punkte p1, . . . , pn ∈ E 2
1 Bestimme den Punkt pmin mit minimaler y-Koordinate (bei Punkten
gleicher y-Koordinate, denjenigen mit maximaler x-Koordinate)
2 Sortiere die Punkte {p1, . . . , pn} \ {pmin} nach ihrer angularen Ordnung
»�« mit pmin als Bezugspunkt und der positiven x-Achse als
Referenzrichtung (bei Punkten gleichen Winkels, nach wachsendem
Abstand zu pmin)
(pi1 , . . . , pin−1 ) sei die sortierte Folge
3 P ← (pmin, pi1 , . . . , pin−1 )
Output: P ist ein sternförmiges Polygon mit der
Eckenmenge {p1, . . . , pn}
diesen zusammen mit dem Polygon abspeichern, so daß dann jeder
Point-in-polygon-Test mit logarithmischem Zeitbedarf beantwortet werden
kann.
4.2.2 Erzeugen eines (sternförmigen) Polygons mit vorgegebener
Eckenmenge
Angenommen, wir sollen für eine vorgegebene Punktmenge
{p1, . . . , pn} ⊂ E 2 ein Polygon P bestimmen, das genau diese
Menge als Eckenmenge besitzt. Ist dies immer möglich und – falls ja –
wie schnell können wir das Polygon erzeugen?
Offenbar leistet Algorithmus 4.1 das Gewünschte: Durch die angulare
Sortierung der Punkte bezüglich des extremalen Punktes pmin wird
ausgeschlossen, daß sich zwei nicht inzidente Polygonkanten schneiden
und wir erhalten ein sternförmiges Polygon P mit pmin ∈ ker(P).
Die Laufzeit des Algorithmus wird offensichtlich vom Zeitbedarf für das
Sortieren der n Punkte dominiert und ist aus O(n log n). Es stellt sich
nun die Frage, ob wir mit einem anderen Ansatz diese Schranke noch
unterbieten können. Der folgende Satz zeigt, daß dies nicht möglich ist:
Satz 4.19 Der Zeitbedarf, um zu einer gegebenen Menge von n Punkten
{p1, . . . , pn} ⊂ E 2 ein Polygon zu bestimmen, das genau diese Punkte
als Ecken besitzt, ist aus Θ(n log n).
Beweis: Es genügt, noch zu zeigen, daß die Lösung des Problems im
Worst case einen Zeitbedarf von Ω(n log n) besitzt.
Hierzu reduzieren wir das Sortierproblem, welches nach Satz 2.39 auf
Seite 20 in unserem Berechnungsmodell die Komplexität Ω(n log n) besitzt,
auf unser Problem: Gegeben also n Zahlen, x1, . . . , xn ∈ R, dann
pmin
Zeitbedarf von Θ(n log n)
zur Polygonbestimmung

44 Polygone
Vorsicht! Sonderfälle!
linearer Zeitbedarf für
Point-in-polygon-Test
betrachten wir die Punktmenge
S := {(x1, x 2 1), . . . , (xn, x 2 n)} ,
die wir in linearer Zeit bestimmen können.
Weil alle Punkte von S auf der konvexen Funktion x ↦→ x 2 liegen, gibt
es nach Bemerkung 4.6 (5) auf Seite 35 nur genau ein Polygon, welches
diese Punkte als Eckenmenge besitzt. Zudem liefert uns ein Durchlaufen
der Eckenfolge dieses Polygons in linearer Zeit eine Sortierung der
Zahlen x1, . . . , xn.
Somit haben wir das Sortierproblem in linearer Zeit auf das Problem
der Polygonbestimmung reduziert und erhalten für dieses eine untere
Schranke von Ω(n log n − n) = Ω(n log n). ✷
4.3 Point-in-polygon-Test bei allgemeinen Polygonen
Für beliebige einfache Polygone läßt sich der Point-in-polygon-Test
nicht so elegant lösen wie im Fall konvexer oder sternförmiger Polygone,
da es i. allg. keine Zerlegung der Ebene in Sektoren gibt, so daß der
Schnitt jedes Sektors mit dem Polygon genau ein Dreieck ergibt (sonst
wäre das Polygon ja auch sternförmig).
Allerdings können wir uns den Jordanschen Kurvensatz zunutze machen
und die Anzahl der Schnitte des Polygonrandes mit einem Strahl
vom Anfragepunkt q aus ins „Unendliche“ zählen. Ist diese nämlich
ungerade, dann liegt q offensichtlich innerhalb von P, sonst außerhalb
(Sonderfälle, in denen q auf dem Rand von P liegt, sollen hier unberücksichtigt
bleiben; diese können aber z. B. separat in linearer Zeit ausgeschlossen
werden). Algorithmus 4.2 auf der folgenden Seite bestimmt
genau diese Anzahl an Schnitten. Der Punkt ˜p liegt dabei in jedem Fall
außerhalb von P.
Beim Zählen der Schnitte treten allerdings leicht Sonderfälle auf (wenn
z. B. Polygonecken oder -kanten auf dem Segment liegen), die geeignet
berücksichtigt werden müssen, so daß keine Schnitte übersehen oder
doppelt gezählt werden. Algorithmus 4.2 berücksichtigt dies, indem
nicht alle Schnitte von Polygonkanten mit dem Strahl gezählt werden,
sondern nur solche, bei denen beim Durchlauf der Eckenfolge ein Wechsel
des Eckpunktes auf die andere Seite des Strahls erfolgt. Hierzu wird
wieder die ccw-Funktion aus Abschnitt 3.2.2 verwendet.
Der Zeitbedarf von Algorithmus 4.2 ist offensichtlich linear in der Zahl
der Polygonecken, so daß wir folgenden Satz erhalten:
Satz 4.20 Für ein beliebiges Polygon P = (p1, . . . , pn) in Eckendarstellung
und einen Anfragepunkt q ∈ E 2 kann der Point-in-polygon-Test
mit einem Zeitbedarf von O(n) beantwortet werden.

4.3 Point-in-polygon-Test bei allgemeinen Polygonen 45
Algorithmus 4.2 Point-in-polygon-Test
POINTINPOLYGON(q)
Input: Beliebiges Polygon P = (p1, . . . , pn) ⊂ E 2
Anfragepunkt q
1 Bestimme einen Punkt ˜p außerhalb von P (z. B. anhand der maximalen
Koordinatenwerte der Eckpunkte)
{Suche einen Eckpunkt, der nicht auf ˜p q liegt}
2 i ← 1
3 while ccw( ˜p, q, pi ) = 0 do
4 i ← i + 1
5 end while
6 s ← 0 {s zählt die Anzahl der Schnitte von [ ˜p q] mit ∂P}
7 lr ← sgn(ccw( ˜p, q, pi )) {lr ∈ {−1, 0, 1}}
8 for j ← i + 1, . . . , n do
9 lrnew ← sgn(ccw( ˜p, q, pj ))
10 if |lrnew − lr| = 2 then
11 lr ← lrnew
12 if ccw(pj−1, pj , ˜p) · ccw(pj−1, pj , q) ≤ 0 then
13 s ← s + 1 { ˜p und q liegen auf versch. Seiten von [pj−1 pj ]}
14 end if
15 end if
16 end for
Output: Ist s ungerade, befindet sich q innerhalb von P, sonst
außerhalb

Das
Plane-sweep-Paradigma
Das Sweep-Paradigma ist eine algorithmische Technik, die zur Lösung
einer Vielzahl von geometrischen Problemen verwendet werden kann.
Das Gemeinsame an allen Sweep-Verfahren ist, daß aus einem statischen
d-dimensionalen Problem ein dynamisches (d − 1)-dimensionales Problem
wird, indem eine der räumlichen Dimensionen in eine zeitliche Dimension
verwandelt wird. Bezogen auf die zweidimensionalen Probleme,
mit denen wir uns beschäftigen, heißt das, daß ein solches Problem in
eine Folge eindimensionaler Probleme transformiert wird.
Dieses Verwandeln geschieht in der Regel dadurch, daß eine eindimensionale
Struktur – z. B. eine Gerade (die Sweep line) – horizontal über die Sweep line
Problemanordnung hinwegwandert. Die Problemanordnung selbst (die
sich u. U. während die Sweep line sie überquert auch noch ändern kann)
wird hierbei in der sog. Horizontalstruktur verwaltet. Horizontalstruktur
An einigen diskreten Stellen hält die Sweep line dann an, um jeweils ein
eindimensionales Problem zu bearbeiten. Die für die Bearbeitung dieses
Problems nötige Informationsmenge ist in der Regel sehr viel kleiner
als das zu lösende Gesamtproblem und wird in der sog. Vertikalstruktur Vertikalstruktur
verwaltet. Diese kann – z. B. bei sehr einfachen Problemen – an jedem
Haltepunkt der Sweep line neu erzeugt werden, wird aber in der Regel
nur von einem Haltepunkt zum nächsten Haltepunkt geeignet fortgeführt.
Die Gesamtlösung des zweidimensionalen Problems ergibt sich dann
durch eine geeignete Verknüpfung der Folge von Teillösungen der eindimensionalen
Probleme.
5.1 Das Problem des dichtesten Punktepaares
Gegeben n Punkte p1, . . . , pn ∈ E 2 , dann besteht das Closest-pair-
Problem darin, zwei Punkte pi, pj (i �= j) mit minimalem euklidischen Closest-pair-Problem
Abstand zu finden, d. h.
|pi pj| = min
1≤k

48 Das Plane-sweep-Paradigma
MinDist
Ein naiver Algorithmus zur Bestimmung des dichtesten Punktepaares
berechnet alle Θ(n 2 ) Abstandspaare zwischen je zwei Punkten und
wählt hiervon den kleinsten aus. Die Laufzeit dieses Algorithmus ist
also aus O(n 2 ). Diese Schranke wollen wir mittels eines Plane-sweep-
Ansatzes unterbieten.
Problem im Das analoge Problem im Eindimensionalen, zu einer Menge von Zah-
Eindimensionalen len x1, . . . , xn ∈ R das dichteste Paar zu finden, ist uns schon in Beispiel
2.37 auf Seite 19 begegnet. Wir lösen es (mit einem Zeitbedarf
von O(n log n)), indem wir die Zahlen zunächst sortieren. Dann können
wir die Tatsache ausnutzen, daß zwei Zahlen, die ein dichtestes Paar
bilden, in der Sortierung direkt aufeinander folgen müssen. Somit können
wir dieses Paar mit einem eindimensionalen Sweep über alle Zahlen
bestimmen, wobei unser Sweep point an jeder Zahl Halt macht und wir
ein nulldimensionales Problem lösen müssen: Wir müssen die Differenz
der aktuellen und der vorhergehenden Zahl bestimmen und diese mit
der bisher kleinsten Differenz vergleichen.
MinDist
Im Zweidimensionalen wollen wir jetzt so ähnlich vorgehen. Die Kernpunkte
unserer Idee sind hierbei die folgenden:
Horizontalstruktur Wir sortieren zunächst alle Punkte nach ihrer
x-Koordinate, d. h. die Horizontalstruktur, die sich in diesem Fall
während der gesamten Algorithmenausführung nicht ändert,
wird in einem Preprocessing-Schritt als sortierte Liste initialisiert.
Der Zeitaufwand hierfür ist aus O(n log n).
Sweep line Die Sweep line lassen wir von links nach rechts über die
Punkte gleiten, wobei wir an jedem Punkt Halt machen.
Sei MinDist der minimale Abstand unter allen bereits abgearbeiteten
Punkten, d. h. der Abstand zweier Punkte, die links der aktuellen
Sweep line liegen. Um zu testen, ob der aktuelle Punkt (auf
der Sweep line) diesen Abstand noch unterbieten kann, genügt es
offensichtlich, alle Punkte zu betrachten, die sich in einem Streifen
der Breite MinDist links der Sweep line befinden.
Vertikalstruktur Dieser Streifen (bzw. die Punkte, die er enthält) muß
also mittels unserer Vertikalstruktur (möglichst effizient) verwaltet
werden. Wir verwenden hierfür einen balancierten Suchbaum
(z. B. einen AVL-Baum), der für alle drei Operationen »Suchen«,
»Einfügen« und »Löschen« eine logarithmische Zugriffszeit garantiert.
Außerdem sind Bereichsanfragen mit einem Zeitbedarf
von O(log n + k) möglich, wobei k die Größe der Antwort beschreibt.
Die Punkte werden dabei bezüglich ihrer y-Koordinate im AVL-
Baum verwaltet.
Es müssen jetzt nur noch die folgenden Fragen geklärt werden:
• Zu welchen Zeitpunkten muß die Vertikalstruktur aktualisiert
werden.

5.1 Das Problem des dichtesten Punktepaares 49
• Welche Aktionen müssen bei einer Aktualisierung jeweils durchgeführt
werden?
• Wie hoch ist der Gesamtzeitaufwand des Plane-sweep-Algorithmus?
Dieser Aufwand sollte in jedem Fall geringer sein als Ω(n 2 ),
denn sonst hätten wir keinen Vorteil gegenüber dem naiven Verfahren
erreicht.
Offenbar gibt es zwei Typen von Ereignissen, die eine Aktualisierung
der Vertikalstruktur erfordern:
1. Der linke Rand des Streifens, der im Abstand MinDist der Sweep
line „folgt“, wandert über einen Punkt hinweg.
2. Die Sweep line stößt auf einen neuen Punkt.
Im ersten Fall, muß der betreffende Punkt aus der Vertikalstruktur entfernt
werden (mit einem Zeitbedarf von O(log n)). Im zweiten Fall,
wenn die Sweep line auf einen neuen Punkt stößt, muß der Punkt in die
Vertikalstruktur aufgenommen werden. Außerdem muß getestet werden,
ob der neu aufgenommene Punkt zu irgendeinem anderen Punkt
im Streifen einen geringeren Abstand als den momentan minimalen Abstand
MinDist besitzt. Falls dies der Fall ist, muß der Wert von MinDist
und damit auch die Streifenbreite aktualisiert werden. Hierdurch können
in der Folge auch wieder Ereignisse des ersten Typs ausgelöst werden
– ohne daß die Sweep line weiterwandert.
Zwei Typen von
Ereignissen
Diese Vorgehensweise wird in Algorithmus 5.1 auf der folgenden Seite
realisiert. Hierbei bedarf Schritt 12 – die Bestimmung des minimalen
Abstands des aktuellen Punktes zu allen Punkten aus dem Streifen –
einer genaueren Erläuterung: Zur Bestimmung dieses Abstands müssen
nämlich nicht alle Punkte in dem Streifen der Breite MinDist betrachtet
werden (dies können u. U. immer noch sehr viele sein, z. B. bei einer
vertikalen Anordnung der Punkte), sondern nur diejenigen, die sich in
einem Rechteck der Breite MinDist und der Höhe 2 · MinDist um den
aktuellen Punkt herum befinden. MinDist
Dieses Rechteck kann man sich nun in acht rechtwinklige gleichseitige
Dreiecke unterteilt vorstellen, deren längste Seite jeweils gleich MinDist
ist. Da nach Voraussetzung der minimale Abstand aller Punkte links
der Sweep line gleich MinDist ist, kann jedes dieser Dreiecke maximal
einen Punkt enthalten – das gesamte Rechteck also maximal acht Punkte.
Diese Punkte entsprechen demnach im AVL-Baum einem Teilbaum,
der aus maximal acht Knoten besteht, und können durch zwei Suchanfragen
(nach »HS rechts.y − MinDist« bzw. »HS rechts.y + MinDist«) und
Enumeration der dazwischen liegenden Knoten bestimmt werden. Der
Zeitbedarf hierfür ist aus O(log n + 8) = O(log n).
Folgender Satz faßt unsere Überlegungen noch einmal zusammen:
Satz 5.1 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 können zwei
Punkte pi, pj (i �= j) mit minimalem euklidischen Abstand, d. h.
|pi pj| = min
1≤k

50 Das Plane-sweep-Paradigma
Zeitbedarf von Θ(n log n)
für dichtestes Punktepaar
Algorithmus 5.1 Bestimmung des dichtesten Punktepaares in der Ebene
CLOSESTPAIR(p1, . . . , pn)
Input: n Punkte p1, . . . , pn ∈ E 2
{Initialisierungsschritt}
1 Sortiere die Punkte p1, . . . , pn nach aufsteigenden x-Koordinaten
und füge sie ins Feld HS ein
2 VS ← AVL-Baum, initialisiert mit HS 1 und HS 2
3 MinDist ← |HS 1 HS 2|
4 MinPair ← (1, 2)
5 links ← 1 {HS links ist der am weitesten links liegende Punkt im
Streifen}
6 rechts ← 3 {HS rechts ist der aktuelle Punkt auf der Sweep line}
{Sweep}
7 while rechts ≤ n do
8 if HS links.x + MinDist ≤ HS rechts.x then
9 Entferne HS links aus VS
10 links ← links + 1
11 else
12 Bestimme den minimalen Abstand D = |HS rechts HS min|
von HS rechts zu allen Punkten in VS
13 if D < MinDist then
14 MinDist ← D
15 MinPair ← (rechts, min)
16 end if
17 Füge HS rechts in VS ein
18 rechts ← rechts + 1
19 end if
20 end while
Output: Dichtestes Punktepaar MinPair mit minimalem
Abstand MinDist
mit einem optimalen Zeitbedarf von Θ(n log n) gefunden werden. Der
Speicherbedarf ist dabei aus Θ(n).
Beweis: Die Initialisierung der Horizontalstruktur hat einen Zeitbedarf
von O(n log n) für das Sortieren der Punkte.
Die while-Schleife des Algorithmus wird O(n)-mal durchlaufen, da jeder
Punkt höchstens einmal in die Vertikalstruktur aufgenommen und
höchstens einmal daraus entfernt wird. Sowohl das Entfernen aus der
Vertikalstruktur als auch das Einfügen in diese erfordern O(log n) Zeit.
Da nach obigen Überlegungen auch Schritt 12 des Algorithmus in logarithmischer
Zeit zu bewerkstelligen ist, erhält man einen Zeitbedarf
von O(log n) für einen Schleifendurchlauf.
Insgesamt erhalten wir also eine Gesamtlaufzeit von O(n log n) für Algorithmus
5.1.
Die Optimalität folgt dann aus einer unteren Schranke von Ω(n log n)

5.2 Schnitt konvexer Polygone 51
für das Problem des dichtesten Paares (selbst im eindimensionalen Fall).
Auf den Beweis dieser Schranke wollen wir hier verzichten; er ähnelt
jedoch dem Beweis von Satz 2.39 auf Seite 20 für die untere Schranke
von O(n log n) für das Sortierproblem.
Der Speicherbedarf der Horizontal- und der Vertikalstruktur ist dabei
jeweils linear in der Zahl der gespeicherten Punkte und somit, da jeweils
maximal O(n) Punkte darin enthalten sind, aus Θ(n). ✷
5.2 Schnitt konvexer Polygone
Gegeben zwei Polygone P = (p1, . . . , pm) und Q = (q1, . . . , qn), dann
interessiert uns zum einen, ob die beiden Polygone sich schneiden, und
zum anderen eine Beschreibung der Schnittmenge. Offensichtlich gilt:
Beobachtung 5.2 Der Schnitt zweier beliebiger Polygone P =
(p1, . . . , pm) und Q = (q1, . . . , qn) kann im Worst case aus Ω(mn) Polygonen
bestehen und somit eine Gesamtkomplexität von Ω(mn)
besitzen.
Der Schnitt zweier konvexer Polygone P = (p1, . . . , pm) und Q =
(q1, . . . , qn) ist entweder leer, niederdimensional (d. h. ein Punkt oder
eine Strecke) oder ein konvexes Polygon der Komplexität O(m + n).
(Dies folgt sofort aus Bemerkung 4.6 (4) auf Seite 35.) Im Worst case kann
diese Schranke auch angenommen werden, z. B. beim Schnitt zweier regelmäßiger
n-Ecke, die um den Winkel π
n gegeneinander verdreht sind.
Da also der Schnitt konvexer Polygone – schon strukturell – beträchtlich
einfacher ist, beschränken wir uns in diesem Abschnitt zunächst auf die
Schnittbestimmung konvexer Polygone – wiederum mittels eines Planesweep-Verfahrens.
Die Grundidee hierbei ist, die Ebene in eine Menge vertikaler Streifen
zu zerlegen und die Streifen von links nach rechts zu bearbeiten. Jede
Ecke eines der beiden Polygone induziert dabei eine vertikale Gerade
und die Menge aller auf diese Weise entstehenden Geraden unterteilt
die Ebene in O(n + m) Streifen. Innerhalb eines Streifens Si kann dann
der Schnitt (P ∩ Si) ∩ (Q ∩ Si) sehr einfach berechnet werden, da jedes
„Bruchstück“ P ∩ Si bzw. Q ∩ Si maximal vier Ecken besitzt.
Horizontalstruktur Die Liste der Halteereignisse für die Sweep line besteht
genau aus der Menge aller Polygonecken von P und Q – sortiert
bez. ihrer x-Koordinate.
Um diese Liste zu erzeugen, müssen wir die Polygonecken nicht
explizit sortieren, sondern können uns wieder zunutze machen, daß
die Polygone in Eckendarstellung (also bereits angular sortiert) gegeben
sind. Denn unabhängig von der Wahl der Anfangsecke p1
eines konvexen Polygons P = (p1, . . . , pm), besteht die Folge
der x-Koordinaten p1.x, . . . , pm.x aus maximal drei x-monotonen
im Worst case Ω(mn)
Schnittpolygone
im Worst case Ω(m + n)
Schnittpolygone

52 Das Plane-sweep-Paradigma
p1
linearer Zeitbedarf für
Schnitt konvexer Polygone
Teilfolgen. Diese können (zusammen mit den maximal drei Teilfolgen
des Polygons Q) mittels Mergesort in linearer Zeit zu einer
sortierten Folge verschmolzen werden.
Vertikalstruktur Während die Sweep line die Haltepunkte der Horizontalstruktur
von links nach rechts abarbeitet, müssen wir uns
in der Vertikalstruktur lediglich für jedes der beiden Polygone P
und Q die zwei aktiven Kanten merken, die momentan von der
Sweep line geschnitten werden. Die Aktualisierung dieser Kanten
von einem Streifen zum nächsten entspricht gerade einem Durchlauf
der Kantenfolgen – entweder im oder gegen den Uhrzeigersinn,
je nachdem, ob die Kante das Polygon von oben oder von
unten begrenzt.
Sweep line An jedem Haltepunkt der Sweep line bestimmen wir die
Schnittmenge (P ∩ Si) ∩ (Q ∩ Si) im aktuellen Streifen Si mit Hilfe
der momentan aktiven Kanten der beiden Polygone. Da die
„Bruchstücke“ nur Trapeze oder Dreiecke sein können, erfordert
dies nur einen konstanten Zeitbedarf. Im Falle eines Schnitts im
aktuellen Streifen müssen wir nur noch dafür sorgen, daß die Gesamtschnittmenge
entsprechend aktualisiert wird.
Zusammenfassend erhalten wir dann den folgenden Satz:
Satz 5.3 Der Schnitt zweier konvexer Polygone P = (p1, . . . , pm)
und Q = (q1, . . . qn) kann mit einem optimalen Zeitbedarf von Θ(m+n)
ermittelt werden, wobei im Falle eines (zweidimensionalen) Schnitts ein
Polygon in Ecken- oder Kantendarstellung zurückgeliefert wird. Der
Speicherbedarf ist dabei aus Θ(m + n).
Beweis: Die Initialisierung der Horizontalstruktur hat – wie oben beschrieben
– einen Zeitbedarf von O(m + n). Jedes der m + n Halteereignisse
der Sweep line kann in konstanter Zeit bearbeitet werden und ein
eventuelles Postprocessing (z. B. zum Erzeugen der Eckenfolge) erfordert
auch nur lineare Zeit.
Die Optimalität, d. h. eine untere Schranke von O(m + n), folgt aus dem
eingangs erwähnten Beispiel der beiden n-Ecke. Der lineare Speicherbedarf
folgt wieder aus den Eigenschaften der verwendeten Datenstrukturen.
✷
5.3 Anwendung »Schnitt von Halbebenen«
Den zeitoptimalen Algorithmus aus dem letzten Abschnitt zur Schnittberechnung
zweier konvexer Polygone können wir (leicht modifiziert)
auch dazu verwenden, für n Halbebenen H +
1 , . . . , H+ n im E2 deren
Schnittmenge
P = H +
1 ∩ · · · ∩ H+ n

5.3 Anwendung »Schnitt von Halbebenen« 53
zu bestimmen.
Hierzu erweitern wir zunächst den Polygonbegriff, um auch unbeschränkte,
geradlinig begrenzte Gebiete beschreiben zu können:
Definition 5.4 (Unbeschränktes Polygon)
Sei eine einfache polygonale Kette w = [p2 p3], . . . , [pn−2 pn−1] ⊂ E 2
gegeben (wobei auch die „leere Kette“ zugelassen ist), sowie zwei sich
nicht schneidende Halbstrahlen {p1 p2] und [pn−1 pn}, so daß w weder
von {p1 p2] noch von [pn−1 pn} geschnitten wird.
Dann nennt man dasjenige von
{p1 p2], [p2 p3], . . . , [pn−2 pn−1], [pn−1 pn}
berandete Gebiet (inklusive seines Randes), welches links von [p2 p3]
liegt, ein (einfaches) unbeschränktes Polygon, i. Z.
P = ({p1 p2], p2, . . . , pn−1, [pn−1 pn}) .
Die Begriffe »Knickwinkel«, »konvex«, »sternförmig« usw., sowie viele
der im letzten Kapitel gezeigten Eigenschaften können jetzt auch auf den
Fall unbeschränkter Polygone übertragen werden.
Somit ist es ist nicht schwer, den Algorithmus zum Schnitt konvexer Polygone
aus Abschnitt 5.2 so zu verallgemeinern, daß sowohl (konvexe)
beschränkte Polygone P und Q als auch unbeschränkte Polygone
P = ({p1 p2], p2, . . . , pm−1, [pm−1 pm}) und
Q = ({q1 q2], q2, . . . , qn−1, [qn−1 qn})
verarbeitet werden können. Ein konvexes unbeschränktes Polygon P
kann nämlich immer als Vereinigung eines konvexen beschränkten
Polygons Pb und eines konvexen unbeschränkten Polygons Pu der
Form {p1 p2], [p2 p3], [p3 p4} geschrieben werden.
Dann gilt offensichtlich
P ∩ Q = (Pb ∩ Qb) ∪ (Pb ∩ Qu) ∪ (Pu ∩ Qb) ∪ (Pu ∩ Qu)
und wir können die Teilprobleme separat lösen, nämlich
• die erste Schnittmenge mittels des Algorithmus aus Abschnitt 5.2
mit einem Zeitbedarf O(m + n),
• die zweite und dritte Schnittmenge durch Schnitt eines Polygons
der Komplexität O(m) bzw. O(n) mit drei Halbebenen mit einem
Zeitbedarf von O(m) bzw. O(n),
• die letzte Schnittmenge durch Schnitt von sechs Halbebenen in
konstanter Zeit.
Wir erhalten also das folgende Korollar zu Satz 5.3:
p1
p2
pn−1
pn
p3
unbeschränktes Polygon
Pu
Pb

54 Das Plane-sweep-Paradigma
linearer Zeitbedarf für
Schnitt konvexer
unbeschränkter Polygone
Divide-and-conquer-Ansatz
Zeitbedarf von Θ(n log n)
für den Halbebenenschnitt
untere Schranke mittels
Reduktion des
Sortierproblems
Korollar 5.5 Der Schnitt zweier konvexer unbeschränkter Polygone
P = ({p1 p2], p2, . . . , pm−1, [pm−1 pm}) und
Q = ({q1 q2], q2, . . . , qn−1, [qn−1 qn})
kann mit einem optimalen Zeitbedarf von Θ(m+n) sowie Θ(m+n) Speicher
ermittelt werden.
Zum Lösen des eigentlichen Problems, den Schnitt von n Halbebenen
zu bestimmen, führen wir dieses zurück auf die Schnittbestimmung für
konvexe unbeschränkte Polygone. Denn der Schnitt einer Menge von
Halbebenen ist entweder leer, niederdimensional (d. h. Punkt, Gerade,
Halbstrahl oder Segment), ein beschränktes oder ein unbeschränktes
konvexes Polygon.
Wir können also jetzt mittels eines Divide-and-conquer-Ansatzes die Menge
der n Halbebenen in zwei ungefähr gleichmächtige Mengen
H +
1 , . . . H+
⌊n/2⌋
und H+
⌊n/2⌋+1 , . . . , H+ n
zerlegen, deren Schnittmengen (rekursiv) berechnen und dann (sofern
beide Mengen nicht leer oder niederdimensional sind) deren gemeinsamen
Schnitt nach Korollar 5.5 in linearer Zeit berechnen.
Für den Gesamtzeitbedarf t(n) erhalten wir dann die Rekursionsgleichung
t(n) = 2 · t(n/2) + O(n) ,
die zu t(n) ∈ O(n log n) führt. Wir fassen dies in folgendem Satz zusammen:
Satz 5.6 Der Schnitt von n beliebigen Halbebenen im E 2 kann mit einem
optimalen Zeitbedarf von Θ(n log n) und O(n) Speicher bestimmt
werden.
Beweis: Wir müssen nur noch die (asymptotische) Worst-case-Optimalität
zeigen. Hierzu reduzieren wir wieder – ähnlich wie im Beweis zu
Satz 4.19 auf Seite 43 – das Sortierproblem auf unser Problem: Aus ei-
ner Menge von n Zahlen, x1, . . . , xn ∈ R, erzeugen wir eine Menge von
n Halbebenen, H +
1 , . . . , H+ n, so daß für xi
1. die zugehörige Begrenzungsgerade durch den Punkt (xi, x2 i ) verläuft,
2. die Begrenzungsgerade eine Tangente an die Funktion x ↦→ x 2 ist,
3. die Funktion x ↦→ x 2 in der positiven Halbebene H +
i verläuft.
Ein Durchlaufen der Schnittmenge dieser Halbebenen liefert uns dann
wieder eine Sortierung der Zahlen x1, . . . , xn. ✷

5.4 Schnitt von Liniensegmenten 55
Bemerkung 5.7 Die untere Schranke des obigen Satzes ist kein Widerspruch
zu Satz 4.18 auf Seite 42 (über die Bestimmung eines Kernpunktes
in linearer Zeit), denn bei der Bestimmung des Kerns eines Polygons
besitzt man mehr Information als hier in unserem Fall – nämlich die
Durchlaufordnung des Polygons.
Deshalb kann man den Kern eines Polygons, der sich ja auch als Schnitt
von Halbebenen darstellen läßt, in linearer Zeit ermitteln, obwohl im
allgemeinen Fall beliebiger Halbebenen ein Zeitbedarf von Ω(n log n)
erforderlich ist. ⊳
Bemerkung 5.8 Aus obigem Satz folgt sofort, daß jedes lineare Programm
1 im R 2 mit n Restriktionen mit einem Zeitbedarf von O(n log n)
gelöst werden kann.
Allerdings ist es bei einem linearen Programm im R 2 gar nicht nötig, alle
berandenden Strecken des erlaubten Bereiches zu kennen, um dieses zu
lösen! Megiddo [16] und Dyer [7] haben bereits 1983 bzw. 1984 gezeigt,
daß lineare Programme im R 2 und im R 3 in linearer Zeit gelöst werden
können. ⊳
5.4 Schnitt von Liniensegmenten
Gegeben n Liniensegmente s1 = [p1 q1], . . . , sn = [pn qn] ⊂ E 2 , dann
interessieren wir uns für die folgenden zwei Probleme:
1. Schneiden sich (mindestens) zwei der n Segmente?
2. Bestimme alle Schnittpunkte der n Segmente.
Offenbar lassen sich beide Probleme wieder mittels eines naiven Algorithmus
lösen, der schlicht alle Θ(n 2 ) Paare von Segmenten auf Schnitt
testet und ggf. deren Schnittpunkt ausgibt. Außerdem ist auch klar, daß
im Worst case tatsächlich Θ(n 2 ) Schnittpunkte existieren können, z. B.
beim Schnitt von n horizontalen mit n vertikalen Segmenten.
Oft wird diese maximal möglich Schnittpunktzahl jedoch gar nicht erreicht;
der naive Algorithmus besitzt jedoch trotzdem in jedem Fall eine
quadratische Laufzeit. Deshalb ist es sinnvoll, zur Beurteilung eines
Algorithmus, dessen Laufzeit nicht nur in Abhängigkeit der Eingabegröße
n, sondern auch in Abhängigkeit der Größe der Ausgabe k (bei unserem
zweiten Problem von oben also die Anzahl der Schnittpunkte) anzugeben.
Von einem „guten“ Algorithmus erwarten wir dann, daß er nur
dann eine hohe Laufzeit besitzt, wenn die Ausgabe ebenfalls umfangreich
ist.
linearer Zeitbedarf für
lineare Programme im R 2/3
im Worst case Θ(n 2 )
Schnittpunkte
Einen Algorithmus, dessen Laufzeit nicht nur von der Größe der Eingabe
n sondern auch von der Größe der Ausgabe k abhängt, nennen
wir output-sensitiv. Der naive Algorithmus von oben ist offenbar nicht output-sensitiv
1 Ein lineares Programm ist ein System von (linearen) Restriktionen Ax ≤ b, die die
erlaubten Werte für x einschränken, und einer Zielfunktion c T x, die minimiert werden
soll.

56 Das Plane-sweep-Paradigma
Abbildung 5.1
Die Sweep line definiert
eine Ordnung auf den
Segmenten
zunächst keine Sonderfälle
y
x1
s2
s4
s5
output-sensitiv, denn er benötigt immer Θ(n 2 ) Zeit – unabhängig von k.
Mittels einer Reduktion des ε-closeness-Problems auf das Segmentschnittproblem
können wir die folgenden unteren Schranken angeben:
Lemma 5.9 Für n Liniensegmente im E 2 hat der Test, ob sich (mindestens)
zwei Segmente schneiden, die Zeitkomplexität Ω(n log n). Alle
k Schnittpunkte zu bestimmen hat die Zeitkomplexität Ω(n log n + k).
Ein Beweis findet sich z. B. in [14, S. 65].
Im folgenden wollen wir jetzt also für die beiden obigen Probleme output-sensitive
Plane-sweep-Algorithmen angeben (basierend auf den Arbeiten
von Bentley und Ottmann [2] aus dem Jahre 1979), die für k ∈
o(n 2 ) eine geringere Laufzeit haben als der naive Ansatz. Um die Überlegungen
etwas zu vereinfachen, nehmen wir dabei an, daß sich nie
mehr als zwei Segmente im selben Punkt schneiden und daß sich keine
zwei Segmente überlappen.
5.4.1 Schnittest
Wir lassen die Sweep line wieder – wie üblich – von links nach rechts
über die Liniensegmente wandern. An jeder Stelle definiert dann die
Sweep line auf den Segmenten, die sie schneidet, eine Ordnung gemäß
den y-Koordinaten der Schnittpunkte. Beispielsweise ist in Abbildung
5.1 an der Stelle x1 die Ordnung s4 < s2 < s5.
Für zwei Segmente, die sich in einem Punkt (x, y) schneiden, gilt offensichtlich:
x2
s6
s1
s7
s3
x

5.4 Schnitt von Liniensegmenten 57
Beobachtung 5.10 Besitzen (genau) zwei Segmente in einem
Punkt (x, y) einen (echten) Schnittpunkt, dann gibt es immer eine
Stelle x − ε, an der sie in der durch die Sweep line definierten Ordnung
direkte Nachbarn sind. An der Stelle x kehrt sich ihre Ordnung dann
um.
In Abbildung 5.1 auf der vorherigen Seite trifft dies z. B. auf die beiden
Segmente s4 und s5 zu, für die unmittelbar links der Stelle x2 die Beziehung
s4 < s5 und unmittelbar rechts von x2 die Beziehung s5 < s4 gilt.
Um alle (echten) Schnittpunkte zu finden, genügt es also, an allen Stellen,
an denen sich die durch die Sweep line definierte Ordnung ändert,
jeweils die neu benachbarten Segmente auf Schnitt zu testen. Dies ist die
grobe Idee unseres Algorithmus.
Vertikalstruktur Um jeweils benachbarte Segmente auf einen gemeinsamen
Schnittpunkt testen zu können, speichern wir in der Vertikalstruktur
jeweils die Ordnung der momentan von der Sweep
line geschnittenen Segmente.
Idee: Testen direkter
Nachbarn
Die Haltepunkte der Sweep line sind dann all diejenigen Stellen,
an denen sich die Ordnung ändert, nämlich die x-Koordinaten der
folgenden Ereignisse: Drei Halteereignisse
1. Die Sweep line stößt auf den linken Endpunkt eines Liniensegments,
d. h. dieses Segment muß mit in die Vertikalstruktur
aufgenommen werden.
2. Die Sweep line stößt auf den rechten Endpunkt eines Liniensegments,
d. h. dieses Segment muß aus der Vertikalstruktur
entfernt werden.
3. Die Sweep line erreicht einen (echten) Schnittpunkt zweier
Segmente, an dem sich deren Ordnung umkehrt.
Das dritte Ereignis – das Erreichen eines Schnittpunkts – können
wir hier außer Acht lassen, da wir ja nur nach dem ersten Schnittpunkt
suchen und den Algorithmus sofort beenden können, wenn
wir ihn gefunden haben. D. h., ein Ereignis des dritten Typs werden
wir nie erreichen, da der Schnittpunkt schon (spätestens) beim
letzten Halt der Sweep line entdeckt worden sein muß.
Horizontalstruktur Um die Ereignisse, an denen wir die Vertikalstruktur
aktualisieren müssen, in der richtigen Reihenfolge abzuarbeiten,
genügt es wieder, die Endpunkte pi, qi aller Segmente nach
ihren x-Koordinaten zu sortieren.
Die Vertikalstruktur können wir wieder als balancierten Baum implementieren,
wobei beim „Vergleich“ zweier Segmente bez. ihrer
von der Sweep line definierten Ordnung natürlich immer die aktuelle
x-Koordinate der Sweep line mitherangezogen werden muß. Für die Horizontalstruktur
genügt wieder eine sortierte Liste der Endpunkte. Damit
jedoch auch senkrechte Liniensegmente und Segmente, die sich in
Endpunkten schneiden, richtig verarbeitet werden, müssen wir die Sortierreihenfolge
etwas modifizieren:
Modifizierte
Sortierreihenfolge

58 Das Plane-sweep-Paradigma
Zeitbedarf von Θ(n log n)
für den Segmentschnittest
Halteereignisse zur
Laufzeit
Erstes Sortierkriterium ist die x-Koordinate des betreffenden Punktes.
Zweites Sortierkriterium (bei Gleichheit der x-Koordinaten) ist der Typ
des Ereignisses: Einfügeereignisse (also linke Endpunkte) sollen
vor Löschereignissen (also rechten Endpunkten) behandelt werden.
Drittes Sortierkriterium (bei Gleichheit der beiden ersten Kriterien) ist
die y-Koordinate des Punktes. Die Punkte sollen dann nach aufsteigenden
y-Koordinaten sortiert werden.
Beim Einfügen von Punkten mit gleicher x- und y-Koordinate (wie z. B. die
Segmente s3 und s6 in Abbildung 5.1 auf Seite 56) muß zusätzlich noch
die Ordnung direkt rechts der Sweep line (also die angulare Ordnung der
Segmente) als viertes Kriterium herangezogen werden.
Bemerkung 5.11 Das dritte Sortierkriterium – also das Hinzuziehen der
y-Koordinate bei Gleichheit – ist ein oft verwendetes Hilfmittel um Sonderfälle
wie z. B. senkrechte Segmente, o. ä. zu behandeln. Diese Vorgehensweise
entspricht anschaulich einem infinitesimalen Kippen der
Sweep line und hat zur Folge, daß keine zwei verschiedenen Punkte zur
selben Zeit von der Sweep line getroffen werden können. ⊳
Die oben beschriebene Vorgehensweise wurde in Algorithmus 5.2 auf
der folgenden Seite umgesetzt und wir erhalten den folgenden Satz:
Satz 5.12 Man kann in optimaler Zeit Θ(n log n) und Θ(n) Speicher
n Liniensegmente in der Ebene auf Schnitt testen.
Beweis: Der Initialisierungsschritt kostet uns wieder O(n log n) Zeit.
Die while-Schleife wird maximal 2n-mal durchlaufen und jeder Durchlauf
hat einen Zeitbedarf von O(log n). Zusammen mit der unteren
Schranke aus Lemma 5.9 auf Seite 56 folgt dann der Zeitbedarf
von Θ(n log n). ✷
5.4.2 Bestimmen aller Schnittpunkte
Alle Schnittpunkte zu bestimmen ist ein schwierigeres Problem als nur
zu testen, ob mindestens ein Schnitt existiert. Denn jetzt müssen wir
auch das im letzten Abschnitt außer Acht gelassene dritte Halteereignis
auf der vorherigen Seite – das Erreichen des Schnittpunkts zweier Segmente
– berücksichtigen, damit die Vertikalstruktur korrekt aktualisiert
wird. Diese Ereignisse entstehen aber erst während der Algorithmus bereits
ausgeführt wird und sind zu Beginn noch gar nicht bekannt.
Aus diesem Grund müssen wir immer, wenn wir einen Schnittpunkt
gefunden haben, diesen als zusätzliches Halteereignis in unsere Horizontalstruktur
einsortieren und, wenn wir dann auf ein solches Ereignis
treffen, geeignet bearbeiten. Eine sortierte Liste der x-Koordinaten reicht
deshalb nun (aus Effizienzgründen) als Horizontalstruktur nicht mehr
aus.

5.4 Schnitt von Liniensegmenten 59
Algorithmus 5.2 Schnittest für Liniensegmente
TESTINTERSECTION(s1, . . . , sn)
Input: n Liniensegmente s1 = [p1 q1], . . . , sn = [pn qn] ⊂ E 2
{Initialisierungsschritt}
1 Sortiere die Punkte p1, q1, . . . , pn, qn gemäß den vier Sortierkriterien
und füge sie in die Liste HS ein
2 VS ← leerer AVL-Baum
3 schnitt ← false
{Sweep}
4 while HS �= ∅ ∧ ¬schnitt do
5 Punkt ← NächsterPunkt(HS)
6 if Punkt = linker Endpunkt (von Segment s) then
7 Füge s in VS ein
8 Vorg ← der Vorgänger von s in VS
9 Nachf ← der Nachfolger von s in VS
10 if (s schneidet Vorg) ∨ (s schneidet Nachf) then
11 schnitt ← true
12 end if
13 else if Punkt = rechter Endpunkt (von Segment s) then
14 Vorg ← der Vorgänger von s in VS
15 Nachf ← der Nachfolger von s in VS
16 if Vorg schneidet Nachf then
17 schnitt ← true
18 end if
19 Entferne s aus VS
20 end if
21 end while
Output: Es gibt genau dann (mindestens) einen Schnittpunkt,
wenn schnitt gleich true ist
Wir verwenden stattdessen als Horizontalstruktur eine Prioritätswarteschlange
(engl. priority queue), z. B. einen Fibonacci heap, der u. a. das
Einfügen eines Elements und das Ermitteln und Entfernen des minimalen
Elements in O(log n) Zeit bewerkstelligt und das Reduzieren eines
Schlüsselwerts sogar mit konstantem Zeitbedarf. In unserem speziellen
Fall wird diese letzte Eigenschaft allerdings gar nicht benötigt und wir
können auch einen AVL-Baum zur Verwaltung der Horizontalstruktur
verwenden.
Außerdem müssen wir noch folgende Punkte berücksichtigen:
• Es kann passieren, daß ein Schnittpunkt mehrere Male entdeckt
wird. Trotzdem darf er natürlich nur einmal in die Horizontalstruktur
eingefügt werden.
Es kann sogar passieren, daß ein Schnittpunkt entdeckt wird, nachdem
ihn die Sweep line schon passiert hat. Zum Beispiel wird in
Abbildung 5.1 auf Seite 56 der Schnittpunkt zwischen den Segmenten
s4 und s5 erneut entdeckt, wenn der rechte Endpunkt
priority queue als
Horizontalstruktur

60 Das Plane-sweep-Paradigma
Zeitbedarf von
O((n + k) log n) für die
Schnittpunktbestimmung
von s7 abgearbeitet wird. In so einem Fall – wenn also der Schnittpunkt
links der aktuellen Sweep line liegt – darf der Punkt überhaupt
nicht mehr in die Horizontalstruktur eingefügt werden.
• Bei dem zweiten Sortierkriterium auf Seite 58 erhalten wir einen
weiteren Ereignistyp (»Schnittpunktereignis«), der nach den Einfügeereignissen
und vor den Löschereignissen abgearbeitet werden
muß.
Unter Beachtung der oben aufgeführten Besonderheiten kann Algorithmus
5.2 nun daraufhin angepaßt werden, alle Schnittpunkte zu finden.
Hierzu müssen im wesentlichen die folgenden Punkte geändert werden:
• Die Horizontalstruktur wird durch eine Prioritätswarteschlange
ersetzt.
• Die Variable schnitt fällt weg, da jetzt immer die ganze Ebene abgearbeitet
wird.
• Es kommt ein neues Schnittpunktereignis hinzu, an dem
– die Koordinaten des Schnittpunktes ausgegeben werden,
– die beiden beteiligten Segmente ihre Ordnung tauschen,
– das neue untere Segment mit seinem Vorgänger und das neue
obere Segment mit seinem Nachfolger in der Vertikalstruktur
auf Schnitt getestet wird.
Somit erhalten wir den folgenden Satz für unseren output-sensitiven
Plane-sweep-Algorithmus:
Satz 5.13 Die k Schnittpunkte von n Liniensegmenten in der Ebene können
mit einem Zeitaufwand von O((n + k) log n) und einem Speicherbedarf
von O(n + k) bestimmt werden.
Beweis: Insgesamt gibt es O(n+k) Haltepunkte für die Sweep line, d. h.
die while-Schleife wird O(n + k)-mal durchlaufen. Da keines der Ereignisse
mehrfach in der Horizontalstruktur gespeichert wird, kann jeder
Zugriff darauf in O(log(n + k)) = O(log(n 2 )) = O(log n) Zeit erfolgen.
Außerdem erfordert jeder Zugriff auf die Vertikalstruktur ebenfalls nur
logarithmischen Aufwand.
Insgesamt erhalten wir also einen Zeitbedarf von O((n + k) log n)
und einen Speicherbedarf (hauptsächlich für die Horizontalstruktur)
von O(n + k). ✷
Die etwas grobe Analyse des Speicherbedarfs von O(n+k) ist hierbei ein
bißchen unbefriedigend, da k ja bekanntermaßen aus Ω(n 2 ) sein kann.
Mit einer feineren Analyse kann man zeigen [20], daß die Größe der Horizontalstruktur
(und damit der Gesamtspeicherbedarf) tatsächlich nur
aus O(n(log n) 2 ) ist. Auf der anderen Seite kann man aber auch Worstcase-Beispiele
angeben [20], für die an mindestens einer Position der

5.5 Anwendung »Test auf Einfachheit« 61
Sweep line die Größe der Horizontalstruktur aus Ω(n log n) ist (siehe
z. B. auch [14, S. 72]).
Mittels eines einfachen Tricks läßt sich allerdings der Speicherbedarf sogar
auf O(n) drücken: Wir merken uns in der Horizontalstruktur nur Trick zur Speicherersparnis
Schnittpunkte von solchen Segmenten, die auch aktuell benachbart sind,
alle anderen entfernen wir wieder aus der Horizontalstruktur, sobald
die beteiligten Segmente nicht mehr benachbart sind. Denn aufgrund
der Beobachtung 5.10 auf Seite 57 wissen wir, daß bevor sich die Segmente
schneiden, diese wieder benachbart sein müssen.
Beispielsweise würden wir in Abbildung 5.1 auf Seite 56, wenn wir den
linken Endpunkt von Segment s2 bearbeiten, den Schnittpunkt von s4
und s5 wieder aus der Horizontalstruktur löschen und erst bei Erreichen
des rechten Endpunkts von s2 wieder einfügen. Auf diese Weise
bleibt die Zahl der in der Horizontalstruktur gespeicherten Schnittpunktereignisse
immer aus O(n) und wir erhalten folgende Verbesserung von
Satz 5.13:
Satz 5.14 Die k Schnittpunkte von n Liniensegmenten in der Ebene können
mit einem Zeitaufwand von O((n + k) log n) und einem Speicherbedarf
von O(n) bestimmt werden.
Bemerkung 5.15 Die einzigen beiden Einschränkungen an die n Liniensegmente,
die wir gemacht hatten, waren, daß sich nie mehr als zwei
Segmente in demselben Punkt schneiden und daß sich keine zwei Segmente
überlappen.
Im ersten Fall würde dann nämlich Beobachtung 5.10 auf Seite 57 nicht
mehr zutreffen. Durch eine etwas genauere Analyse dieser Problematik
ist es jedoch trotzdem – ohne allzu großen Mehraufwand – möglich,
auch solche Fälle zuzulassen. Dies wird beispielsweise in [5, S. 26] beschrieben.
Auch die zweite Einschränkung – sich überlappende Segmente – kann
durch eine verfeinerte Analyse und geeignete Fallunterscheidungen vermieden
werden und stellt kein schwerwiegendes Problem dar. ⊳
5.5 Anwendung »Test auf Einfachheit«
Durch eine leichte Modifikation können wir Algorithmus 5.2 auf Seite 59
dazu verwenden, die Einfachheit einer polygonalen Kette zu testen: Wir
müssen nur dafür sorgen, daß beim Schnittest zweier Strecken, die sich
in ihren Endpunkten berührenden adjazenten Kanten nicht berücksichtigt
werden. Wir erhalten damit folgendes Korollar zu Satz 5.12 auf Seite
58:
Korollar 5.16 Eine aus n Segmenten bestehende polygonale Kette (in
der Ebene) kann mit einem Zeitaufwand von O(n log n) auf ihre Einfachheit
hin getestet werden.
linearer Speicherbedarf zur
Schnittpunktbestimmung
Zeitbedarf von O(n log n)
für den Test auf Einfachheit

62 Das Plane-sweep-Paradigma
Abbildung 5.2
Der Graph links ist ein
PSLG, die beiden anderen
nicht
planar subdivision
Planar straight line graph
vertices, edges und faces
5.6 Anwendung »Überlagerung von PSLGs«
und »Arrangement-Berechnung«
Planar straight line graphs können verwendet werden, um den Spezialfall
einer Unterteilung der Ebene (engl. planar subdivision), bei dem Gebiete
ausschließlich durch Liniensegmente begrenzt werden, zu modellieren
und sind ein wichtiges Hilfsmittel in der Algorithmischen Geometrie.
Definition 5.17 (Planar straight line graph)
Eine kreuzungsfreie Realisierung (in die Ebene) eines ungerichteten zusammenhängenden
Graphen G = (V, E, γ) heißt Planar straight line
graph (kurz: PSLG), wenn
1. jede Kante bei der geometrischen Realisierung auf ein Liniensegment
abgebildet wird und
2. jede Ecke v ∈ V einen Grad g(v) ≥ 2 besitzt.
Abbildung 5.2 zeigt links einen PSLG, der mittlere Graph verletzt die
PSLG-Eigenschaft, weil er nicht zusammenhängend ist und der rechte,
weil er Knoten mit einem Grad kleiner als zwei besitzt.
Die Knoten (oder Ecken) eines PSLGs werden in der englischsprachigen
Literatur auch als vertices, die Kanten als edges und die Flächen als faces
bezeichnet.
Bemerkung 5.18 Manchmal verzichtet man zur Definition des PSLGs
auch auf den Zusammenhang des Graphen oder auf die Forderung eines
Eckengrades ≥ 2. Wir wollen uns aber auf diesen einfacheren Fall
beschränken. ⊳
Beobachtung 5.19 Ein PSLG zerlegt die Ebene in eine Menge aneinander
grenzender Polygone, deren Vereinigung jedoch – wie Abbildung
5.2 zeigt – im allgemeinen kein einfaches Polygon ergibt, weil die
Polygone auch „über Eck“ benachbart sein können.
Die folgende „Beobachtung“ ist eigentlich eine Folgerung aus der Eulerschen
Formel, die wir allerdings erst in Kapitel 7 zeigen werden:

5.6 Anwendung »Überlagerung von PSLGs« und »Arrangement-Berechnung« 63
e3
v2
v1
e4
f1
e1
v3
e2
f2
v4
Koord. IncEdge
v1 (x1, y1) e3,2
v2 (x2, y2) e4,1
v3 (x3, y3) e4,2
v4 (x4, y4) e2,1
e3,1
f1
f2
v2
v1
e3,2
e1,2
f1
e4,1
e4,2
e1,1
e2,2
BoundEdge
e2,2
e1,1
Origin Twin IncFace Prev Next
e1,1 v1 e1,2 f2 e3,1 e2,1
e1,2 v4 e1,1 f1 e2,2 e3,2
e2,1 v4 e2,2 f2 e1,1 e4,2
e2,2 v3 e2,1 f1 e4,1 e1,2
e3,1 v2 e3,2 f2 e4,2 e1,1
e3,2 v1 e3,1 f1 e1,2 e4,1
e4,1 v2 e4,2 f1 e3,2 e2,2
e4,2 v3 e4,1 f2 e2,1 e3,1
v3
f2
v4
e2,1
Beobachtung 5.20 Sei n die Anzahl der Ecken eines PSLGs. Dann ist
die Gesamtkomplexität des PSLGs, d. h. die Summe der Eckenzahlen,
Kantenzahlen und Flächenzahlen, ebenfalls nur aus O(n).
Abbildung 5.3
Darstellung eines PSLGs
als Doubly connected edge
list
Zur Repräsentation eines PSLGs verwenden wir die Doubly connected
edge list (kurz: DCEL), die eine speicherplatzoptimale und auch zeit- Doubly connected edge list
optimale Möglichkeit darstellt (z. B. beim Zugriff auf einzelne Kanten,
Flächen usw.), einen PSLG zu speichern:
Die Doubly connected edge list besteht aus drei Tabellen, je eine für die Tabellen für die Ecken,
Kanten und Flächen
Ecken, Kanten und Flächen des PSLGs. Zusätzlich kann in den Tabellen
natürlich auch noch weitere (Nutz-)Information zu den Objekten
abgespeichert werden, beispielsweise Namen für die Kanten oder die
Flächen, z. B. wenn es sich bei dem PSLG um die Repräsentation einer
Straßen- oder einer Landkarte handelt.
Um aus dem PSLG eine Doubly connected edge list zu erzeugen, ersetzen
wir zunächst jede Kante durch ein Paar entgegengesetzt gerichteter
sog. Halbkanten (siehe hierzu Abbildung 5.3). Die beiden entgegengesetzt
gerichteten Halbkanten, die wir aus einer Kante des PSLGs er-

64 Das Plane-sweep-Paradigma
zeugen, nennen wir Zwillinge. Jetzt können wir die drei Tabellen für
die Ecken, Flächen und Halbkanten des PSLGs definieren (siehe Abbildung
5.3 auf der vorhergehenden Seite):
Ecken Für jede Ecke v speichern wir ihre Koordinaten (x, y) und einen
Zeiger auf eine beliebige Halbkante IncEdge(v), die in v startet.
Flächen Für jede Fläche f speichern wir einen Zeiger auf eine beliebige
Halbkante BoundEdge(f) auf dem Rand von f, so daß f links dieser
Halbkante liegt.
Halbkanten Für jede Halbkante e speichern wir einen Zeiger auf ihre
Startecke Origin(e), einen Zeiger auf ihre Zwillingskante Twin(e)
und einen Zeiger auf diejenige Fläche IncFace(e), die links von ihr
liegt. Die Endecke der Halbkante müssen wir nicht speichern, da
sie die Startecke der Zwillingskante ist.
Zusätzlich speichern wir noch jeweils einen Zeiger auf die eindeutig
bestimmte Halbkante Prev(e), die in der Startecke Origin(e)
endet und ebenfalls die Fläche IncFace(e) berandet (die Vorgängerkante
von e) und auf die Halbkante Next(e), die in der Endecke
von e startet und ebenfalls IncFace(e) berandet (die Nachfolgerkante
von e).
Durch diese Art der Speicherung können wir auf effiziente Art und Weise
(nämlich immer mit einer Zeitkomplexität, die linear in der Größe der
Ausgabe ist)
• zu einer Ecke alle inzidenten Kanten bestimmen,
• zu einer Fläche alle berandenden Kanten ermitteln.
In [5, S. 31] wird außerdem eine nur geringfügig kompliziertere DCEL
beschrieben, mit der auch unzusammenhängende PSLGs mit Eckengraden
≥ 1 (anstelle von 2) repräsentiert werden können.
Den in Abschnitt 5.4.2 vorgestellten Algorithmus zum Bestimmen aller
Schnittpunkte von n Liniensegmenten können wir nun zu einem Algorithmus
modifizieren, der die Überlagerung zweier gegebener PSLGs
berechnet. Hierzu wenden wir den Schnittalgorithmus auf die Menge
der Liniensegmente in den beiden PSLGs an. Zusätzlich zur Bestimmung
der Schnittpunkte bauen wir während des Sweeps eine neue
DCEL auf, die jeweils den Schnitt-PSLG links der aktuellen Sweep line
beschreibt. Wir beschränken uns dabei auf die Ecken- und Kantentabellen;
das Erzeugen der Flächentabelle schieben wir zunächst auf.
Zum Aufbau der DCEL gehen wir folgendermaßen vor: Wir kopieren
vor Beginn des Sweeps die Ecken- und Kantentabellen der beiden
Ausgangs-DCELs in jeweils eine gemeinsame neue Tabelle (die natürlich
noch keine gültige DCEL darstellt) und modifizieren diese dann bei
jedem Schnittpunktereignis (zwischen Kanten aus verschiedenen DCELs)
in geeigneter Weise.

5.6 Anwendung »Überlagerung von PSLGs« und »Arrangement-Berechnung« 65
Vereinfacht ausgedrückt müssen bei jedem solchen Ereignis die zwei beteiligten
Kanten (bzw. die vier beteiligten Halbkanten) durch vier neue
Kanten (bzw. durch acht neue Halbkanten) ersetzt werden (für Einzelheiten
siehe [5, S. 33]). Insgesamt wird hierfür (größenordnungsmäßig)
nicht mehr Zeit benötigt als für das Erzeugen der Schnittpunkte.
Nachdem die Ecken- und Kantentabellen der neuen DCEL während des
Sweeps korrekt erzeugt wurden, müssen nun noch die Flächentabelle
sowie die korrekten IncFace-Einträge der Kantentabelle generiert werden.
Wieder etwas vereinfacht ausgedrückt geschieht dies, indem wir
die Halbkanten der neuen DCEL – beginnend bei einer beliebigen, noch
nicht besuchten Halbkante – „kreisförmig“ durchlaufen, d. h. zu einer
Halbkante immer ihren Nachfolger besuchen, bis wir irgendwann wieder
bei derjenigen Halbkante ankommen, bei der wir gestartet sind. Ein
Kreis gegen den Uhrzeigersinn entspricht dann einer der beschränkten
Flächen, ein Kreis im Uhrzeigersinn der unbeschränkten Fläche. Der
Zeitaufwand hierfür ist wieder von derselben Größenordnung wie die
Komplexität der DCEL.
Insgesamt erhalten wir dann folgendes Korollar zu Satz 5.14:
Korollar 5.21 Die Überlagerung zweier PSLGs der Komplexitäten m
und n kann mit einem Zeitaufwand von O((m + n + k) log(m + n))
und einem Speicherbedarf von O(m + n + k) bestimmt werden, wobei k
die Komplexität der Überlagerung darstellt.
Da wir zu einem gegebenen Polygon P = (p1, . . . , pm) in linearer Zeit
einen PSLG erzeugen können, der genau dieses Polygon repräsentiert,
folgt hieraus sofort ein weiteres Korollar:
Korollar 5.22 Für zwei Polygone P = (p1, . . . , pm) und Q =
(q1, . . . , qn) kann mit einem Zeitaufwand von O((m+n+k) log(m+n))
und einem Speicherbedarf von O(m+n+k) ein PSLG bestimmt werden,
der den Schnitt der beiden Polygone repräsentiert. Hierbei stellt k die
Komplexität des Schnitts dar.
Außerdem können wir mit derselben Vorgehensweise für eine Menge
von n Liniensegmenten nicht nur deren Schnittpunkte berechnen, sondern
auch das sog. Arrangement der Segmente, d. h. denjenigen PSLG, Arrangement
der die gesamte Menge sich schneidender Segmente repräsentiert:
Korollar 5.23 Für eine Menge von n Liniensegmenten in der Ebene
kann deren Arrangement mit einem Zeitbedarf von O((n + k) log n) bestimmt
werden.
O((m + n + k) log(m + n))
Zeitbedarf für den Schnitt
allgemeiner Polygone
Zeitbedarf von
O((n + k) log n) zur
Arrangement-Berechnung

Konvexe Hüllen ebener
Punktmengen
Die konvexe Hülle einer Menge A ⊆ R d (siehe Definition 4.5 auf Seite
34) ist uns ja schon im Abschnitt 1.2 bei den Problemen »Einzäunen
von Apfelbäumen« und »Christos Reichstag« (für d = 2, 3) begegnet. In
diesem Kapitel wollen wir den Spezialfall betrachten, die konvexe Hülle
einer endlichen Punktmenge A in der Ebene zu bestimmen.
Wie wir schon in Abschnitt 4.1 gesehen haben, ist die konvexe Hülle einer
ebenen n-elementigen Punktmenge (die nicht alle auf einer Geraden
liegen) ein konvexes Polygon mit maximal n Ecken. Um dieses Polygon
soll es also im folgenden gehen.
6.1 Eigenschaften und untere Schranke
Offensichtlich scheint der Rand der konvexen Hülle CH(A) der kürzeste
geschlossene Weg zu sein, der die Punktmenge A umschließt. Folgendes
Lemma bringt dies zum Ausdruck:
Lemma 6.1 Sei w ein einfacher, geschlossener Weg, der die konvexe
Hülle CH(A) der endlichen Punktmenge A ⊂ E 2 umschließt, d. h.
CH(A) liegt in dem von w induzierten beschränkten Gebiet (welches
nach dem Jordanschen Kurvensatzes eindeutig bestimmt ist). Dann ist
der Rand von CH(A) höchstens so lang wie der Weg w.
Beweis: O. B. d. A. sei CH(A) ein konvexes Polygon mit mindestens drei
Ecken, d. h. CH(A) = (p1, . . . , pn). Von jedem Punkt pi ziehen wir die
Winkelhalbierende hi der beiden inzidenten Polygonkanten nach außen.
Diese schneidet den umschließenden Weg w mindestens einmal
(siehe Abbildung 6.1 auf der nächsten Seite). Wir durchlaufen nun w
(von einem beliebigen Punkt aus startend) gegen den Uhrzeigersinn und
bezeichnen den beim Durchlauf jeweils ersten Schnitt von w mit der Winkelhalbierenden
hi mit wi.
Aufgrund der Konvexität des Polygons CH(A) schließt die Winkelhalbierende
hi mit den beiden zu pi inzidenten Kanten einen Winkel ≥
6
Rand von CH(A) ist der
kürzeste Weg um A

68 Konvexe Hüllen ebener Punktmengen
Abbildung 6.1
Der Abstand |pi pi+1| ist
immer kleiner oder gleich
dem Abstand |wi wi+1|
a
w
W
w ′
untere Schranke von
Ω(n log n) für konv. Hülle
b
wi
pi
CH(A)
p1
w1
pi+1
pn
wi+1
π/2 ein. Somit ist für zwei aufeinanderfolgende Winkelhalbierende hi
und hi+1 das Punktepaar (pi, pi+1) unter allen Paaren aus der Menge
hi × hi+1 dasjenige mit dem kleinsten Abstand. Deshalb gilt
|pi pi+1| ≤ |wi wi+1| ≤ |wi,i+1| ,
wobei wi,i+1 den Teilweg von w zwischen den Punkten wi und wi+1
bezeichnet. Insgesamt kann deshalb die Gesamtlänge von ∂CH(A) nicht
größer als die Länge des Weges w sein. ✷
Erst Lemma 6.1 rechtfertigt z. B. bei unserem Problem »Einzäunen von
Apfelbäumen« die Verwendung der konvexen Hülle, um einen Zaun
minimaler Länge zu erhalten.
Obiges Lemma läßt sich sowohl auf nicht-einfache Wege w, die CH(A) in
einer ihrer Schlingen enthalten, verallgemeinern als auch auf beliebige
konvexe Mengen A anstelle von CH(A). Mittels dieser allgemeineren
Aussage erhalten wir dann folgendes nützliches Korollar:
Korollar 6.2 Ist w ein einfacher „konvexer“ Weg von a nach b, d. h. zusammen
mit dem Segment [a b] umschließt w eine konvexe Menge W,
und ist w ′ ein beliebiger anderer Weg von a nach b (auf derselben Seite
von [a b] wie w und außerhalb von W ◦ ), dann ist w ′ mindestens so lang
wie w.
Um eine untere Schranke für die Laufzeit eines Algorithmus zur Bestimmung
der konvexen Hülle zu erhalten, können wir wieder – exakt wie
im Beweis zu Satz 4.19 auf Seite 43 – das Sortierproblem auf unser Problem
reduzieren und erhalten dann folgenden Satz:
Satz 6.3 Die Konstruktion der konvexen Hülle von n Punkten in der
Ebene besitzt einen Zeitbedarf von Ω(n log n).
wn

6.2 Inkrementelle Konstruktion 69
In den folgenden Abschnitten werden wir verschiedene Algorithmen
zur Bestimmung der konvexen Hülle vorstellen, einige davon mit einer
optimalen Laufzeit von Θ(n log n), andere output-sensitiv, d. h. mit einer
Laufzeit, die von der Eckenzahl der konvexen Hülle abhängt. Hierbei
sei {p1, . . . , pn} mit n ≥ 3 jeweils die Punktmenge, deren konvexe
Hülle bestimmt werden soll (o. B. d. A. sollen nicht alle Punkte auf einer
Geraden liegen1 ), und (pi1 , . . . , pim ) mit m ≤ n das gesuchte Polygon.
6.2 Inkrementelle Konstruktion
Ein Verfahren zur Konstruktion einer Struktur für eine Menge von Objekten
(hier: die konvexe Hülle einer Menge von Punkten) heißt inkrementell,
wenn die Objekte eines nach dem anderen hinzugefügt werden inkrementelle Verfahren
und dabei die Struktur jedesmal aktualisiert wird.
Wir starten also mit der konvexen Hülle für die Punktmenge {p1, p2, p3}
– also einem Dreieck – und fügen die restlichen Punkte einen nach
dem anderen hinzu, wobei wir die konvexe Hülle jedesmal aktualisieren
müssen. Für den neu hinzukommenden Punkt pi gibt es hierbei
zwei Möglichkeiten:
1. pi liegt innerhalb des Polygons CH({p1, . . . , pi−1}):
In diesem Fall ist nichts zu tun, da sich die konvexe Hülle durch
Hinzunahme des Punktes pi nicht ändert, und es gilt
CH({p1, . . . , pi}) = CH({p1, . . . , pi−1}) .
2. pi liegt außerhalb (oder auch auf dem Rand) des Polyg-
ons CH({p1, . . . , pi−1}):
In diesem Fall kommt der Punkt pi zur Eckenfolge der konvexen
Hülle hinzu, und zwar (bei Orientierung gegen den Uhrzeigersinn)
nach dem Punkt pl und vor dem Punkt pr. Die Punkte pl
und pr sind hierbei jeweils die (zu pi nächstgelegenen) Berührpunkte
der beiden Tangenten durch den Punkt pi an das Polygon
CH({p1, . . . , pi−1}). Die in der Eckenfolge zwischen pl und pr
liegenden Punkte werden dabei aus der Eckenfolge der konvexen
Hülle entfernt.
Somit leistet Algorithmus 6.1 auf der nächsten Seite das Gewünschte.
Einige Schritte des Algorithmus bedürfen allerdings noch der genaueren
Erläuterung:
Schritt 3: Der Point-in-polygon-Test kann (nach Satz 4.10) mittels der
angularen Ordnung der Polygonecken mit einem Zeitbedarf
von O(log n) beantwortet werden. Da sich unser Polygon während
der Ausführung des Algorithmus dynamisch ändert (in
1 Dieser Fall läßt sich immer mit linearem Prüfaufwand ausschließen und gesondert
behandeln.
Zwei Fälle für den neuen
Punkt pi
pi
pr
pl
pi

70 Konvexe Hüllen ebener Punktmengen
x
pr
pl
pi
Algorithmus 6.1 Inkrementelle Bestimmung der konvexen Hülle
CONVEXHULLINCREMENTAL(p1, . . . , pn)
Input: n Punkte p1, . . . , pn ∈ E 2
1 CH ← (p1, p2, p3) bzw. CH ← (p1, p3, p2) {die drei Punkte sollen
gegen den Uhrzeigersinn orientiert sein}
2 for i ← 4, . . . , n do
3 if pi liegt nicht im Polygon CH then
4 Bestimme die beiden Berührecken pl bzw. pr der Tangenten
durch pi an das Polygon CH
5 Entferne alle Punkte zwischen pl und pr aus der Eckenliste CH
6 Füge den Punkt pi zwischen pl und pr in die Eckenliste CH ein
7 end if
8 end for
Output: CH ist die konvexe Hülle der Punkte p1, . . . , pn
Schritt 5 werden evtl. Eckpunkte entfernt und in Schritt 6 wird
ein Punkt hinzugefügt), sollte die Eckenfolge allerdings nicht in
einem Feld sondern besser mittels eines balancierten Suchbaums
verwaltet werden.
Schritt 4: Der Sektor des Polygons, in dem sich der Punkt pi befindet, ist
ja schon aus Schritt 3 bekannt. Somit können die Punkte pl und pr
durch einen Durchlauf des Polygons gegen bzw. im Uhrzeigersinn
bestimmt werden. Beispielsweise wird zur Bestimmung von pr
das Polygon – beginnend bei der linken Sektorgrenze – unter Verwendung
der ccw-Funktion aus Abschnitt 3.2.2 solange gegen den
Uhrzeigersinn durchlaufen, wie der nächste Eckpunkt echt rechts
des Strahls von pi zum aktuellen Eckpunkt liegt.
Bemerkung 6.4 Realisieren wir Schritt 4 des Algorithmus wie oben beschrieben,
erhalten wir für den Fall, daß kollineare Punkte auf dem Rand
der konvexen Hülle liegen, eine Polygonrepräsentation, die alle diese
Punkte auch als Ecken besitzt.
Ist dies nicht gewünscht, so müssen wir den Polygondurchlauf im
Schritt 4 so modifizieren, daß wir bei der Bestimmung der Berührpunkte
pl und pr auch dann weiterlaufen, wenn der nächste Eckpunkt
auf dem Strahl von pi zum aktuellen Eckpunkt liegt. Auf diese Weise
enthält die Eckenfolge der konvexen Hülle keine kollinearen Ecken
mehr. ⊳
Wie ist jetzt also die Gesamtlaufzeit von Algorithmus 6.1? Die if-Abfrage
in Schritt 3 kostet – wie oben gesehen – O(log n) Zeit, das Bestimmen
der beiden Punkte pl und pr kostet O(n) Zeit und das Löschen der zwischen
pl und pr liegenden Punkte sowie das Einfügen von pi lassen
sich ebenfalls mit linearem bzw. konstantem Zeitaufwand erledigen. Jeder
Schleifendurchlauf hat also einen Zeitbedarf von O(n). Da die for-

6.3 Jarvis’s march 71
Schleife insgesamt (n − 3)-mal durchlaufen wird, erhalten wir als Gesamtzeitbedarf
O(n 2 ). Laufzeit von O(n 2 )
Diese Abschätzung ist jedoch zu grob! Es ist zwar richtig, daß uns in Feinere Abschätzung
einem einzigen Schleifendurchlauf die Schritte 4 und 5 Ω(n) Zeit kosten
können, nämlich dann, wenn fast alle Punkte der konvexen Hülle innerhalb
des Dreiecks liegen, das von pi, pl und pr gebildet wird. Dies kann
jedoch nicht beliebig oft passieren. Denn jeder Punkt, der in Schritt 4
passiert und dann in Schritt 5 gelöscht wird, verschwindet aus der konvexen
Hülle und kann in späteren Schleifendurchläufen nie wieder in
Erscheinung treten. Summiert über alle Schleifendurchläufe erhalten wir
also für die Schritte 4 und 5 trotzdem nur eine Laufzeit von O(n).
Aufgrund des logarithmischen Zeitbedarfs für Schritt 3 erhalten wir damit
also eine Gesamtlaufzeit von O(n log n). Dies fassen wir in folgendem
Satz zusammen:
Satz 6.5 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 kann deren
konvexe Hülle mittels des inkrementellen Algorithmus bei linearem
Speicherbedarf mit einem Zeitbedarf von Θ(n log n) bestimmt werden.
Bemerkung 6.6 Die Bestimmung der beiden Berührecken pl und pr
kann sogar in logarithmischer Zeit O(log n) erfolgen, da die Folge
ccw(pi, p1, p2), ccw(pi, p2, p3), . . . , ccw(pi, pi−1, p1)
aufgrund der Konvexität des Polygons (p1, . . . , pi−1) genau zwei Vorzeichenwechsel
besitzt (sofern pi nicht gerade auf dem Rand des Polygons
liegt). Diese Vorzeichenwechsel entsprechen genau den Punkten pl
und pr und können mittels binärer Suche ermittelt werden.
Für unseren Algorithmus ergibt dies jedoch keinen Gewinn (im Gegenteil,
über alle Schleifendurchläufe summiert werden sogar mehr Ecken
betrachtet), da jede Ecke, die zwischen pl und pr liegt, sowieso in
Schritt 5 entfernt werden muß. ⊳
6.3 Jarvis’s march
Die Beobachtung, die dem Algorithmus von Jarvis zugrunde liegt, ist,
daß ein Segment [pi pj], welches die Punktmenge A = {p1, . . . , pn} separiert
(d. h. sowohl links als auch rechts von [pi pj] liegen Punkte aus A),
keine Kante der konvexen Hülle sein kann. Folglich genügt es, mit einem
Punkt pi1 , der sicher ein Eckpunkt der konvexen Hülle ist, zu starten
und dann nach einem weiteren Punkt pi2 zu suchen, so daß alle
übrigen Punkte links des Segments [pi1 pi2 ] liegen. Dieser Schritt wird
dann iteriert, bis man wieder beim Startpunkt pi1 angelangt ist. Aufgrund
dieser Vorgehensweise erhielt der Algorithmus auch seinen Namen:
Man startet an einer Stelle der konvexen Hülle und marschiert
(engl. to march) dann um alle Punkte herum, bis man wieder am Ausgangspunkt
angelangt ist.
Trick: Summation über alle
Schleifendurchläufe
Zeitbedarf von Θ(n log n)
für konvexe Hülle
Bestimmung von pl und pr
in O(log n)
pi 1
pi 4
pi 2
pi 3

72 Konvexe Hüllen ebener Punktmengen
Jarvis’s march ist outputsensitiv
Zeitbedarf von Θ(mn) für
Jarvis’s march
Algorithmus 6.2 Jarvis’s march zur Bestimmung der konvexen Hülle
CONVEXHULLJARVIS(p1, . . . , pn)
Input: n Punkte p1, . . . , pn ∈ E 2
1 Bestimme den Punkt pi1 als den Punkt mit minimaler y-Koordinate
(bei Punkten gleicher y-Koordinate, denjenigen mit minimaler
x-Koordinate)
2 j ← 1
3 repeat
{j zählt die Eckpunkte pij der konvexen Hülle}
4 j ← j + 1
5 rechts ← 1
6 for k ← 2, . . . , n do
7 if (pk liegt echt rechts von [pij−1 prechts]) oder (pk
pij−1
liegt auf
prechts und näher an pij−1 als prechts)
8
then
rechts ← k
9 end if
10 end for
11 pij ← prechts
12 until pij
= pi1
Output: Die konvexe Hülle der Punkte p1, . . . , pn ist das Polygon
mit der Eckenfolge (pi1 , . . . , pij−1 )
Für den Startpunkt pi1 können wir z. B. den Punkt mit minimaler
y-Koordinate (und bei Punkten gleicher y-Koordinate, denjenigen
mit minimaler x-Koordinate) wählen; zum Bestimmen der Punkte
pi2 , pi3 , . . . verwenden wir wieder die ccw-Funktion. Diese Idee wurde
im Algorithmus 6.2 umgesetzt.
Bemerkung 6.7 Für den Fall, daß kollineare Punkte auf dem Rand der
konvexen Hülle liegen, liefert Algorithmus 6.2 eine Polygonrepräsentation,
die alle diese Punkte auch als Ecken besitzt.
Soll die Eckenfolge der konvexen Hülle keine kollinearen Ecken enthalten,
können wir Schritt 7 dahingehend modifizieren, daß im zweiten Teil
der if-Abfrage daraufhin getestet wird, ob der Punkt pk weiter von pij−1
entfernt ist als der Punkt prechts. ⊳
Zum Zeitbedarf des Algorithmus: Jeder Durchlauf der for-Schleife benötigt
Θ(n) Schritte; die äußere repeat-Schleife wird so oft durchlaufen,
wie Eckpunkte auf der konvexen Hülle liegen. Somit hat der Jarvis’smarch-Algorithmus
eine Gesamtlaufzeit von Θ(mn), wenn m die Komplexität
der konvexen Hülle bezeichnet. Der Jarvis’s march ist also out-
put-sensitiv. Im Worst case, wenn alle n Punkte auch auf der konvexen
Hülle liegen, hat der Algorithmus also eine (nicht optimale) Laufzeit
von Ω(n 2 ). Wir erhalten damit folgenden Satz:
Satz 6.8 Für eine Menge von n Punkten p1, . . . , pn ∈ E2 kann deren
konvexe Hülle (pi1 , . . . , pim ) mittels des Jarvis’s march bei linearem
Speicherbedarf mit einem Zeitbedarf von Θ(mn) bestimmt werden.

6.4 Graham’s scan 73
6.4 Graham’s scan
Die Hauptidee des Algorithmus von Graham ist, die Punkte zunächst
(zyklisch) angular zu sortieren, bezüglich eines Punktes, der in der konvexen
Hülle der Punkte liegt (z. B. der Schwerpunkt dreier Punkte). Mittels
dieses Preprocessings ist es dann leicht, diejenigen Punkte zu finden, die
Eckpunkte der konvexen Hülle sind.
Ein Eckpunkt p der konvexen Hülle muß nämlich mit allen Punkten pr �
p � pl (insbesondere also mit den direkten Nachbarn in der angularen
Ordnung) einen Winkel ≤ π einschließen, andernfalls wäre p eine
konkave Ecke des Polygons. Andererseits wissen wir bereits aus Lem-
ma 4.7, daß ein Polygon mit ausschließlich konvexen Ecken (d. h. positiven
Knickwinkeln) konvex ist.
Dies machen wir uns jetzt zunutze, indem wir die Punkte gemäß ihrer
zyklischen angularen Ordnung durchlaufen und jeden Punkt p mit seinen
direkten Nachbarn pr und pl in der angularen Ordnung testen. Wir
unterscheiden dabei zwei Fälle:
1. p liegt echt links von [pr pl]:
Preprocessing: Angulare
Sortierung der Punkte
Der Punkt p kann somit keine Ecke der konvexen Hülle sein. Wir
eliminieren deshalb p aus der Liste der Punkte. Da pr jetzt einen
neuen direkten Nachbarn in der angularen Ordnung bekommen
hat (nämlich pl) machen wir einen Rückwärtsschritt und testen als Rückwärtsschritt
nächstes pr (eventuell zum wiederholten Mal).
2. p liegt rechts von [pr pl]:
Momentan spricht nichts dagegen, daß p ein Eckpunkt der konvexen
Hülle ist. Wir machen deshalb einen Vorwärtsschritt und testen Vorwärtsschritt
als nächstes pl.
Durch dieses Vorgehen ist gewährleistet, daß alle Punkte vom Start- Invariante
punkt bis zum aktuellen Punkt mit ihren Nachbarpunkten einen Winkel
≤ π einschließen. Sollte der Startpunkt bei einem Rückwärtsschritt
eliminiert werden, übernimmt der zugehörige Punkt pr seine Rolle.
Diesen zirkularen Scan über alle Punkte führen wir solange durch, bis zirkularer Scan
wir den Startpunkt wieder erreicht und erneut erfolgreich getestet haben
(d. h. der Punkt liegt rechts von [pr pl]). Denn dann können wir
sicher sein, daß alle in der Liste verbliebenen Punkte mit ihren Nachbarpunkten
einen Winkel ≤ π einschließen. Da die verbliebene Punktfolge
außerdem immer noch angular sortiert ist, wissen wir, daß sie gleichzeitig
Eckenfolge eines (zumindest sternförmigen) Polygons ist (vgl. Abschnitt
4.2.2). Lemma 4.7 garantiert uns dann die Konvexität des Polygons.
Zur Bestimmung der Gesamtlaufzeit des Graham’s scans müssen wir
nur noch die Zahl der insgesamt ausgeführten Vorwärts- und Rückwärtsschritte
ermitteln:
pl
p
pr

74 Konvexe Hüllen ebener Punktmengen
Zeitbedarf von Θ(n log n)
für Graham’s scan
Rückwärtsschritte Da bei jedem Rückwärtsschritt ein Punkt aus der Liste
entfernt wird, kann es maximal n − 3 solche Schritte geben, da
aufgrund unserer Voraussetzungen die konvexe Hülle mindestens
drei Eckpunkte enthalten muß.
Vorwärtsschritte Offensichtlich kann es passieren, daß von einem
Punkt aus Ω(n) Vorwärtsschritte getätigt werden. Dies kann allerdings
nicht für alle Punkte der Fall sein. Denn die Zahl der noch
nicht besuchten Punkte wird von einem Vorwärtsschritt um eins
verringert und wird bei einem Rückwärtsschritt zumindest nicht
vergrößert. Da außerdem für jeden Rückwärtsschritt höchstens
ein zusätzlicher Vorwärtsschritt nötig ist, die Zahl der Rückwärtsschritte
aber aus O(n) ist, muß auch die Zahl aller Vorwärtsschritte
aus O(n) sein.
Wir fassen diese Überlegungen in folgendem Satz zusammen:
Satz 6.9 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 kann deren
konvexe Hülle mittels des Graham’s scans bei linearem Speicherbedarf
mit einem Zeitbedarf von Θ(n log n) bestimmt werden.
Bemerkung 6.10 Der oben beschriebene Algorithmus liefert wieder eine
Polygonrepräsentation, die im Fall kollinearer Punkte auf dem Rand
der konvexen Hülle diese auch alle als Ecken zurückliefert.
Ist dies nicht gewünscht, muß nur in der Fallunterscheidung auf der vorhergehenden
Seite »echt links« durch »links« und »rechts« durch »echt
rechts« ersetzt werden. ⊳
6.5 Konstruktion mittels Divide-and-conquer
Divide-and-conquer-Verfahren sind insbesondere dann von Interesse,
wenn ein Problem auf einem Parallelrechner bearbeitet werden soll, weil
dann die entstehenden Teilprobleme auf verschiedenen Prozessoren
gleichzeitig gelöst werden können.
Bei einem Divide-and-conquer-Ansatz zerlegen wir das Problem in zwei
ungefähr gleich große Probleme (hier: die Bestimmung der konvexen
Hülle zweier nur halb so großer Punktmengen), lösen diese rekursiv
und konstruieren aus den beiden Teillösungen (hier: zwei konvexe Polygone)
die Lösung des ursprünglichen Problems (hier: die Bestimmung
der konvexen Hülle zweier konvexer Polygone). Das Grundgerüst des
Divide-and-conquer-Verfahrens bildet somit Algorithmus 6.3 auf der
folgenden Seite. Hierbei setzen wir o. B. d. A. voraus, daß keine drei
Punkte kollinear sind, denn sonst könnte es passieren, daß eine der konvexen
Hüllen in einem der Rekursionsschritte kein reguläres Polygon
mehr ist, sondern nur ein Liniensegment.
Wichtigster Baustein dieses Divide-and-conquer-Algorithmus ist natürlich
das „Verschmelzen“ der beiden konvexen Hüllen CH 1 und CH 2 in

6.5 Konstruktion mittels Divide-and-conquer 75
Algorithmus 6.3 Konvexe Hülle mittels Divide-and-conquer
CONVEXHULLD-A-Q(p1, . . . , pn)
Input: n Punkte p1, . . . , pn ∈ E 2
1 if n ≤ 6 then
2 CH ← CH(p1, . . . , pn) {z. B. mittels eines naiven Algorithmus}
3 else
4 CH 1 ← CONVEXHULLD-A-Q(p1, . . . , p ⌊n/2⌋)
5 CH 2 ← CONVEXHULLD-A-Q(p ⌊n/2⌋+1, . . . , pn)
6 CH ← MERGEHULLS(CH 1, CH 2)
7 end if
Output: CH ist die konvexe Hülle der Punkte p1, . . . , pn
Algorithmus 6.4 Konvexe Hülle zweier konvexer Polygone
MERGEHULLS(P1, P2)
Input: Zwei konvexe Polygone P1, P2 ⊂ E 2
1 Bestimme einen Punkt ˜p ∈ P1
2 if ˜p ∈ P2 then
3 Verschmelze die (jeweils bez. ˜p angular sortierten) Eckenfolgen
von P1 und P2 zu einer Folge CH
4 else
5 Bestimme die beiden Berührecken pl und pr der Tangenten
durch ˜p an das Polygon P2
6 Verschmelze die (bez. ˜p angular sortierten) Eckenfolge von P1 und
die Teilfolge von P2 zwischen pr bis pl zu einer Folge CH
7 end if
8 Wende den Scan-Schritt des Graham’s scans auf die Folge CH an
und eliminiere alle konkaven Ecken aus CH
Output: CH ist die konvexe Hülle der beiden Polygone P1 und P2
Schritt 6. Diesen Teil – also das Berechnen der konvexen Hülle zweier
konvexer Polygone – müssen wir noch genauer spezifizieren. Hierbei
können wir wieder ausnutzen, daß wir die beiden konvexen Polygone
als Eckenfolge – und damit (zyklisch) angular sortiert – vorliegen haben.
Algorithmus 6.4 leistet dann das Gewünschte. Einige Schritte des
Algorithmus bedürfen noch einer genaueren Erläuterung:
Schritt 2: Den Point-in-polygon-Test können wir aufgrund der angularen
Sortierung der Polygonecken in logarithmischer Zeit durchführen.
Hier in unserem Fall genügt jedoch auch ein naiver Linearzeitalgorithmus.
Schritt 5: Die beiden Berührecken pl und pr können wie beim inkrementellen
Algorithmus (Abschnitt 6.2) in linearer Zeit bestimmt
werden. Die Ecken zwischen pl und pr liegen dabei sicherlich innerhalb
von CH(P1 ∪ P2) und können entfernt werden.
P1
˜p
pl
pr
P2

76 Konvexe Hüllen ebener Punktmengen
konvexe Hülle zweier
konvexer Polygone in Θ(n)
Zeitbedarf von Θ(n log n)
für Divide-and-conquer-
Algorithmus
Schritt 3 und Schritt 6: In beiden Fällen (»p ∈ P2« und »p /∈ P2«) können
die beiden Eckenfolgen (bzw. Teilfolgen) in linearer Zeit zu
einer Eckenfolge verschmolzen werden, die ebenfalls bezüglich ˜p
zyklisch angular sortiert ist.
Schritt 8: Somit haben wir jetzt dieselben Voraussetzungen wie nach
dem Sortierschritt beim Graham’s scan, nämlich eine zyklisch angular
sortierte Menge von Punkten, und können nun auf diese den
Scan-Schritt anwenden (mit ebenfalls linearem Zeitbedarf), um die
konvexe Hülle zu erhalten.
Für das Bestimmen der konvexen Hülle zweier konvexer Polygone erhalten
wir somit den folgenden Satz:
Satz 6.11 Für zwei konvexe Polygone P1, P2 ⊂ E 2 mit einer Gesamtkomplexität
von |P1| + |P2| = n kann deren konvexe Hülle bei linearem
Speicherbedarf mit einem Zeitbedarf von Θ(n) bestimmt werden.
Als direkte Folge aus diesem Satz erhalten wir dann auch die Laufzeitabschätzung
für den Divide-and-conquer-Algorithmus 6.3:
Satz 6.12 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 kann deren
konvexe Hülle mittels des Divide-and-conquer-Algorithmus 6.3 bei linearem
Speicherbedarf mit einem Zeitbedarf von Θ(n log n) bestimmt
werden.
Beweis: Schritt 2 des Algorithmus hat einen konstanten Zeitbedarf, die
Schritte 4, 5 und 6 jeweils linearen Zeitbedarf. Somit erhalten wir für
den Gesamtzeitbedarf t(n) die Rekursionsgleichung
t(n) = 2 · t(n/2) + O(n) ,
die zu t(n) ∈ O(n log n) führt. ✷
Bemerkung 6.13 Eine Alternative zu obigem Divide-and-conquer-Verfahren
ist, die Punktmenge in zwei etwa gleich große Mengen zu zerlegen,
deren konvexe Hüllen garantiert disjunkt sind. Dies kann beispielsweise
mittels des Medians (der mit linearem Zeitbedarf bestimmt werden
kann) der x-Koordinaten der Punkte geschehen. Die konvexen Hüllen
der beiden Teilmengen werden dann wieder rekursiv bestimmt.
Im Gegensatz zum vorherigen Algorithmus verzichten wir jetzt beim
Berechnen der konvexen Hülle der beiden konvexen Polygone auf die
Anwendung des Scan-Schritts des Graham’s scans, sondern nutzen aus,
daß die beiden Polygone disjunkt sind. Dann können nämlich die obere
und die untere Tangente an die beiden Polygone direkt bestimmt werden
– durch gleichzeitiges Durchlaufen beider Eckenfolgen. Dieser Durchlauf
benötigt bei naiver Implementierung auch wieder nur linearen Zeitbedarf.
Zudem können die beiden Tangenten auch – durch Verwendung
binärer Suche (siehe Bemerkung 6.6) – mit nur logarithmischem Zeitbedarf
ermittelt werden.
Insgesamt hat dieser alternative Divide-and-conquer-Ansatz auch einen
Zeitbedarf von Θ(n log n). ⊳

6.6 Quickhull 77
6.6 Quickhull
Quickhull ist ebenfalls ein Divide-and-conquer-Verfahren und trägt seinen
Namen aufgrund der großen Ähnlichkeit zum Quicksort-Sortierverfahren.
Bei Quicksort wird ja bekanntlich die Menge der zu sortierenden
Zahlen bezüglich eines zufällig gewählten Pivotelements in zwei Teilmengen
von Zahlen zerlegt, die alle kleiner bzw. größer als das Pivotelement
sind und diese Teilmengen werden dann rekursiv auf dieselbe Art
und Weise sortiert. Im Average case (wenn die beiden Teilmengen ungefähr
gleich groß sind) erhält man dann eine Laufzeit von O(n log n),
im Worst case dagegen (wenn z. B. eine der beiden Mengen immer nur
ein Element enthält) dagegen eine Laufzeit von Ω(n 2 ).
Die Idee bei Quickhull ist die folgende:
• Wir bestimmen zunächst zwei Punkte pl und pr, die garantiert
Eckpunkte der konvexen Hülle sind (z. B. mittels minimaler und
maximaler x-Koordinate). Die Gerade pl pr zerlegt dann die Menge
der Punkte in zwei Hälften.
• Zur Bestimmung der oberen Hälfte der konvexen Hülle (analog
für die untere Hälfte) suchen wir einen Punkt ph, der ebenfalls garantiert
auf der konvexen Hülle liegt, z. B. den Punkt maximalen
Abstands zu pl pr. Alle Punkte in dem durch pl, pr und ph induzierten
Dreieck können jetzt entfernt werden, da sie innerhalb der
konvexen Hülle liegen.
• Für die verbliebenen Punkte links von pl ph und rechts von ph pr
wird nun rekursiv genauso verfahren, d. h. der Punkt ph übernimmt
die Rolle von pr bzw. pl.
Dies ergibt im Worst case (z. B. wenn auf allen Rekursionebenen alle
Punkte stets rechts von ph pr liegen) wie bei Quicksort eine Laufzeit
von Ω(n 2 ). Teilt ph dagegen die Menge der Punkte stets in zwei etwa
gleich große Mengen, 2 erhält man eine Laufzeit von O(n log n) – unabhängig
davon, wieviele Punkte außerdem noch innerhalb des Dreiecks
liegen und eliminiert werden können.
6.7 Dynamische Verfahren
Alle bis jetzt vorgestellten Algorithmen zur Bestimmung der konvexen
Hülle waren sog. Offline-Algorithmen, bei denen die komplette Eingabe Offline- vs. Online-
(also in unserem Fall, die n Punkte) schon vor dem Start des Algorithmus Algorithmen
vorliegt.
Im Gegensatz hierzu erhält ein Online-Algorithmus seine Eingabe nicht
vollständig zu Beginn, sondern nach und nach und auch die Größe der
2 In der Tat müssen die beiden Mengen nicht wirklich gleich mächtig sein, sondern es
genügt bereits, wenn (wie bei Quicksort) jede der beiden Mengen immer mindestens einen
linearen Bruchteil der Ausgangsmenge enthält.
pl
ph
pr

78 Konvexe Hüllen ebener Punktmengen
Eingabe ist vor dem Start des Algorithmus nicht bekannt. Für unser Beispiel
heißt das, daß zu beliebigen Zeitpunkten ein oder mehrere Punkte
zur Punktmenge hinzukommen können (sog. Einfügeereignis) und die
konvexe Hülle aller bis zu einem Zeitpunkt bekannten Punkte jeweils
aktualisiert werden muß.
Einfüge- und Außerdem sind nicht nur die obigen Einfügeereignisse möglich, son-
Löschereignisse dern auch Löschereignisse, d. h. ein Punkt wird wieder aus der Punktmenge
entfernt. Auch hier muß dann die konvexe Hülle entsprechend
aktualisiert werden.
Zeitbedarf von Θ(log n) für
ein Einfügeereignis
Von den in den letzten Abschnitten vorgestellten Algorithmen kann nur
das inkrementelle Verfahren aus Abschnitt 6.2 so modifiziert werden,
daß zumindest Einfügeereignisse effizient behandeln werden können.
Hierzu verwalten wir die konvexe Hülle CH aller Punkte in einer geeigneten
Union-Find-Struktur (siehe hierzu z. B. [22, S. 115]), so daß das
Einfügen neuer Punkte und insbesondere das Löschen einer zusammenhängenden
Folge von Punkten jeweils in logarithmischer Zeit möglich
ist.
Um die konvexe Hülle für einen neu hinzugekommenen Punkt zu aktualisieren,
verwenden wir dann eine leicht modifizierte Version des Aktualisierungsschrittes
von Algorithmus 6.1 auf Seite 70 (Schritte 3 bis 7):
Schritt 4: Die Bestimmung der beiden Berührecken soll jetzt – wie in Bemerkung
6.6 beschrieben – mit logarithmischem Zeitbedarf erfolgen.
Wir verwenden deshalb eine binäre Suche auf unserer Union-
Find-Datenstruktur.
Schritt 5: Sind die beiden Berührecken pl und pr bestimmt, können alle
zwischen pl und pr liegenden Ecken mit logarithmischem Zeitaufwand
aus der Union-Find-Struktur für die konvexe Hülle „ausgehängt“
werden.
Somit kostet jeder Aktualisierungsschritt für ein Einfügeereignis
Θ(log n). Schneller kann dies auch nicht bewerkstelligt werden, denn
sonst hätten wir (bei n Punkten) einen Widerspruch zur unteren
Schranke Θ(n log n) aus Satz 6.3. Insgesamt kostet also das dynamische
Erzeugen der konvexen Hülle (wenn wir die n Punkte als n Einfügeereignisse
betrachten) nicht mehr als das Erzeugen mit einem Offline-
Algorithmus.
Das effiziente Behandeln von Löschereignissen ist hingegen weitaus
schwieriger als das von Einfügeereignissen, denn beim Löschen eines
Punktes können im Worst case Ω(n) Punkte aus dem Inneren der konvexen
Hülle zu neuen Ecken werden. Man kann jedoch zeigen, daß
sich unter Verwendung einer komplizierteren Datenstruktur sowohl der
Aktualisierungsschritt für ein Einfüge- als auch für ein Löschereignis
in jeweils O(log 2 n) Zeit durchführen läßt. Das dynamische Erzeugen
der konvexen Hülle mit diesem Online-Algorithmus (mittels n Einfügeereignissen)
hat damit einen Zeitbedarf von O(n log 2 n). Die Online-
Eigenschaft kostet uns also einen „Straffaktor“ von O(log n).

Lokationsprobleme in
der Ebene
Gegeben einen PSLG (siehe Abschnitt 5.6) mit der Gesamtkomplexität n,
der eine Zerlegung der Ebene induziert, und einen Anfragepunkt p.
Dann interessiert uns beim Point-location-Problem, in welchem der vom
PSLG induzierten polygonalen Gebiete der Punkt p liegt (bzw. ob p in
der unbeschränkten Region liegt). Offensichtlich läßt sich diese Frage
naiv mit linearem Zeitbedarf beantworten, indem man p mit allen Polygonen
auf Inklusion testet (z. B. mittels Algorithmus 4.2 auf Seite 45).
Eine untere Schranke von Ω(log n) (im Entscheidungsbaummodell) für
den Zeitbedarf einer Lokationsanfrage ist ebenfalls sofort einsichtig,
denn ein PSLG der Komplexität n kann Ω(n) verschiedene Regionen
aufweisen, in denen ein Anfragepunkt liegen kann und die demnach
bei einer Point-location-Anfrage unterschieden werden müssen. Somit
besitzt also der zu einer Point-location-Anfrage gehörende Entscheidungsbaum
mindestens Ω(n) Blätter und hat damit mindestens die Höhe
Ω(log n).
Um ein Lokationsverfahren zu erhalten, das eine bessere Laufzeit aufweist
als das naive Verfahren, ist ein sinnvoller Ansatz, aus der ursprünglichen
vom PSLG induzierten planar subdivision eine neue Zerlegung
der Ebene zu erzeugen, die sich „leichter“ durchsuchen läßt,
d. h. bei der die Zahl der zu durchsuchenden Komponenten während
der Suche möglichst schnell eingeschränkt werden kann. Dies könnte
z. B. durch Verwendung von binärer Suche geschehen (denn dann wäre
die Suchzeit nur noch logarithmisch von der Komponentenzahl abhängig).
Darüberhinaus sollte die neue Zerlegung sich „nicht zu stark“ von
der alten Zerlegung unterscheiden; insbesondere sollte jedes der neuen
Polygone nur eine möglichst geringe (d. h. durch eine Konstante beschränkte)
Zahl der ursprünglichen Polygone schneiden, da sonst die
Rekonstruktion des Lokationsergebnisses für die ursprüngliche Zerlegung
zu zeitaufwendig wäre.
Diese zentrale Idee, neue geometrische Objekte zu erzeugen, auf die
dann das Konzept der binären Suche angewandt werden kann, geht auf
Dobkin und Lipton zurück (siehe [6]) und wird bei beiden Ansätzen, die
in den folgenden Abschnitten vorgestellt werden, ausgenutzt.
p
point location
untere Schranke von
Ω(log n)
7

80 Lokationsprobleme in der Ebene
Anfragezeit von Θ(log n)
mit doppelter bin. Suche
Ω(n 2 ) Speicherbedarf
7.1 Die Slab-Methode
Bei der Slab-Methode zerlegen wir die Ebene in eine Menge vertikaler
Streifen (engl. slabs), deren Begrenzungslinien jeweils durch die Ecken
des PSLGs induziert werden (vgl. auch die Schnittbestimmung konvexer
Polygone mittels des Plane-sweep-Ansatzes in Abschnitt 5.2). Auf
diese Weise erhalten wir eine neue planar subdivision, deren beschränkte
Regionen ausschließlich Trapeze (bzw. Dreiecke) sind.
Da nach Konstruktion der Streifen Si keine Ecke des PSLGs innerhalb eines
Streifens liegt, sich demnach also auch keine zwei Kanten des PSLGs
innerhalb eines Streifens schneiden, können wir für jeden Streifen Si eine
Ordnung der von Si geschnittenen Kanten, ei1 ≤ ei2 ≤ · · · ≤ ein i ,
angeben und zusammen mit Si abspeichern. Eine Point-location-Anfrage
für einen Punkt p ist demnach sehr einfach mittels einer zweimaligen
binären Suche zu realisieren:
1. Zuerst bestimmen wir mittels binärer Suche bez. der
x-Koordinaten denjenigen Streifen Si, der den Punkt p enthält.
2. Dann führen wir erneut eine binäre Suche durch (bez. der
y-Koordinaten) und ermitteln im Streifen Si die beiden bez. ihrer
Ordnung aufeinanderfolgenden Segmente eij und eij+1 , die den
Punkt p einschließen.
Da sowohl die Gesamtzahl aller Streifen als auch die Zahl aller Segmente
aus O(n) ist, erhalten wir auf diese Weise eine optimale Anfragezeit
von Θ(log n).
Wir müssen also nur noch analysieren, wie groß der Aufwand zur Speicherung
der Streifen Si und der jeweiligen Segmentfolgen ei1 , . . . , eini ist und was es uns kostet, die zugehörigen Datenstrukturen zu erzeugen.
Wie oben schon erwähnt, gibt es höchstens O(n) Streifen und
in jedem Streifen maximal O(n) Segmente, was einen Gesamtspeicherbedarf
von O(n2 ) zur Folge hat. Speichern wir die Streifen, sortiert
nach ihren x-Koordinaten in einem Baum, dann kostet uns der Aufbau
O(n log n) Zeit. Wenn wir für jeden Streifen Si die zugehörigen Segmente
eij ebenfalls in einem eigenen Baum speichern, dann hat der Aufbau
aller dieser Bäume einen Zeitbedarf von O(n · n log n). Insgesamt erhalten
wir also einen Gesamtzeitbedarf von O(n2 log n) für den Aufbau
der Lokationsdatenstruktur.
Wir können allerdings ausnutzen, daß, wenn eine Kante des PSLGs
durch mehrere Streifen verläuft, diese Streifen alle aufeinanderfolgen
müssen. Diese Beobachtung erlaubt es uns, mittels eines Plane-sweep-
Algorithmus alle Segmentfolgen mit einem Zeitbedarf von O(n 2 ) zu erzeugen
(siehe z. B. [22, S. 47]).
Unglücklicherweise ist aber Ω(n2 ) tatsächlich auch eine untere Schranke
für die Worst-case-Komplexität des Speicherbedarfs beim Slab-Verfahren
und wir können leicht ein Beispiel angeben, bei dem Ω(n) Streifen
mit jeweils Ω(n) Segmenten entstehen. Somit erhalten wir für die Slab-
Methode den folgenden Satz:

7.2 Das Verfahren der verfeinerten Triangulationen 81
Satz 7.1 Das Point-location-Problem für einen PSLG der Gesamtkomplexität
n kann mittels der Slab-Methode mit einem optimalen Zeitbedarf
von Θ(log n) beantwortet werden. Der Preprocessing-Aufwand
(Zeit und Speicher) ist hierbei aus Θ(n 2 ).
Ein in der Größe des PSLGs quadratischer Speicherbedarf ist jedoch für
praktische Anwendungen (d. h. umfangreiche PSLGs) untragbar, so daß
die Slab-Methode nur für kleinere Anwendungen praktikabel ist.
7.2 Das Verfahren der verfeinerten Triangulationen
In diesem Abschnitt wollen wir ein Verfahren vorstellen, das ebenfalls
eine optimale Anfragezeit von Θ(log n) besitzt, gleichzeitig aber auch
nur einen linearen Speicher- und Preprocessing-Zeitbedarf besitzt – das
Verfahren der verfeinerten (und vergröberten) Triangulationen, welches
im Jahr 1983 von Kirkpatrick [13] vorgestellt wurde.
7.2.1 Einschub »Die Eulersche Formel«
Die Eulersche Formel (bzw. Eulersche Polyederformel) ist uns schon in
Beobachtung 5.20 im Abschnitt 5.6 begegnet. Sie stellt einen Zusammenhang
her zwischen den Ecken-, Kanten- und Flächenzahlen sowie
der Zahl der Zusammenhangskomponenten eines in die Ebene eingebetteten
ungerichteten, planaren Graphen. Genauer gilt der folgende
Satz:
Satz 7.2 Für die kreuzungsfreie Realisierung (in die Ebene) eines unge-
richteten Graphen G = (V, E, γ) sei
v seine Eckenanzahl |V| ,
e seine Kantenanzahl |E| ,
f seine Flächenanzahl (inklusive der unbeschränkten Region) ,
c die Zahl seiner Zusammenhangskomponenten .
Dann gilt
v − e + f = c + 1 . (7.1)
Beweis: Wir konstruieren die geometrische Realisierung von G sukzessive
und zeigen durch Induktion, daß die Eulersche Formel jeweils
erfüllt ist. Wir beginnen mit der Realisierung des Graphens, der nur
die Knoten V von G, aber keine Kanten, enthält. Dann ist offensichtlich
v = c, e = 0 und f = 1, also stimmt die Behauptung.
Wir fügen jetzt nach und nach jeweils eine Kante aus E zu G hinzu und
untersuchen, wie sich die Verhältnisse in der entsprechenden geometrischen
Realisierung ändern. Es gibt zwei Fälle:
Preprocessing-Aufwand
von Θ(n 2 ) bei der Slab-
Methode
v = 11, e = 10, f = 3, c = 3

82 Lokationsprobleme in der Ebene
1. die neue Kante verbindet zwei bisher disjunkte Zusammenhangskomponenten:
In diesem Fall wächst e um 1 und die Zahl c der Zusammenhangskomponenten
fällt um 1. Gleichung (7.1) bleibt also richtig.
2. die neue Kante verbindet Knoten derselben Zusammenhangskomponente:
In diesem Fall wachsen sowohl e als auch die Flächenzahl f um
jeweils 1 und Gleichung (7.1) bleibt ebenfall richtig. ✷
Schränken wir die zugelassenen geometrischen Graphen etwas ein, erhalten
wir die beiden folgenden Korollare:
Folgerung für einfache Korollar 7.3 Für die kreuzungsfreie Realisierung (in die Ebene) eines
Graphen ungerichteten einfachen Graphen G = (V, E, γ) gilt
e ≤ 3v − 6c ≤ 3v − 6
f ≤ 2
2
3e − c + 1 ≤ 3e f ≤ 2v − 5c + 1 ≤ 2v − 4
(7.2)
Beweis: Wir müssen nur die erste Ungleichung beweisen. Durch Einsetzen
von Gleichung (7.1) in diese ergeben sich die beiden anderen.
Hierzu betrachten wir die einzelnen Zusammenhangskomponenten
von G getrennt voneinander. Seien also deshalb vi, ei, und fi die Ecken-,
Kanten- und Flächenzahlen desjenigen Graphen, der nur aus der i-ten
Zusammenhangskomponente von G besteht. Wir erweitern nun diesen
Graphen durch Hinzufügen neuer Kanten zu einem einfachen Graphen
mit maximaler Kanten- und Flächenanzahl. In diesem so entstehenden
Graphen werden offenbar alle beschränkten Regionen von genau drei
Kanten begrenzt, denn sonst könnten wir noch eine neue Kante einfügen
und die Zahl der Flächen und Kanten noch weiter erhöhen. (Weniger
als drei begrenzende Kanten ist aufgrund der geforderten Einfachheit
des Graphen ebenfalls nicht möglich)
Seien nun emaxi und fmaxi die Kanten- und Flächenzahlen dieses neuen
Graphen für die i-te Zusammenhangskomponente. Da jede Region
von genau drei Kanten begrenzt wird und jede Kante genau zwei Regionen
begrenzt, gilt 2emaxi = 3fmaxi . Durch Einsetzen von Gleichung (7.1)
mit c = 1 erhält man dann ei ≤ emaxi = 3vi − 6.
Da die Ecken und Kanten in den einzelnen Zusammenhangskomponenten
von G disjunkt sind, gilt �c i=1 vi = v und �c i=1 ei = e, woraus durch
Summation e ≤ 3v − 6c folgt. ✷
Folgerung für Graphen mit Korollar 7.4 Für die kreuzungsfreie Realisierung (in die Ebene) eines
Knotengrad ≥ 3 ungerichteten Graphen G = (V, E, γ), dessen Knoten alle einen Grad
von mindestens 3 besitzen, gilt
v ≤ 2
3 e
v ≤ 2(f − c − 1) ≤ 2f − 4
e ≤ 3(f − c − 1) ≤ 3f − 6
(7.3)

7.2 Das Verfahren der verfeinerten Triangulationen 83
Beweis: Von jedem Knoten gehen nach Voraussetzung mindestens drei
Kanten aus. Da jede Kante zwei Knoten miteinander verbindet, gilt 2e ≥
3v. Die beiden anderen Ungleichungen erhält man wieder durch Einsetzen
von Gleichung (7.1). ✷
Ein PSLG, wie wir ihn definiert haben, ist offensichtlich ein einfacher
kreuzungsfrei in der Ebene realisierter Graph mit genau einer Zusammenhangskomponente
(d. h. c = 1), so daß die Voraussetzungen von
Satz 7.2 und Korollar 7.3 für einen PSLG immer erfüllt sind. Hieraus
folgt dann auch sofort Beobachtung 5.20 auf Seite 63 – die Gesamtkomplexität
eines PSLGs (also v + e + f) ist größenordnungsmäßig nicht größer
als die Zahl v seiner Ecken.
Bemerkung 7.5 Die Bezeichnung »Eulersche Polyederformel« resultiert
aus der Tatsache, daß Gleichung (7.1) – ebenso wie die Ungleichungen –
auch für ein Polyeder im dreidimensionalen Raum gilt (mit c = 1).
Denn durch eine geeignete stetige Transformation können wir ein evtl.
nicht-konvexes Polyeder zunächst in ein konvexes Polyeder überführen.
Dieses bzw. seine Ecken und Kanten projizieren wir dann auf eine umschriebene
Kugeloberfläche und anschließend vom „Nordpol“ der Kugel
in eine zum „Südpol“ tangential verlaufende Ebene. Abbildung 7.1
illustriert diesen Sachverhalt anhand eines zweidimensionalen Schnitts
durch die Szene: die Ecken und Kanten des schwarzen konvexen Polyeders
werden auf die Kugeloberfläche (grün) projiziert und von dort aus
in die Projektionsebene (blau).
Die Inzidenzen bleiben bei allen diesen Transformationen erhalten: Jede
Kante des Polyeders wird auf eine (evtl. krummlinige) Kante in der
Projektionsebene abgebildet und jede Fläche auf eine beschränkte Region
des entstehenden planaren Graphen. Die einzige Ausnahme bildet
diejenige „Fläche“ auf der Kugel, die den Nordpol enthält; diese wird
auf die unbeschränkte Region abgebildet. (Der Nordpol sollte natürlich
nicht gerade durch eine Ecke oder Kante verlaufen.)
Somit haben wir das ursprüngliche Polyeder in einen kreuzungsfrei in
die Ebene eingebetteten Graphen transformiert, für den die Eulersche
Formel (und auch die beiden Korollare) gilt. Deren Aussagen übertragen
sich damit auf die Ecken-, Kanten- und Flächenzahlen des Polyeders.
⊳
Abbildung 7.1
Projektion des Polyeders
auf eine Kugeloberfläche
und von dort in die Ebene

84 Lokationsprobleme in der Ebene
maximaler PSLG
Triangulation
7.2.2 Die Methode von Kirkpatrick
Da das Verfahren der verfeinerten Triangulationen nur für solche PSLGs
definiert ist, deren Regionen ausschließlich Dreiecke sind, führen wir
hierfür eine eigene Bezeichnung ein.
Definition 7.6 (Maximaler PSLG) Ein PSLG, zu dem keine weitere
Kante, die zwei Ecken des PSLGs verbindet, hinzugefügt werden kann
ohne seine Planarität zu verletzen, heißt ein maximaler PSLG.
Man kann leicht zeigen, daß in einem maximalen PSLG jede der beschränkten
Regionen ein Dreieck ist und daß sich jeder PSLG der Gesamtkomplexität
n durch Hinzunahme weiterer Kanten in einen maximalen
PSLG verwandeln läßt, der (aufgrund von Korollar 7.3) ebenfalls
eine Komplexität aus O(n) besitzt.
Definition 7.7 (Triangulation) Einen maximalen PSLG, bei dem der
Rand der äußeren unbeschränkten Region ebenfalls ein Dreieck ist, nennen
wir eine Triangulation.
Eine Triangulation einer endlichen Punktmenge P ⊂ E 2 ist ein maximaler
PSLG, der genau P als Eckenmenge besitzt.
Wir nehmen also im folgenden an, daß wir das Point-location-Problem
für den Spezialfall einer Triangulation beantworten wollen.
Dies ist keine sehr große Einschränkung, denn jeder PSLG der Gesamtkomplexität
n kann durch Hinzunahme dreier zusätzlicher Ecken und
weiterer Kanten in eine Triangulation der Gesamtkomplexität O(n) verwandelt
werden:
1. Hierzu bestimmen wir zunächst ein Dreieck, das alle Ecken des
PSLGs umschließt, beispielsweise indem wir in linearer Zeit mittels
der maximalen und minimalen x- und y-Koordinaten dem
PSLG ein Rechteck umschreiben und für dieses mit konstantem
Zeitbedarf ein umschließendes Dreieck bestimmen.
Dieses Dreieck fügen wir dem PSLG hinzu und verbinden jeweils
jede Ecke des Dreiecks mit einer geeigneten extremalen Ecke des
PSLGs. Der Gesamtzeitaufwand für diesen Schritt ist aus O(n).
2. Jetzt müssen wir noch jede der beschränkten polygonalen Regionen
triangulieren. Chazelle konnte zeigen, daß sich jedes einfache
Polygon in linearer Zeit triangulieren läßt [3] – allerdings mit
einem völlig unpraktikablen Algorithmus, der kaum von praktischem
Interesse ist.
Die Triangulation aller beschränkten Regionen kostet uns somit
ebenfalls nur O(n) Zeit.
3. Die auf diese Weise ggf. neu entstehenden Dreiecksregionen müssen
natürlich noch einen Verweis auf diejenige Region des ursprünglichen
PSLGs erhalten, in welcher sie enthalten sind.

7.2 Das Verfahren der verfeinerten Triangulationen 85
Algorithmus 7.1 Point-location in einer Subdivision-Hierarchie
LOCATE(p)
Input: Subdivision-Hierarchie T1, . . . , Th
Anfragepunkt p
1 CAND h ← alle Regionen von Th
2 R ← diejenige Region aus CAND h, die p enthält
3 i = h − 1
4 while i > 0 do
5 CAND i ← alle Elternregionen von R in Ti
6 R ← diejenige Region aus CAND i , die p enthält
7 i ← i − 1
8 end while
Output: R ist diejenige Region von T1, die den Punkt p enthält
Wir erhalten somit folgendes zusammenfassendes Lemma, welches die
Einschränkung auf Triangulationen beim Point-location-Problem rechtfertigt:
Lemma 7.8 Zu einem gegebenen PSLG der Gesamtkomplexität n kann
mit einem Zeitbedarf von O(n) eine Triangulation (der Gesamtkomplexität
O(n)) erzeugt werden.
7.2.3 Subdivision-Hierarchien
linearer Zeitbedarf zum
Triangulieren eines PSLGs
Die zentrale Idee des Verfahrens ist nun, zu der gegebenen Triangulation
T eine Folge T1, . . . , Th Triangulationen zu erzeugen (eine sog. subdivision
hierarchy), für die folgendes gilt: subdivision hierarchy
• T1 = T .
• Jede Region R von Ti+1 besitzt Zeiger auf diejenigen Regionen R ′
von Ti, für die R ∩ R ′ �= ∅ gilt (für 1 ≤ i < h). Diese Regionen
heißen die Eltern von R in Ti.
Die Zahl h bezeichnen wir hierbei als die Höhe der Subdivision-Hierarchie.
Der Speicherplatzbedarf einer solchen Hierarchie ist offensichtlich
die Summe der Einzelkomplexitäten der Triangulationen, O( �h i=1 |Ti|),
plus den zusätzlichen Platzbedarf für die Verzeigerung.
Für einen Anfragepunkt p kann jetzt die entsprechende Region aus T1, Point-location mittels
die p enthält, mittels eines Durchlaufs durch die Subdivision-Hierarchie
– beginnend bei Th – gefunden werden, siehe Algorithmus 7.1.
Da der Point-in-polygon-Test für ein Dreieck in konstanter Zeit durchgeführt
werden kann, ist der Gesamtzeitbedarf für Algorithmus 7.1 offensichtlich
aus O( �h i=1 |CAND i|). Somit muß es unser Ziel sein, eine Subdivision-Hierarchie
zu konstruieren, bei der sowohl die Höhe als auch
die Größe der Mengen CAND i möglichst klein sind. Daß dies tatsächlich
möglich ist, wollen wir im folgenden zeigen.
Durchlauf durch die
Subdivision-Hierarchie

86 Lokationsprobleme in der Ebene
v
Lemma 7.9 Es gibt positive Konstanten c und d, so daß für jede Triangulation
T mit mehr als drei Ecken mit einem Zeitbedarf von O(|T|) eine
Triangulation T ′ konstruiert werden kann, für die gilt
• |T ′ | ≤ (1 − 1/c) · |T| ,
• jede Region von T ′ hat höchstens d Eltern in T.
Beweis: Sei n die Zahl der Ecken von T und sei v irgendeine innere
Ecken von T, d. h. eine Ecke, die nicht auf dem Rand der unbeschränkten
Region liegt, und sei g(v) ihr Grad (im zugehörigen Graphen).
Dann grenzen an v genau g(v) Regionen und die Vereinigung
dieser Regionen (die Nachbarschaft von v) ergibt ein sternförmiges Polygon
mit g(v) Ecken.
Wenn wir nun die Ecke v und die g(v) inzidenten Kanten aus dem PSLG
entfernen und die Nachbarschaft von v neu triangulieren (durch Einfügen
von g(v)−3 neuen Kanten), erhalten wir eine neue Triangulation mit
n − 1 Ecken. Außerdem schneidet jede der neuen Regionen – unabhängig
davon, wie retrianguliert wurde – maximal g(v) der ursprünglichen
Regionen von T.
Betrachten wir jetzt zwei unabhängige Ecken v und w, d. h. zwei Ecken,
die nicht durch eine Kante verbunden sind, dann überlappen sich die
Nachbarschaften dieser Ecken offensichtlich nicht. Somit können beide
Ecken gleichzeitig aus dem PSLG entfernt und die Nachbarschaften
retrianguliert werden. Die entstehende Triangulation hat dann die Eigenschaft,
daß keine ihrer Regionen mehr als max{g(v), g(w)} der ursprünglichen
Regionen von T schneidet.
gleichzeitiges Entfernen Diese Argumention können wir jetzt ausdehnen auf eine Menge
unabhängiger Ecken v1, . . . , vt paarweise unabhängiger Ecken in T. Durch Entfernen dieser
Ecken und anschließendem Retriangulieren der t sternförmigen Polygone
erhalten wir eine neue Triangulation T ′ mit n − t Ecken und der
Eigenschaft, daß keine Region von T ′ mehr als max1≤i≤t g(vi) Regionen
von T schneidet.
durchschnittlicher
Eckengrad ist ≤ 6
Es genügt jetzt also noch zu zeigen, daß es Konstanten c und d gibt, so
daß eine Menge v1, . . . , vt unabhängiger Ecken mit g(vi) ≤ d (für 1 ≤
i ≤ t) und t ≥ |T| /c immer mit einem Zeitbedarf von O(|T|) bestimmt
werden kann. Dies ist eine direkte Folge aus dem nächsten Lemma. ✷
Lemma 7.10 Es gibt positive Konstanten c und d, so daß jeder PSLG mit
n Ecken mindestens n/c unabhängige Ecken mit einem Grad kleiner
oder gleich d besitzt. Diese können mit einem Zeitaufwand von O(n)
bestimmt werden.
Beweis: Nach Korollar 7.3 besitzt ein PSLG mit n Ecken höchstens
3n − 6 Kanten. Da jede dieser Kanten zwei Ecken miteinander verbindet,
gibt es also maximal 6n − 12 Kantenenden und der durchschnittliche
Eckengrad ist somit kleiner oder gleich (6n − 12)/n ≤ 6. Dar-
aus folgt, daß höchstens die Hälfte aller Ecken einen Grad größer oder

7.2 Das Verfahren der verfeinerten Triangulationen 87
gleich 11 besitzen können, denn sonst stünden nicht genügend Kanten
zur Verfügung. Wir wählen also d = 11 und bestimmen in linearer
Zeit die Teilmenge V aller Ecken, deren Grad kleiner oder gleich 11 ist
(mit |V| ≥ n/2).
Mit einer einfachen Eliminationsstrategie können wir dann in linearer
Zeit eine unabhängige Teilmenge von V bestimmen. Aufgrund des beschränkten
Grades der Ecken in V werden pro ausgewählter Ecke v
maximal 11 Ecken aus V eliminiert, die zu v adjazent sind. Somit
bleiben mindestens noch |V| /12 ≥ n/24 Ecken übrig und wir erhalten
c = 24. ✷
Durch wiederholte Anwendung von Lemma 7.9 erhalten wir dann den
folgenden Satz, der uns die Existenz einer Subdivision-Hierarchie mit
den gewünschten Eigenschaften garantiert:
Satz 7.11 Zu einem PSLG der Gesamtkomplexität n kann mit einem
Zeitbedarf von O(n) eine Folge T1, . . . , Th von Triangulationen erzeugt
werden mit folgenden Eigenschaften:
• Jede Region von T1 ist ganz in einer Region des PSLGs enthalten.
• Es gibt eine positive Konstante d, so daß jede Region von Ti+1
höchstens d Eltern in Ti besitzt (für 1 ≤ i < h).
• Der Gesamtspeicherbedarf der Hierarchie ist aus O(n).
• Die Höhe h der Hierarchie ist aus O(log n).
Beweis: Nach den einleitenden Überlegungen von oben kann der PSLG
in linearer Zeit in eine Triangulation T1 überführt werden, so daß jede
Region von T1 ganz in einer Region des PSLGs enthalten ist. Mittels
Lemma 7.9 erhalten wir dann aus T1 eine echte Triangulation T2 mit
|T2| ≤ (1 − 1/c) · |T1|. Durch mehrfache Anwendung des Lemmas (solange,
bis die Triangulation nur noch aus einem einzigen Dreieck besteht)
erhalten wir eine Folge von Triangulationen T1, . . . , Th, deren Komplexitäten
geometrisch fallen, und es gilt
|T1| ∈ O(n)
|Ti+1| ≤ (1 − 1/c) i · |T1| für 1 ≤ i < h
|Th| ∈ O(1)
Wegen Lemma 7.9 besitzt für 1 ≤ i < h jede Region von Ti+1 höchstens
d Eltern in Ti und der Gesamtspeicherbedarf von O( �h i=1 d·|Ti|) =
O( �h i=1 d · (1 − 1/c)i−1 · n) ist damit aus O(n). Hierbei schätzt der (konstante)
Faktor d den zusätzlichen Aufwand für die Verzeigerung ab.
Außerdem folgt wegen (1 − 1/c) h−1 · |T1| ≥ |Th| ∈ O(1) sofort h ∈
O(log n). ✷
Aus der Existenz einer solchen Subdivision-Hierarchie erhalten wir
dann sofort folgendes Korollar zur Methode der verfeinerten Triangulationen:

88 Lokationsprobleme in der Ebene
Anfrage in Θ(log n)
Preprocessing in Θ(n)
Korollar 7.12 Das Point-location-Problem für einen PSLG der Gesamtkomplexität
n kann mittels der Methode der verfeinerten Triangulationen
mit einem optimalen Zeitbedarf von Θ(log n) beantwortet werden.
Der Preprocessing-Aufwand (Zeit und Speicher) ist hierbei jeweils
aus Θ(n).
Beweis: Die logarithmische Anfragezeit ergibt sich aus dem Gesamtzeitbedarf
von O( �h i=1 |CAND i|) für Algorithmus 7.1, der wegen
|CAND i| ≤ d und h ∈ O(log n) logarithmisch in n ist. ✷
Das Verfahren von Kirkpatrick ist somit in jeglicher Hinsicht optimal.
Sowohl die Anfragezeit als auch der Zeit- und der Speicherbedarf
für das Preprocessing genügen den unteren Schranken für das Pointlocation-Problem.
Allerdings gibt es für praktische Probleme trotzdem sinnvollere Alternativen
als dieses Verfahren. Denn zum einen wird schon ein triangulierter
PSLG vorausgesetzt (und der Triangulatiosalgorithmus von Chazelle
ist für praktische Belange indiskutabel) und zum anderen sind die
in der O-Notationen versteckten Konstanten relativ groß. Trotzdem besticht
dieses Verfahren durch seine konzeptionelle Einfachheit und der
erreichten Optimalität bezüglich aller geforderten Kriterien »Anfragezeit«,
»Preprocessing-Aufwand« und »Speicherbedarf«.

Nachbarschaftsprobleme
Ein Nachbarschaftsproblem ist ganz allgemein und abstrakt durch folgende
Größen charakterisiert:
• Einen Raum X (in unserem Fall ist dies der zweidimensionale reelle
Raum R 2 ),
• eine (endliche) Menge P von Objekten (hier: eine Teilmenge P ⊂ X
von Punkten),
• eine Möglichkeit der Objekte, Einfluß auf den Raum auszuüben.
In unserem Fall wird diese Einflußnahme eines Objektes p ∈ P auf
einen Punkt x ∈ X des Raumes durch den Abstand d(p, x) ausgedrückt
(je geringer d(p, x), desto größer der Einfluß von p auf x).
Hierbei gehen wir davon aus, daß die Funktion d(x, y) eine Metrik
auf X (meist die euklidische Metrik) ist, das Paar (X, d) also einen
metrischen Raum darstellt.
8
Man interessiert sich nun z. B. bei einem Objekt p ∈ P für die Gestalt
und die Größe seines Einflußbereiches, d. h. für diejenige Region, für die
der Einfluß von p stärker ist als der Einfluß eines der anderen Objekte
(vgl. das Problem »Nähestes Telefon« in Abschnitt 1.2). Ein weiteres
typisches Nachbarschaftsproblem ist, für einen Punkt x ∈ X dasjenige
Objekt p ∈ P zu bestimmen, das den stärksten Einfluß auf x ausübt,
also dasjenige Objekt, in dessen Einflußbereich x liegt. Dies wird als das
Problem des nächsten Nachbarn (engl. nearest neighbor problem) bezeichnet. Nearest-Neighbor-Problem
Solche Überlegungen führen uns im folgenden zum Begriff der Voronoi-
Region und des Voronoi-Diagramms.
8.1 Definition und Eigenschaften des Voronoi-
Diagramms
Im folgenden gehen wir – sofern nicht anders angegeben – immer davon
aus, daß unsere Objekte Punkte im zweidimensionalen euklidischen
Raum E2 sind. Insbesondere wird also der Einfluß eines Objekts p auf
einen Punkt x durch die euklidische Metrik
�
|p x| = (p1 − x1) 2 + (p2 − x2) 2

90 Nachbarschaftsprobleme
Abbildung 8.1
Bisektoren in der
Manhattan-Metrik (links)
und der
Maximum-Metrik (rechts)
p
Bisektor
B(p, q)
q
flächige Bisektoren
beschrieben.
Wir betrachten nun zunächst den Fall von nur zwei Punkten p und q
und interessieren uns für die Grenze zwischen ihren Einflußbereichen,
den sog. Bisektor der beiden Punkte.
Definition 8.1 (Bisektor) Der Bisektor B(p, q) zweier Punkte p und q
im E2 ist definiert als
Da die letzte Zeile der Umformung
x ∈ B(p, q) ⇐⇒ |p x| = |q x|
B(p, q) := { x ∈ E 2 � � |p x| = |q x| } . (8.1)
⇐⇒ (p1 − x1) 2 + (p2 − x2) 2 = (q1 − x1) 2 + (q2 − x2) 2
⇐⇒ p 2 1 − 2p1x1 + x 2 1 + p 2 2 − 2p2x2 + x 2 2 =
q 2 1 − 2q1x1 + x 2 1 + q 2 2 − 2q2x2 + x 2 2
⇐⇒ x1(2q1 − 2p1)
+ x2(2q2 − 2p2)
− (q 2 1 + q 2 2 − p 2 1 − p 2 2) = 0
die Normalenform einer Geraden im R2 darstellt, ist der Bisektor B(p, q)
für die euklidische Metrik eine Gerade (nämlich genau die Mittelsenkrechte
des Liniensegments [p q]).
Bemerkung 8.2 Legen wir andere Metriken als die euklidische Metrik
zugrunde, können durchaus auch „kompliziertere“ Gebiete als Bisektoren
auftreten. Abbildung 8.1 zeigt beispielsweise links Bisektoren bei
Verwendung der Manhattan-Metrik und rechts bei Verwendung der
Maximum-Metrik (siehe deren Definition auf Seite 6). Offenbar können
hier sogar flächige Bisektoren auftreten: Bei der Manhattan-Metrik tritt
ein solcher Spezialfall ein, wenn die beiden Punkte gegenüberliegende
Eckpunkte eines Quadrats sind, und bei der Maximum-Metrik, wenn sie
gleiche x- oder y-Koordinaten besitzen. ⊳
Der (euklidische) Bisektor für zwei Punkte p und q zerlegt die Ebene in
zwei Halbebenen, nämlich in
D(p, q) := { x ∈ E 2 � � |p x| < |q x| }

8.1 Definition und Eigenschaften des Voronoi-Diagramms 91
und
D(q, p) = { x ∈ E 2 � � |p x| > |q x| } ,
mittels derer wir jetzt auch für mehr als zwei Punkte deren Einflußbereiche
– ihre sog. Voronoi-Regionen – definieren können.
Definition 8.3 (Voronoi-Diagramm)
Für eine Menge P = {p1, . . . , pn} ⊂ E2 von n Punkten in der Ebene ist
die Voronoi-Region des Punktes pi ∈ P die Menge Voronoi-Region
VR(pi) := �
D(pi, pj) .
Die Menge
1≤j≤n
j�=i
VD(P) := E 2 \ �
1≤i≤n
VR(pi)
bezeichnen wir als das Voronoi-Diagramm der Punktmenge P. Voronoi-Diagramm
Aufgrund der Definition ist die Voronoi-Region VR(pi) eines Punktes pi
der Schnitt von n − 1 offenen Halbebenen, die jeweils alle pi enthalten.
Somit besitzt VR(pi) innere Punkte und kann als konvexes (möglicherweise
unbeschränktes) Polygon dargestellt werden, das von maximal
n − 1 Ecken und maximal n − 1 Kanten (bzw. Halbstrahlen) berandet
wird. Das Voronoi-Diagramm besteht dann gerade aus denjenigen Bisektorteilen,
die nicht im Innern eines dieser Polygone liegen. Der folgende
Satz beschreibt deren Struktur etwas genauer:
Satz 8.4 Sei P = {p1, . . . , pn} ⊂ E 2 eine Menge von n Punkten in der
Ebene. Falls alle Punkte auf einer Geraden liegen, dann besteht das
Voronoi-Diagramm aus n − 1 parallelen Geraden, ansonsten ist VD(P)
wegzusammenhängend und besteht nur aus Segmenten und Halbstrahlen.
Beweis: Die erste Aussage des Satzes ist einfach nachzuprüfen, wir zeigen
deshalb gleich die zweite Aussage und nehmen an, daß nicht alle
n ≥ 3 Punkte auf einer Geraden liegen.
Wir zeigen zunächst, daß VD(P) nur aus Segmenten und Halbstrahlen
besteht. Angenommen, dies wäre nicht der Fall, dann müßte VD(P) eine
Gerade g enthalten, welche auf dem Rand zweier Voronoi-Regionen
– o. B. d. A. VR(pi) und VR(pj) – liegt. Sei nun pk ∈ P ein Punkt, der
nicht kollinear zu pi und pj liegt. Dann ist der Bisektor B(pk, pj) nicht pi pj
parallel zu g und schneidet die Gerade. Somit kann aber der Teil der
Geraden g, der im Innern von D(pk, pj) liegt, nicht zum Voronoi-Diagramm
gehören und wir erhalten einen Widerspruch.
Wir müssen jetzt nur noch zeigen, daß VD(P) wegzusammenhängend
ist. Wäre dem nicht so, dann müßte es eine Voronoi-Region VR(pi) geben,
die die komplette Ebene teilt. Da Voronoi-Regionen konvex sind,
g
pk

92 Nachbarschaftsprobleme
Abbildung 8.2
Die drei möglichen Fälle
eines Punktes x der Ebene
Repräsentation des
Voronoi-Diagramms als
PSLG
VR(pi) unbeschränkt
⇐⇒ pi ∈ ∂CH(P)
x
pi
x
müßte VR(pi) aus einem Streifen bestehen, der von zwei parallelen Geraden
begrenzt wird. Dies ist aber – wie eben gezeigt – nicht möglich.
✷
Außer für den einfachen Spezialfall von n kollinearen Punkten ist das
Voronoi-Diagramm also wegzusammenhängend und kann als PSLG
(siehe Abschnitt 5.6) repräsentiert werden, sofern wir die Halbstrahlen,
welche die unbeschränkten Regionen beranden, geeignet berücksichtigen.
Die Voronoi-Knoten und Voronoi-Kanten entsprechen dann den Knoten
und Kanten (bzw. Halbstrahlen) des PSLGs.
Das folgende Lemma gestattet uns, jeden Punkt der Ebene eindeutig
einer der drei Mengen »Voronoi-Knoten«, »Voronoi-Kante« oder
»Voronoi-Region« zuzuordnen. Ein Beweis dieses Lemmas findet sich
z. B. in [14, S. 215].
Lemma 8.5 Für einen Punkt x ∈ E 2 sei C(x) die kleinste abgeschlossene
ε-Kugel U ε(x) um x,
pi
pj
U ε(x) = { y ∈ E 2 � � |x y| ≤ ε } ,
die mindestens einen Punkt aus P = {p1, . . . , pn} enthält. Dann gilt:
P ∩ C(x) = {pi} ⇐⇒ x liegt in der Voronoi-Region VR(pi) des Punktes
pi (siehe Abbildung 8.2, links).
P ∩ C(x) = {pi, pj} ⇐⇒ x liegt auf der Voronoi-Kante, die die Regionen
VR(pi) und VR(pj) begrenzt (siehe Abbildung 8.2, Mitte).
P ∩ C(x) = {pi1 , . . . , pik } (mit k ≥ 3) ⇐⇒ x ist ein Voronoi-Knoten,
an den die Regionen VR(pi1 ), . . . , VR(pik ) angrenzen. Dabei entspricht
die zyklische angulare Ordnung der Punkte pi1 , . . . , pik
um x der Ordnung ihrer Voronoi-Regionen um x (siehe Abbildung
8.2, rechts).
Mit Hilfe dieses Lemmas können wir eine interessante Eigenschaft der
unbeschränkten Regionen des Voronoi-Diagramms beweisen:
Satz 8.6 Eine Voronoi-Region VR(pi) eines Punktes pi ∈ P ist genau
dann unbeschränkt, wenn der Punkt pi auf dem Rand der konvexen
Hülle von P liegt.
pk
x
pi
pj

8.1 Definition und Eigenschaften des Voronoi-Diagramms 93
Beweis: Angenommen, die Voronoi-Region VR(pi) ist unbeschränkt.
Dann muß es einen weiteren Punkt pj geben, so daß ein unbeschränktes
Stück des Bisektors B(pi, pj) zum Voronoi-Diagramm VD(P) gehört.
Wir wählen einen Punkt x auf diesem Stück und betrachten den in Lemma
8.5 definierten Kreis C(x), auf dessen Rand die beiden Punkte pi
und pj liegen.
Schieben wir x auf der unbeschränkten Voronoi-Kante weit genug
nach rechts (ins „Unendliche“), können wir jeden Punkt in der rechten
(durch pi und pj induzierten) Halbebene mit C(x) überdecken. Da
nach Lemma 8.5 der Kreis C(x) keinen weiteren Punkt aus P enthalten
kann, müssen alle übrigen Punkte aus P \ {pi, pj} in der linken Halbebene
liegen und das Segment [pi pj] liegt auf dem Rand der konvexen
Hülle CH(P).
Sind umgekehrt pi und pj zwei benachbarte Ecken von CH(P) und
liegt P o. B. d. A. links der Geraden pi pj, dann läßt sich immer ein Halbstrahl
auf dem Bisektor B(pi, pj) finden (indem wir weit genug nach
rechts wandern), so daß jeder Kreis C(x) mit einem Mittelpunkt x auf
dem Halbstrahl keinen weiteren Punkt aus P\{pi, pj} mehr enthält. Folglich
bildet ein unbeschränktes Stück von B(pi, pj) – nämlich eben jener
Halbstrahl – eine Voronoi-Kante und auch VR(pi) und VR(pj) sind unbeschränkt.
✷
Für das Voronoi-Diagramm als eine Unterteilung der Ebene in Regionen
größten Einflusses interessiert uns natürlich, wie komplex diese Unterteilung
sein kann:
Satz 8.7 Das Voronoi-Diagramm einer n-elementigen Punktmenge in
der Ebene besteht aus höchstens 2n − 5 Ecken und 3n − 6 Kanten.
Beweis: Falls alle n Punkte auf einer Geraden liegen, folgt die Behauptung
sofort aus Satz 8.4. Wir nehmen deshalb an, dies wäre nicht der Fall
und erweitern das Voronoi-Diagramm zu einem (zusammenhängenden)
planaren Graphen, indem wir eine zusätzliche Ecke einführen, die wir
mit allen Halbstrahlen (von denen es mindestens drei geben muß) verbinden.
Auf diese Weise erhalten wir einen Graphen, dessen Knoten
alle einen Grad von mindestens 3 besitzen, und wir können Korollar 7.4
darauf anwenden. Die Flächenzahl f des Graphen ist dabei gleich der
Zahl n der Punkte, die Kantenzahl e gleich der Zahl der Voronoi-Kanten
und die Eckenzahl v gleich der Zahl der Voronoi-Knoten plus eins.
Somit folgt die Behauptung aus Ungleichung (7.3). ✷
Die Komplexität des Voronoi-Diagramms für eine Punktmenge ist also
nur linear in der Zahl der Punkte. Zusammen mit Satz 8.6 auf der vorherigen
Seite erhalten wir dann aus dem vorherigen Satz sofort die folgende
Aussage zur Konstruktion der konvexen Hülle einer Punktmenge:
Korollar 8.8 Aus dem Voronoi-Diagramm VD(P) einer n-elementigen
Punktmenge P kann mit einem Zeitbedarf von O(n) die konvexe Hülle
CH(P) konstruiert werden.
L R
pj
pi
x
∞

94 Nachbarschaftsprobleme
unt. Schr. von Ω(n log n)
für Voronoi-Diagramm
Delaunay-Zerlegung
DG(P) ist planar
Beweis: Für das gegebene Voronoi-Diagramm müssen wir nur eine
unbeschränkte Regionen finden und uns dann an den unbeschränkten
Kanten entlang einmal um die Punktmenge herum bewegen. Dabei
wird jede Voronoi-Kante höchstens einmal inspiziert und der Gesamtzeitbedarf
ist aus O(n). ✷
Aufgrund der unteren Schranke von Ω(n log n) aus Satz 6.3 für die Konstruktion
der konvexen Hülle ergibt sich damit auch sofort eine untere
Schranke für die Konstruktion des Voronoi-Diagramms:
Korollar 8.9 Die Konstruktion des Voronoi-Diagramms von n Punkten
in der Ebene besitzt einen Zeitbedarf von Ω(n log n).
8.2 Der Delaunay-Graph
Definition 8.10 (Delaunay-Graph) Sei P eine Menge von n Punkten
in der Ebene und E die Menge aller Voronoi-Kanten im Voronoi-Diagramm
VD(P). Der ungerichtete Graph DG(P) = (P, E, γ) mit Eckenmenge
P, Kantenmenge E und einer Abbildung
γ: e ↦→ {pi, pj} für eine Voronoi-Kante e auf dem Bisektor B(pi, pj)
heißt der Delaunay-Graph zur Menge P.
Seine geometrische Realisierung, die jede Ecke auf den zugehörigen
Punkt in der Ebene und jede Kante e = {pi, pj} auf das Liniensegment
[pi pj] abbildet, heißt die von der Punktmenge P induzierte Delaunay-Zerlegung.
Ein Liniensegment [pi pj] dieser Zerlegung nennt man
auch Delaunay-Kante.
Aufgrund der Konvexität der Voronoi-Regionen gibt es zu jedem
Bisektor B(pi, pj) höchstens eine Voronoi-Kante. Somit enthält der
Graph DG(P) auch höchstens eine Kante zwischen je zwei Punkten
pi, pj ∈ P. Für die vom Delaunay-Graphen induzierte Zerlegung
der Ebene können wir damit eine wichtige Eigenschaft zeigen:
Satz 8.11 Die zu einem Delaunay-Graphen DG(P) gehörende Delaunay-
Zerlegung ist kreuzungsfrei, d. h. der Graph DG(P) ist planar.
Beweis: Wir nehmen an, es gäbe zwei Segmente [pi pj] und [pk pl] in
der Delaunay-Zerlegung, die sich in einem Punkt x schneiden (oder
überlappen). Für den in Lemma 8.5 definierten Kreis C(x) gilt dann
P ∩ C(x) = {pi, pj}, da x auf der Voronoi-Kante zu den Regionen VR(pi)
und VR(pj) liegt. Andererseits gilt aber auch P ∩ C(x) = {pk, pl}, da x
auch auf der Voronoi-Kante zu den Regionen VR(pk) und VR(pl) liegt.
Somit müssen die beiden Segmente identisch sein, was aber – nach obiger
Anmerkung – unmöglich ist. ✷
Bemerkung 8.12 Aus obigen Definitionen und Überlegungen folgt, daß

8.2 Der Delaunay-Graph 95
• jeder Voronoi-Region eine Ecke in DG(P),
• jeder Voronoi-Kante eine Kante in DG(P),
• jedem Voronoi-Knoten eine Region in der zu DG(P) gehörenden
Delaunay-Zerlegung
entspricht. Das Voronoi-Diagramm VD(P) und der Delaunay-
Graph DG(P) sind somit zueinander dual und lassen sich auch in
linearer Zeit ineinander überführen.
VD(P) und DG(P) sind
zueinander dual
Insbesondere hat auch jede beschränkte Region in DG(P) genau so viele
Kanten, wie bei ihrem zugehörigen Knoten in VD(P) zusammenlaufen.
Besitzt also jeder Voronoi-Knoten genau den Grad 3 (d. h. jeder
Kreis C(x) enthält höchstens drei Punkte aus P), dann sind alle beschränkten
Regionen von DG(P) Dreiecke und wir erhalten einen maximalen
PSLG. Aus diesem Grund nennt man DG(P) bzw. die zugehörige
Delaunay-Zerlegung auch eine Delaunay-Triangulation der Punktmen- Delaunay-Triangulation
ge P, selbst wenn der Rand der unbeschränkten Region kein Dreieck ist
oder obige Bedingung nicht erfüllt ist.
Im letzten Fall kann es sich dann bei den übrigen beschränkten Regionen
nur um konvexe Polygone handeln, deren Ecken alle auf dem Kreis C(x)
um den entsprechenden Voronoi-Knoten x liegen, und die sich leicht
„nachtriangulieren“ lassen. Mit Ausnahme dieses Spezialfalls von mehr
als drei kozirkular liegenden Punkten ist die Delaunay-Triangulation somit
eindeutig bestimmt. ⊳
Die Delaunay-Kanten und die Dreiecke in der Delaunay-Zerlegung können
wir noch etwas genauer charakterisieren:
Lemma 8.13 Für eine Punktmenge P und ihre zugehörige Delaunay-Triangulation
DG(P) gilt:
• Zwei Punkte pi, pj ∈ P sind genau dann durch eine Delaunay-
Kante miteinander verbunden, wenn es einen Kreis gibt, der nur pi
und pj auf seinen Rand enthält und keinen Punkt aus P in seinem
Innern.
• Drei nicht-kollineare Punkte pi, pj, pk ∈ P induzieren genau dann
ein Dreieck der Delaunay-Triangulation, wenn der Umkreis des
Dreiecks (d. h. der eindeutig bestimmte Kreis durch pi, pj und pk
keinen weiteren Punkte aus P auf seinem Rand oder in seinem Innern
enthält.
Beweis: Nach Definition 8.10 sind zwei Punkte pi, pj ∈ P genau
dann durch eine Delaunay-Kante miteinander verbunden, wenn es eine
Voronoi-Kante auf dem Bisektor B(pi, pj) gibt. Dies ist nach Lemma 8.5
gleichbedeutend damit, daß es einen Punkt x auf dieser Voronoi-Kante
gibt mit P ∩ C(x) = {pi, pj}.
Die zweite Behauptung zeigt man analog. ✷

96 Nachbarschaftsprobleme
beliebige Triangulation
Delaunay-Triangulation
☞ WWW
Mit Hilfe dieser Aussage erhalten wir sofort eine alternative Charakterisierung
einer Delaunay-Triangulation:
Satz 8.14 Sei P ⊂ E 2 eine endliche Punktmenge in der Ebene und T
eine Triangulation von P. Dann ist T eine Delaunay-Triangulation von P,
genau dann wenn der Umkreis einer jeden Dreiecksregion von T keinen
Punkt von P in seinem Innern enthält.
Die Delaunay-Triangulation besitzt noch viele weitere interessante Ei-
genschaften, unter anderem eine, die z. B. bei der Erzeugung von Oberflächennetzen
(engl. mesh generation) eine wichtige Rolle spielt: Hier
kommt es nämlich darauf an, daß für eine gegebene Punktmenge nicht
irgendeine Triangulation verwendet wird, sondern eine, die hinsichtlich
bestimmter Kriterien, die von der Anwendung vorgegeben werden, optimal
ist. Ein solches Kriterium ist beispielsweise, daß die erzeugten
Dreiecke in der Triangulation möglichst keine spitzen Winkel aufweisen
sollen. Diesbezüglich ist die Delaunay-Triangulation im gewissen Sinn
optimal, wie der folgende Satz zeigt. Ein Beweis findet sich z. B. in [14,
S. 236].
Satz 8.15 Sei P eine Menge von Punkten in der Ebene, die nicht alle auf
einer Geraden liegen und von denen keine vier auf einem gemeinsamen
Kreisrand liegen. Dann haben die Dreiecke der Delaunay-Triangulation
DG(P) unter allen Triangulationen von P den größten minimalen Innenwinkel,
d. h.
min{ α � � α ist Innenwinkel eines Dreiecks von DG(P) }
=
max
Triangulation T von P min{ α � � α ist Innenwinkel eines Dreiecks von T } .
Zum interaktiven Experimentieren mit Voronoi-Diagrammen und Delaunay-Triangulationen
kann das Java-Applet »VoroGlide« der FernUniversität
Hagen verwendet werden (�������������������������������
���������������).
8.3 Verallgemeinerungen
Neben dem Voronoi-Diagramm für Punkte in der euklidischen Ebene
gibt es eine Vielzahl von Möglichkeiten, den Nachbarschaftsbegriff zu
verallgemeinern, siehe z. B. [1]. Einige sollen im folgenden exemplarisch
genannt werden:
Allgemeinere Abstandsbegriffe für Punkte In Bemerkung 8.2 haben
wir schon am Beispiel der Manhattan- und der Maximum-Metrik
gesehen, daß sich die Definition des Bisektors auch auf andere Metriken
als der euklidischen Metrik übertragen läßt, beispielsweise
auf die Familie der Minkowski-Metriken Lp(x, y) mit p = 1, . . . , ∞

8.3 Verallgemeinerungen 97
(siehe deren Definition auf auf Seite 6). Die Funktionen Lp gehören
hierbei zu einer Menge spezieller durch Normen induzierter Metriken,
die in der Algorithmischen Geometrie auch als symmetrische
konvexe Distanzfunktionen bezeichnet werden.
Die meisten strukturellen Eigenschaften des Voronoi-Diagramms
lassen sich hierbei auf diese Klasse von Distanzfunktionen übertragen,
mit dem Hauptunterschied, daß die Bisektoren gekrümmt
sind.
Weitere Informationen und zwei Java-Applets zum Experimentieren
finden sich auf der Seite der FernUniversität Hagen über
(nicht notwendigerweise symmetrische) konvexe Distanzfunktionen
(��������������������������������������������������
������������������������������ ). WWW☞
Allgemeinere Objekte Wir haben uns bisher auf die einfachste Menge
P ⊂ E 2 von Objekten eingeschränkt, die denkbar ist – auf Punkte.
Wenn man die Abstandsfunktion d(p, x), die den Einfluß des
Objekts p auf den Punkt x ∈ E 2 beschreibt, geeignet wählt, kann
man aber auch kompliziertere Objekte zulassen, beispielsweise Liniensegmente.
Hierzu definieren wir für ein Segment l dessen Abstand
zu einem Punkt x.
d(l, x) := min |x y|
y∈l
Die Bisektoren zwischen zwei Liniensegmenten, die wir auf diese
Weise erhalten, sind wieder gekrümmt und bestehen i. allg. aus
Halbstrahlen, Liniensegmenten und Parabelstücken.
Voronoi-Diagramme höherer Ordnung Das klassische Voronoi-Diagramm
VD(P) unterteilt die Ebene so in Regionen, daß alle Punkte
einer Region denselben nächsten Nachbarn in der Menge P besitzen.
Zerlegt man dagegen für eine Zahl k zwischen 1 und n − 1 die
Ebene so in Regionen, daß alle Punkte aus einer Region dieselben k
nächsten Nachbarn besitzen, erhält man das sog. Voronoi-Diagramm
der Ordnung k, i. Z. VDk(P). Dabei ist VD1(P) gerade das klassische
Voronoi-Diagramm und VDn−1(P) ist die Unterteilung in
Gebiete gleicher entferntester Nachbarn.
Höherdimensionale Räume Eine Verallgemeinerung des Voronoi-Diagramms
in Räume höherer Dimension liegt nahe und ist auch
möglich, allerdings gehen hierbei viele der oben gezeigten Eigenschaften
verloren. So besteht z. B. das Voronoi-Diagramm im dreidimensionalen
euklidischen Raum zwar immer noch aus konvexen
Regionen, seine Größe ist aber nicht mehr linear in der Zahl
der Punkte, sondern quadratisch.
Voronoi-Diagramm der
Ordnung 2

98 Nachbarschaftsprobleme
Bisektor von L und R
8.4 Konstruktion des Voronoi-Diagramms
Wir wollen im folgenden zwei Verfahren mit jeweils optimaler Laufzeit
Θ(n log) zur Berechnung des Voronoi-Diagramms einer Punktmenge
in der euklidischen Ebene beschreiben – einen Divide-and-conquer-
Ansatz ähnlich dem Verfahren zur Konstruktion der konvexen Hülle aus
Abschnitt 6.5 sowie ein Sweep-line-Verfahren. Die Algorithmen sollen
dabei nur skizziert werden. Weiterführende Informationen finden sich
zum Divide-and-conquer-Algorithmus in [14, S. 295] und zur Sweepline-Methode
in [5, S. 149] und [14, S. 286].
Aufgrund der Dualität von Voronoi-Diagramm und Delaunay-Triangulation
kann natürlich mit allen Verfahren auch die Delaunay-Triangulation
einer Punktmenge bestimmt werden. Da der lineare Überführungsaufwand
(siehe Bemerkung 8.12 auf Seite 94) geringer ist als die untere
Laufzeitschranke für die Konstruktion des Voronoi-Diagramms (siehe
Korollar 8.9 auf Seite 94) ist Ω(n log n) auch eine untere Schranke für die
Konstruktion der Delaunay-Triangulation und jedes Verfahren, welches
die eine Struktur berechnet, kann zu einem Verfahren erweitert werden,
welches die andere Struktur mit demselben Zeitbedarf bestimmt.
8.4.1 Divide-and-conquer-Verfahren
Die Grundidee des Divide-and-conquer-Verfahrens zur Bestimmung
des Voronoi-Diagramms ist ganz ähnlich wie bei der Konstruktion der
konvexen Hülle: Wie in Bemerkung 6.13 auf Seite 76 beschrieben, teilen
wir mit linearem Zeitbedarf die Punktmenge P in zwei etwa gleich
große Mengen L und R, deren konvexe Hüllen disjunkt sind – beispielsweise
mittels des Medians der x-Koordinaten.
Die Voronoi-Diagramme der beiden Mengen werden dann rekursiv
bestimmt und müssen nun noch zu einem gemeinsamen Voronoi-Diagramm
für die ursprüngliche Menge verschmolzen werden (siehe Abbildung
8.3 auf der gegenüberliegenden Seite). Hierzu betrachten wir die
Kanten im Voronoi-Diagramm VD(P) der Ursprungsmenge P. Offenbar
gibt es zwei Arten von Voronoi-Kanten:
1. Kanten, die zwischen Voronoi-Regionen von Punkten aus derselben
Teilmenge L oder R von P verlaufen. Solche Kanten sind schon
in den Voronoi-Diagrammen VD(L) und VD(R) enthalten, sind
dort aber ggf. länger.
2. Kanten, die zwischen einer L-Region und einer R-Region verlaufen.
Zusammen bilden diese Kanten die Menge
B(L, R) := { x ∈ E 2 � � min
p∈L
|p x| = min |q x| }
q∈R
aller Punkte, die einen nächsten Nachbarn in L und einen in R besitzen,
genannt den Bisektor von L und R.

8.4 Konstruktion des Voronoi-Diagramms 99
Man kann nun zeigen, daß der Bisektor B(L, R) immer eine (unbeschränkte)
polygonale Kette ist, die zudem monoton bez. der Separationsgeraden
der beiden Mengen L und R ist. 1 Das Voronoi-Diagramm
VD(P) kann man dann konstruieren, indem man die beiden Teil-
Diagramme VD(L) und VD(R) längs des Bisektors B(L, R) aufschneidet
und den linken Teil von VD(L) mit B(L, R) und mit dem rechten Teil
von VD(R) verbindet (siehe Abbildung 8.3). Das Hauptproblem ist also,
den Bisektor B(L, R) der beiden Mengen L und R zu bestimmen, denn
das Verschmelzen der beiden Voronoi-Diagramme ist (bei gegebenem
Bisektor) mit linearem Zeitbedarf möglich bzw. kann sogar schon bei
dessen Konstruktion ausgeführt werden.
Um den Bisektor zu ermitteln, sucht man zunächst eines seiner beiden
unbeschränkten Teilstücke. Diese werden aber durch genau diejenigen
Punkte aus L und R induziert, die auch die in Bemerkung 6.13 eingeführten
oberen und unteren Tangenten (an die konvexen Hüllen) bestimmen,
und können somit in linearer (bzw. mittels binärer Suche sogar in logarithmischer)
Zeit ermittelt werden.
Nachdem wir eines der unbeschränkten Stücke des Bisektors gefunden
haben (o. B. d. A. sei dies das zur unteren Tangente durch die beiden
Punkte li ∈ L und rj ∈ R gehörende Stück), arbeiten wir uns in beiden
Voronoi-Diagrammen VD(L) und VD(R) gleichzeitig von unten nach
oben vor. Wir starten jeweils in den beiden Regionen VR(li) und VR(rj),
die das unbeschränkte Bisektorstück induzieren, und prüfen dann, ob
der Bisektor B(li, rj) als nächstes eine Nachbarregion VR(lk) von VR(li)
oder eine Nachbarregion VR(rl) von VR(rj) erreicht. Dies können wir
durch einen geeigneten Durchlauf der Kanten von VR(li) und VR(rj)
erreichen. Die so ermittelte Region VR(lk) bzw. VR(rl), welche vom
1 Monoton bedeutet hier, daß jede zur Separationsgeraden senkrecht stehende Gerade
die Kette B(L, R) maximal einmal schneidet.
Abbildung 8.3
Verschmelzen der beiden
Voronoi-Diagramme

100 Nachbarschaftsprobleme
Abbildung 8.4
Bei einem neuen Punkt
ändert sich das Voronoi-
Diagramm auch links der
Sweep line
Zeitbedarf von Θ(n log n)
für Divide-and-conquer-
Verfahren
Bisektor als nächstes betreten wird, übernimmt dann die Rolle der Region
VR(li) bzw. VR(rj), die der Bisektor verläßt.
Auf diese Weise hangeln wir uns von unten nach oben durch die beiden
Teil-Diagramme, bis wir bei denjenigen Punkten angelangt sind, die die
obere Tangente der konvexen Hülle bestimmen. Eine sorgfältige Implementation
und Analyse garantieren dabei, daß jede Voronoi-Kante der
beiden Teil-Diagramme nur höchstens einmal besucht wird. Somit kann
der Bisektor B(L, R) in linearer Zeit bestimmt werden.
Für die Gesamtlaufzeit des Algorithus erhalten wir dann wieder dieselbe
Rekursionsgleichung wie bei der Konstruktion der konvexen Hülle
in Abschnitt 6.5 und somit den folgenden Satz:
Satz 8.16 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 kann deren
Voronoi-Diagramm mittels des Divide-and-conquer-Verfahrens bei
linearem Speicherbedarf mit einem optimalen Zeitbedarf von Θ(n log n)
bestimmt werden.
8.4.2 Sweep-line-Verfahren
Die Grundidee bei diesem Verfahren ist natürlich wieder – wie bei allen
Sweep-line-Verfahren – eine senkrechte Linie von links nach rechts über
die Punkte aus P gleiten zu lassen und sich in der Vertikalstruktur den
Schnitt der Sweep line mit dem aktuellen Voronoi-Diagramm zu merken.
Jeder neu entdeckte Punkt würde dann ein Einfügeereignis und
jeder Schnitt zweier auf der Sweep line benachbarter Voronoi-Kanten
ein Schnittereignis (und ggf. ein Löschereignis) bewirken.
Problem bei der Das Problem hierbei ist allerdings, daß sich zum einen bei einem Ein-
Sweep-line-Methode fügeereignis – also beim Entdecken eines neuen Punktes – das Voronoi-
Diagramm auch links der Sweep line ändert (siehe Abbildung 8.4), und
zum anderen überhaupt nicht klar ist, wann für solche verspätet hinzugekommenen
Voronoi-Kanten (links der Sweep line) das zugehörige
Schnittereignis abgearbeitet werden soll – zu dem Zeitpunkt, an dem
die Sweep line den Schnittpunkt passiert, ist dieser ja noch gar nicht bekannt.

8.4 Konstruktion des Voronoi-Diagramms 101
Aus diesem Grund wenden wir das Sweep-Paradigma in leicht abgewandelter
Form auf unser Problem an: Anstatt uns in der Vertikalstruktur
die Schnittmenge des aktuellen Voronoi-Diagramms mit der Sweep
line zu merken, verwalten wir besser gleich nur denjenigen Teil des
Voronoi-Diagramms links der Sweep line, der sich garantiert nicht mehr
ändern kann, d. h. der von Punkten rechts der Sweep line unbeeinflußt
bleibt.
Der Teil des Voronoi-Diagramms, welcher sich nicht mehr ändern kann,
besteht offenbar aus allen Punkten der Ebene, deren Abstand zu irgendeinem
der Punkte pi ∈ P links der Sweep line geringer ist als ihr Abstand
zur Sweep line selbst. Da der Bisektor eines Punktes und einer
Geraden eine Parabel ist, besteht die Grenze dieses Bereichs – die sog.
Wellenfront oder Küstenline (engl. beach line) – also aus einer Menge von
Parabelstücken. Für die Wellenfront kann man nun zeigen, daß sie zum
einen wegzusammenhängend und zum anderen y-monoton ist, d. h. jede
horizontale Linie schneidet sie nur in höchstens einem Punkt. Nur
diese Wellenfront sollten wir in der Vertikalstruktur verwalten. Wellenfront
Die Punkte, in denen zwei benachbarte Parabelstücke der Wellenfront
zusammenstoßen, liegen genau auf den Voronoi-Kanten von VD(P).
Wenn nun die Sweep line nach rechts wandert, ändert sich die Wellenfront
kontinuierlich und es können zwei Ereignisse auftreten, welche die
Struktur der Wellenfront beeinflussen:
1. Ein Parabelstück der Wellenfront verschwindet, d. h. die Endpunkte
der beiden Nachbarstücke stoßen zusammen. Dies bedeutet,
daß wir an der Stelle, an der die Endpunkte zusammengestoßen
sind, einen Voronoi-Knoten entdeckt haben, der sich im weiteren
Verlauf nicht mehr ändert und den wir zu VD(P) hinzunehmen
können. Das entsprechende Parabelstück können wir aus der
Vertikalstruktur entfernen.
2. Ein neues Parabelstück erscheint. Dies passiert genau dann, wenn
die Sweep line einen neuen Punkt pi ∈ P passiert. In einem solchen
Fall muß die Vertikalstruktur (also die Folge der Parabelstücke)
entsprechend aktualisiert werden.
Dies ist die Grundidee des Sweep-line-Algorithmus. Die Feinheiten
wie z. B. eine sinnvolle Verwaltung der Vertikalstruktur, die Berechnung
der Ereigniskoordinaten usw. finden sich beispielsweise in [5, S. 149]
und [14, S. 286].
Zusammenfassend erhalten wir dann folgenden Satz:
Satz 8.17 Für eine Menge von n Punkten p1, . . . , pn ∈ E 2 kann deren
Voronoi-Diagramm mittels der Sweep-line-Methode bei linearem
Speicherbedarf mit einem optimalen Zeitbedarf von Θ(n log n) bestimmt
werden.
Zeitbedarf von Θ(n log n)
für Sweep-line-Methode

102

Abkürzungen
A
Abkürzungen und Symbole
CAD engl. computer aided design
CAM engl. computer aided manufacturing
DCEL engl. doubly connected edge list (s. S. 63)
FTS Fahrerloses Transportsystem
GIS Geographisches Informationssystem
NP alle von einem nichtdeterministischen Algorithmus in polynomieller Zeit lösbaren
Probleme (s. S. 18)
O. B. d. A. Ohne Beschränkung der Allgemeinheit
P alle von einem deterministischen Algorithmus in polynomieller Zeit lösbaren Probleme
(s. S. 18)
PSLG engl. planar straight line graph (s. S. 62)
PSPACE alle von einem deterministischen Algorithmus mit polynomiellem Speicherbedarf
lösbaren Probleme (s. S. 18)
Symbole
A die abgeschlossene Hülle der Menge A (s. S. 6)
∀ der Allquantor
a �z b die angulare Ordnung der Punkte a und b bez. des Strahls [0 z} (s. S. 29)
a � b die angulare Ordnung der Punkte a und b bez. der positiven x-Achse (s. S. 30)
B(p, q) der Bisektor der Punkte p und q (s. S. 90)
B + (v) das von der Ecke v ausgehende Pfeilbüschel (s. S. 11)
B − (v) das in die Ecke v mündende Pfeilbüschel (s. S. 11)
ccw(p, q, r) die Counter-clockwise-Funktion der drei Vektoren p, q, r (s. S. 27)
U ε(x) die ε-Umgebung von x (s. S. 6)
U R ε (x) die ε-Umgebung von x in R (s. S. 8)
|x y| der euklidische Abstand der Punkte x und y im E d (s. S. 5)
E d der d-dimensionale euklidische Raum (s. S. 5)
∃ der Existenzquantor
p q die Gerade durch die Punkte p und q (s. S. 23)

104 Abkürzungen und Symbole
g(v) der Grad der Ecke v (s. S. 11)
g + (v) der Außengrad der Ecke v (s. S. 11)
g − (v) der Innengrad der Ecke v (s. S. 11)
O(g) alle Funktionen höchstens von der Größenordnung von g (s. S. 16)
Ω(g) alle Funktionen mindestens von der Größenordnung von g (s. S. 16)
Θ(g) alle Funktionen genau von der Größenordnung von g (s. S. 16)
o(g) alle Funktionen von geringerer Größenordnung als g (s. S. 16)
H + (n, a) die positive Halbebene zu einer Geraden g(n, a) (s. S. 24)
H− (n, a) die negative Halbebene zu einer Geraden g(n, a) (s. S. 24)
A ◦
[a, b]
das Innere oder der offene Kern der Menge A
das geschlossene Intervall { x ∈ R
(s. S. 6)
� � a ≤ x ≤ b }
[a, b) das halboffene Intervall { x ∈ R � � a ≤ x < b }, analog auch (a, b]
(a, b) das offene Intervall { x ∈ R � � a < x < b }
|A| die Kardinalität der Menge A
ker(P) der Kern des Polygons P (s. S. 40)
α(si, si+1) Knickwinkel zweier aufeinanderfolgender Segmente einer polygonalen Kette
(s. S. 34)
CH(A) die konvexe Hülle der Menge A (s. S. 34)
|x| die (euklidische) Länge des Vektors x ∈ E d
tA(n) die Worst-case-Laufzeit von Algorithmus A (s. S. 18)
∅ die leere Menge
Lp(x, y) die Minkowski-Metrik für 1 ≤ p ≤ ∞ (s. S. 6)
N(v) die Nachfolgermenge der Ecke v (s. S. 11)
N die Menge der natürlichen Zahlen, N := {0, 1, 2, . . . }
¬ das logische »nicht«
g(n, a) die Normalenform einer Geraden g (s. S. 23)
G ⊒ G ′ Graph G ist ein Obergraph von G ′ (s. S. 12)
∨ das logische »oder«
GR ′ der durch R ′ induzierte Partialgraph (s. S. 12)
∂A der Rand der Menge A (s. S. 6)
Π1 �τ Π2 Problem Π1 ist auf Π2 τ-reduzierbar (s. S. 19)
R die Menge der reellen Zahlen
vis(p) das Sichtbarkeitspolygon von p (s. S. 39)
sgn(x) das Vorzeichen (lat. signum) von x, sgn(x) ∈ {−1, 0, 1}
〈x, y〉 das kanonische Skalarprodukt der beiden Vektoren x und y im R d (s. S. 6)
sA(n) der Worst-case-Speicherbedarf von Algorithmus A (s. S. 18)
[p q} der Strahl von p aus in Richtung q, analog auch {p q] (s. S. 23)
[p q] die Strecke zwischen den Punkten p und q (s. S. 23)
G[V ′ ] der durch V ′ induzierte Subgraph (s. S. 12)
G ′ ⊑ G Graph G ′ ist ein Teilgraph von G (s. S. 12)
∧ das logische »und«
a × b das Vektorprodukt zweier Vektoren a und b (s. S. 26)

V(v) die Vorgängermenge der Ecke v (s. S. 11)
�w eine Parametrisierung eines Weges w (s. S. 8)
105

106

Literaturverzeichnis
[1] F. Aurenhammer, R. Klein. Voronoi Diagrams. Technischer Bericht TR 198, Department of
Computer Science, FernUniversität Hagen, 1996.
[2] J. L. Bentley, T. A. Ottmann. Algorithms for Reporting and Counting Geometric Intersections.
IEEE Transactions on Computers, C-28:643–647, 1979.
[3] B. Chazelle. Triangulating a Simple Polygon in Linear Time. Discrete and Computational Geometry,
6:485–524, 1991.
[4] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rives. Introduction to Algorithms.
MIT Press, 6th edition, 1992.
[5] Mark de Berg, Marc van Kreveld, Mark Overmars, Otfried Schwarzkopf. Computational Geometry:
Algorithms and Applications. Springer, 1997.
[6] D. P. Dobkin, R. J. Lipton. Multidimensional Searching Problems. SIAM Journal on Computing,
5:181–186, 1976.
[7] M. E. Dyer. Linear Time Algorithms for Two- and Three-Variable Linear Programs. SIAM
Journal on Computing, 13:31–45, 1984.
[8] Herbert Edelsbrunner. Algorithms in Combinatorial Geometry. Springer, Berlin Heidelberg, 1987.
[9] Otto Forster. Analysis 2. Vieweg, Braunschweig, 5th edition, 1984.
[10] Michael R. Garey, David S. Johnson. Computers and Intractability (A Guide to the Theory of NP-
Completeness. W. H. Freeman and Company, 1979.
[11] Klaus Jänich. Topologie. Springer, 5th edition, 1996.
[12] Dieter Jungnickel. Graphen, Netzwerke und Algorithmen. BI Wissenschaftsverlag, 2nd edition,
1990.
[13] David G. Kirkpatrick. Optimal Search in Planar Subdivisions. SIAM Journal on Computing,
12:28–35, Februar 1983.
[14] Rolf Klein. Algorithmische Geometrie. Addison-Wesley, 1997.
[15] Sven Oliver Krumke. Graphentheoretische Konzepte und Algorithmen. ������������������
��������������������������������� , 1997. (Skript zur Vorlesung im Sommersemester 1997,
Universität Würzburg).

108 Literaturverzeichnis
[16] N. Megiddo. Linear-Time Algorithms for Linear Programming in R 3 and Related Problems.
SIAM Journal on Computing, 12:759–776, 1983.
[17] James R. Munkres. Topology: a first course. Prentice-Hall, 1975.
[18] Hartmut Noltemeier. Graphentheorie: mit Algorithmen und Anwendungen. de Gruyter, Berlin,
1975.
[19] Joseph O’Rourke. Computational Geometry in C. Cambridge University Press, 2nd edition, 1998.
[20] J. Pach, M. Sharir. On Vertical Visibility in Arrangements of Segments and the Queue Size in
the Bentley-Ottmann Line Sweeping Algorithm. SIAM Journal on Computing, 20:460–470, 1991.
[21] Christos H. Papadimitriou. Computational Complexity. Addison-Wesley, 1994.
[22] Franco P. Preparata, Michael Ian Shamos. Computational Geometry: An Introduction. Springer,
New–York, 2nd edition, 1985.
[23] Boto von Querenburg. Mengentheoretische Topologie. Springer, 1979.