Lösung

S: Seitenlänge
h: Höhe
c: Diagonale
k: Tiefe

Gesucht: c

Wenn man die Tiefe nicht bei 0, sondern bei 1 beginnen lässt, so kommet man auf:

Anzahl der Knoten des Baums: O(n)

Tiefe:

Gesamtaufwand:

Lösung

public class Suche {
	public static void main(String[] args) {
		double x[] = {10, 12, 50, 5, 13, 6, 8, 11};
		double Min = Double.POSITIVE_INFINITY;
		double LastMin = Double.NEGATIVE_INFINITY;
		int m = 3;
		int n = x.length;
		for (int j = 0; j < m ; j++){
			for (int i = 0; i < n ; i++)
				if (x[i] < Min && x[i] > LastMin)
					Min = x[i];
			LastMin = Min;
			Min = Double.POSITIVE_INFINITY;
			System.out.print(LastMin+" ; ");
		}
	}
}

Liefert: 5.0 ; 6.0 ; 8.0 ;

Rechenzeitkomplexität wäre allerdings:

Ein besserer Algorithmus hat den Aufwand n:

sortiere den Vektor x im Bereich [0, m]
für i = m bis n
	tausche x[i] mit x[m]
	j = m
	solnge j > 0 und x[j-1] > x[j]
		tausche x[j-1] mit x[j]
		-- j

Lösung

Sei folgende Kantenliste gegeben:

Damit erhält man folgenden Graphen:

Mit Hilfe der Tiefensuche (LiFo) ermittelt man nun die Reihenfolge, in der die Knoten gefunden werden:

Lösung

Der Unterschied der Höhen h_links und h_rechts der beiden Nachfolger-Teilbäume eines Knotens soll minimiert werden.

Hier ist h_rechts-h_links = -2. Dies muss verbessert werden. Die Idee hinter selbstbalancierten Binärbäumen (AVL-Bäume nach Adelson-Velsky-Landis) ist es, in jedem Knoten ein Balancekriterium zu speichern. Dieser Wert wird berechnet mit der Formel bal = h_rechts-h_links.
Zulässige Werte für bal sind nur {-1, 0, 1}, das heißt der linke und der rechte Teilbaum eines Knotens dürfen sich höchstens um 1 in der Höhe unterscheiden.

Es kann nachgewiesen werden, dass in diesem Fall der Aufwand zum Einfügen eines neuen Knotens nur O(log n) ist.

Beispiel:

1. bis 3. Knoten einfügen:

4. und 5. Knoten einfügen:

Operationen in AVL-Bäumen

Einfügen neuer Knoten mit insert

Wenn wir einen neuen Knoten einfügen, gehen wir wie beim normalen Binärbaum vor. Jedoch wird rückwärts, vom neuen Knoten aus, dem vorausgehende Knoten mitgeteilt, dass der entsprechende Teilbaum gewachsen ist.
bal erhöht oder verringert sich dadurch um 1. Wenn sich bal nicht mehr im zulässigen Wertebereich befindet, muss der Baum lokal umgebaut werden. Der Funktion wird wie beim Binärbaum der Schlüssel des neuen Elementes übergeben, sowie die Stelle, an der das Element eingefügt werden soll. Beim Aufruf durch den Benutzer ist dies der Wurzelknoten. Programmintern wird die Funktion dann im weiteren Verlauf rekursiv von sich selbst mit einem anderen Parameter für t aufgerufen.
Im ersten Schritt wird geprüft, ob an der Stelle t schon ein Knoten existiert. Wenn nicht, wird an genau dieser Stelle der neue Knoten erzeugt. Wenn der Knoten t schon existiert, muss geprüft werden, ob der neue Knoten als linker oder als rechter Nachfolger in Frage kommt. Hierfür wird der übergebene Schlüssel mit dem Schlüssel des Knotens t verglichen. An dieser Stelle wollen wir nun vier verschiedene Fälle untersuchen, die beim Einfügen des Knotens auf der linken oder der rechten Seite auftreten können.

Fall 1:

Durch das Einfügen des neuen Knotens wird der linke Arm zu lang. Diese Situation ist der “Left-Left-Case”. Das Problem wird behoben durch eine einfache Rotation nach rechts:

Der linke Teilarm (Element 2) wird dabei einfach mitgezogen. Da auf dieses linke “Kind” geachtet werden muss, wird die Rotation “rotateWithLeftChild” genannt.

Fall 2:

Durch das Einfügen des neuen Knotens wird der linke Arm zu lang. Dieser Fall (Right-Right-Case) ist analog zu Fall 1. Hier wird also auch das Problem mit der gleichen Herangehensweise gelöst: Der Baum wird nach links rotiert mit der Funktion “rotateWithRightChild”

Fall 3:

Durch das Einfügen des neuen Knotens wird der linke Arm zu lang, allerdings ist der neue Knoten nun nicht linker Nachfolger, sondern rechter Nachfolger. Hier kann der Baum nicht einfach nach rechts rotiert werden, denn dann wäre der Knoten 3 an der Stelle der Wurzel. Sowohl Knoten 4 als auch Knoten 5 haben aber einen größeren Schlüsselwert als Knoten 3, deshalb hätte Knoten 3 zwei rechte Nachfolger. Es muss jedoch immer einen linken und einen rechten Nachfolger geben.

Die Lösung des Problems ist eine doppelte Rotation. Zuerst wird eine lokale Rotation nach links durchgeführt, anschließend folgt eine Rotation nach rechts, wobei das linke “Kind” mitgezogen wird:

Knoten 4 ist nun die neue Wurzel, er hat einen linken und einen rechten Nachfolger und der Baum ist wieder ausbalanciert. Die Funktion, die diesen beiden Rotationen kombiniert, ist “doubleWithLeftChild”.

Fall 4:

Durch das Einfügen des neuen Knotens wird der rechte Arm zu lang, allerdings ist der neue Knoten nun nicht rechter Nachfolger, sondern linker Nachfolger. Dies ist analog zu 3.

Löschen eines Knotens

Es gibt zwei Varianten, einen Knoten aus einem Binärbaum zu löschen.

Erste Möglichkeit:

Der linke Nachfolgerbaum wird an die Stelle des gelöschten Knotens gesetzt. Der rechte Nachfolgerbaum wird an den untersten rechten Knoten des linken angehängt. Anschließend muss mit den oben beschriebenen Rotationen die Balance des Baumes wiederhergestellt werden.

Zweite Möglichkeit:

Der zu löschende Knoten wird durch das kleinste Element des rechten Nachfolgerbaumes ersetzt (im Fall oben wäre dies der Knoten F). Dieses Element lässt sich finden, indem man im rechten Baum immer dem linken Weg nach unten folgt, bis es nur noch einen Weg nach rechts oder gar keinen Weg mehr gibt. Diese Möglichkeit des Löschens verhindert, dass sich die Geometrie des Baumes stark ändern kann, es müssen daher nicht viele, sondern höchstens eine Rotation zur Balancierung durchgeführt werden.

Rechenaufwand

Die Links- und Rechtsrotationen sind alle lokale Operationen mit dem Aufwand O(1). Als obere Abschätzung kann man sagen, dass schlimmstenfalls bei jedem Einfügen eine Rotation durchgeführt werden muss. Dieser schlimmste Fall kann aber mathematisch nachweislich nicht auftreten, der Rechenaufwand zum Einfügen eines Knotens geht nicht über O(log n) hinaus.

Der Rechenaufwand, um den gesamten Baum aufzubauen ist somit O(n log n), das Optimum für einen Binärbaum.
Der fertig aufgebaute AVL-Baum ist ein perfekter Binärbaum, in dem mit minimalem Aufwand eine sortierte Traversierung durchgeführt werden kann. Zusätzlich ist der AVL-Baum eine dynamische Datenstruktur (Vorteile gegenüber statischen Feldern). Somit ist der AVL-Baum auch ein optimales Sortierverfahren.

Lösung

Die maximale Tiefe wäre n:

Die geometrische Lage der Punkte müsste für die maximale Tiefe so aussehen, dass der jeweils eingefügte Punkt stets unten rechts (oder auch in andere Diagonalrichtungen) von den vorher eingezeichneten Trennlinien liegt.

Aufbau der Klasse k-d-Tree:

Einfügen in einen k-d-Baum

Für den ersten Punkt: Erzeuge Blatt

Neuen Punkt einfügen:(vs: Startknoten, xp: x-Wert des Punktes; xv: x-Wert des Knotens)

Prozedur Einfügen(vs)
Wenn Tiefe gerade:
Wenn xp < xv
		Wenn linker Teilbaum existiert
			Einfügen(xv.links)
		Sonst
			Erzeuge neues Blatt(links)
Wenn xp > xv
		Wenn rechter Teilbaum existiert
			Einfügen(xv.rechts)
		Sonst
			Erzeuge neues Blatt(rechts)
Sonst: Selbes mit xp und yv

Lösungsvorschlag

Bekannte Sortieralgorithmen:

• Selectionsort
• Quicksort
• Bubblesort
• Mergesort

Selection Sort:

Idee: Starte beim ersten Element. Suche ein Element, das kleiner ist als das Startelement und tausche die beiden. Verfahre mit den restlichen ebenso.

Beispiel:

Dieses Verfahren ist allerdings nicht stabil.

Bsp:

Damit sind 13a und 13b in ihrer Reihenfolge vertauscht worden!

Quicksort:

Idee: „Teile und herrsche!“. Partitionieren in zwei Teilmengen mit je n/2 Einträgen anhand eines Pivot-Elements. Diese rekursiv wieder Partitionieren.
Dieses Verfahren ist allerdings auch nicht stabil.

Bsp:

Bubblesort:

Idee: Benachbarte Elemente werden getauscht, wenn z.B. das rechte kleiner ist, als das linke.

Dieses Verfahren ist stabil, da immer nur benachbarte Elemente getauscht werden. Es ist also nicht möglich, dass 13a und 13b vertauscht werden.

Mergesort:

Idee: Ebenfalls „Teile und herrsche!“, allerdings wird je in Listen aufgeteilt, die dann für sich sortiert werden und dann in einem Reißverschlussverfahren wieder zusammengefügt werden.
Damit ist Mergesort ebenfalls stabil, sofern der Merge-Schritt geeignet implementiert wird.

1. davon ausgeht, dass die Koordinaten der Anschlussstellen und Kreuzungen bekannt sind?
2. davon ausgeht, dass nur das Netz und die Streckenlängen zwischen den Anschlussstellen gegeben sind?

Lösung

Es handelt sich hierbei um ein Problem aus der Graphentheorie: „Finde den kürzesten Weg!“
Das Straßennetz muss also zunächst wie in der Abbildung links als Graph dargestellt werden, dessen Kanten als Gewichte die Mautkosten haben.
Der Graph muss anschließend möglichst zielgerichtet traversiert werden. Es gibt verschiedene Algorithmen zur Traversierung, die aber vom Grundlegenden Aufbau her alle gleich sind. Die Knoten werden zu Beginn in eine Menge U (unbekannt) geschrieben, der Startknoten wird in eine Menge A (aktiv) übernommen. Dann werden nach und nach die erreichbaren Knoten von U nach A geschoben und untersucht. Knoten, deren Nachbarn alle schon betrachtet wurden, wandern in die Menge F (fertig):

für alle Knoten v aus V
	v.status = unbesucht
A.einfügen(vstart)
solange A.anzahl() > 0 wiederhole
	v = A.entferneEinenKnoten()
	für alle Nachbarknoten w von v
		falls w.status == unbesucht
			w.status = aktiv
			A.einfügen(w)
	v.status = erledigt

Die verschiedenen Algorithmen unterscheiden sich nun vor allem in der Auswahl des Knotens beim Befehl „entferneEinenKnoten“ und bei der Reihenfolge der Knoten im Befehl danach.

Tiefensuche

Die Tiefensuche verwaltet die Menge A als einen Stapel. Der Knoten, der zuletzt gefunden wurde, wird also als erstes besucht („last in, first out“). Algorithmus:

für alle Knoten v aus V
	v.status = unbesucht
Stapel A.push(vstart)
solange A.anzahl() > 0 wiederhole
	v = A.pop()
	für alle Nachbarknoten w von v
		falls w.status == unbesucht
			w.status = aktiv
			A.push(w)
	v.status = erledigt

Breitensuche

Bei der Breitensuche wird die Menge A als Warteschlange verwaltet. Daraus resultiert, dass die Knoten in der Reihenfolge besucht werden, in der sie gefunden wurden (first in first out).
Der Algorithmus ist ansonsten der gleiche. Damit die Wege später nachvollzogen werden können, muss bei der Traversierung in jedem Knoten der Vorgänger gespeichert werden.
Sollen nicht alle Wege im Graphen, sondern nur ein bestimmter, gefunden werden, kann der Algorithmus vorzeitig abgebrochen werden.

Dijkstra

Um nun statt nur irgend einen Weg den kürzesten Weg zu finden, brauchen wir eine Steuerungsfunktion, die jeweils ein passendes Element aus der Menge A aussucht. Als Bewertungsfunktion nutzt man im Dijkstra-Verfahren die aufsummierten Kantengewichte der Kanten, die auf dem bisher zurückgelegten Weg liegen. Wir ordnen also jedem erreichbaren Knoten als „Abstand vom Startknoten“ den Abstand seines Vorgängers v vom Startknoten, zuzüglich des Gewichtes der Kante vw, zu. Das System funktioniert nur, wenn alle Kantengewichte größer oder gleich 0 sind (bei der Routensuche automatisch erfüllt). Wenn ein Knoten zum ersten Mal eine Bewertung erhält, ist noch nicht sicher, dass dies die minimal mögliche ist. Es könnte sein, dass der Knoten später noch auf einem kürzeren Weg vom Startknoten aus erreicht wird. Daher ist die Bewertungen der Knoten in der Menge A variabel:

für alle Knoten v aus V
	v.status = unbesucht
	v.vorgänger = NULL
	f(v) = INF
A.einfügen(vstart)
f(vstart) = 0
solange A.anzahl() > 0 wiederhole
	v = A.entferneKnotenF_min()
	für alle Nachbarknoten w von v
		falls w.status == unbesucht
			w.status = aktiv
			w.vorgänger = v
			f(w) = f(v)+KantenGewicht(v,w)
			A.einfügen(w)
		sonst // w schon bekannt
			falls f(v)+KantenGewicht(v,w) < f(w)
			w.vorgänger = v
			f(w) = f(v)+KantenGewicht(v,w)
	v.status = erledigt

A*-Algorithmus

Der größte Nachteil des Dijkstra-Verfahrens ist, dass der Graph nicht zielgerichtet durchsucht wird. Wie bei der Breitensuche geht man sternförmig vom Startknoten aus. Eine Weiterentwicklung des Dijkstra-Algorithmus ist der A*-Algorithmus. Es handelt sich bei diesem um ein 1968 von Peter Hart, Nils Nilsson und Bertram Raphael entwickeltes „informiertes“ Suchverfahren. Im Gegensatz zu Dijkstra wird bei der Suche nicht der Knoten mit den geringsten Wegkosten zum Startknoten besucht, sondern der am günstigsten erscheinende.
Die Abbildung zeigt einen Graphen mit zehn von A bis J bezeichneten Knoten und elf ungerichteten gewichteten Kanten. Die Wegkosten entsprechen den grünen Zahlen, die blauen Zahlen repräsentieren zum Vergleich die Luftlinienentfernung zwischen den Knoten. In der linken unteren Ecke sind die Luftlinienentfernungen aller Knoten zu A angegeben.
Wenn wir als Mensch in diesem Graphen den kürzesten Weg von I nach A suchen sollten, würden wir spontan in Richtung F losgehen, weil es unlogisch erschiene, J oder G zu besuchen. Das liegt daran, dass F dem Zielknoten viel näher ist (32 Einheiten) als die beiden anderen Knoten (jeweils 60 Einheiten). Doch wie machen wir diese Logik dem Computer verständlich? Die Lösung ist eine so genannte Heuristik.

„Heuristik ist die Bezeichnung für ein Lösungsverfahren, das nur zum Teil auf wissenschaftlich gesicherten Erkenntnissen, sondern vorwiegend auf Hypothesen, Analogien oder Erfahrungen aufbaut. Die Güte solcher Verfahren ist deshalb meist nicht beweisbar, sondern wird durch wiederholte Experimente an typischen Problemstellungen nachgewiesen.“

Besonders wichtig ist der letzte Satz dieser Definition. Es ist nämlich nicht zu beweisen, dass durch die Verwendung der Luftlinie als Entscheidungsgrundlage für den als nächsten zu besuchenden Knoten der Weg schneller gefunden wird. Da die in der Informatik verwendeten Graphen allerdings meist nicht willkürlich gewählt werden, sondern Darstellungen realer Gegebenheiten sind, gehorchen sie denselben Gesetzen wie die zu modellierenden Objekte. Es ist logisch, dass in einem eine Landkarte darstellenden Graphen die meisten Kantengewichte stark von der Luftlinienentfernung abhängen, obwohl dies nicht zwingend notwendig ist.
Funktion für die Luftlinienentfernung zwischen einem Knoten und dem Zielknoten:

Diese wird nun zu der schon bei Dijkstra verwendeten Funktion addiert, die einem Knoten die bekannten Wegkosten vom Startknoten nach zuordnet:

muss nun als Kriterium für den jeweils als nächstes zu besuchenden Knoten benutzt werden. Das geschieht, indem dieser Knoten nach dem Kriterium gewählt wird. Hier nun ein Beispiel, um die beschriebene Arbeitsweise zu verdeutlichen.

Beispiel: Berechnung des in der Abbildung gesuchten Weges

Es werden zuerst von den drei an den Startknoten angrenzenden Knoten sowohl die Kantengewichte zum Startknoten I als auch die Luftlinien-entfernungen zum Zielknoten A bestimmt und jeweils die Summe daraus gebildet.
Der Dijkstra-Algorithmus würde nun als erstes Knoten J besuchen, da dieser die kleinsten Wegkosten zum Startknoten hat, und liefe damit genau in die falsche Richtung.
Beim A*-Algorithmus ist das Kriterium die berechnete Summe aus Wegkosten und Luftlinie. Daher wird im ersten Schritt Knoten F besucht. Im zweiten Schritt werden alle Knoten überprüft, die von einem der schon besuchten Knoten aus erreicht werden können (also von I oder von F). Das sind die Knoten B, E, G, H und J. Wieder werden die Summen aus Wegkosten und Luftlinienentfernung gebildet und verglichen:

Diese Summe ist bei Knoten B minimal, daher wird er im zweiten Schritt besucht. Im dritten Schritt steht der Algorithmus vor der Wahl zwischen den Knoten E, G, H, J und A. Da A der Zielknoten ist, könnte man meinen, er würde als nächstes besucht, so dass der Weg komplett wäre. Auch die Luftlinienentfernung von Knoten A zu sich selbst, nämlich 0, spricht dafür. Doch der Weg I-F-B-A wäre 75 Einheiten lang. Bei Betrachtung der folgenden Tabelle fällt auf, dass es einen potentiell kürzeren Weg gibt, nämlich über I-F-E. Dieser wäre im Optimalfall (der restliche Weg ab Knoten E entspricht der Luftlinienentfernung von E zu A) nur 63 Einheiten lang, also 12 Einheiten kürzer als der Weg über B.

Da allein die Summe das Kriterium für den als nächstes zu besuchenden Knoten ist, fällt die Wahl auf Knoten E.

Der Weg über die Knoten E und D hat die geringste Summe aus Wegkosten nach I und Luftlinie nach A. Es gibt also einen potentiell kürzeren Weg von I nach A, der über diese beiden Knoten statt über B führt. Auch wenn der optimale Weg über E und D nun „nur noch“ zwei Einheiten kürzer ist als der schon sichere Weg über B, muss er weiter verfolgt werden. Im vierten Schritt wird D besucht.

Der kürzeste Weg ist gefunden. Es ist I-F-E-D-A mit der Länge 74, also genau eine Einheit weniger als der Weg über den Knoten B gehabt hätte. Hier wird deutlich, dass es wichtig ist, dass die Schätzfunktion die Länge des optimalen Weges von einem Knoten zum Ziel immer unterschätzt, da sonst vielleicht der Weg über B als kürzester gefunden worden wäre, obwohl er nicht optimal ist. Die Luftlinienentfernung als Heuristik zu benutzen ist zulässig, da der kürzeste Weg immer mindestens so lang oder länger als die Luftlinie sein muss.

Optimalitätsbeweis

Ob die optimale Lösung gefunden wird, hängt zuerst einmal davon ab, ob die verwendete Heuristik zulässig ist, ob sie also wie schon beschrieben die Wegkosten immer unterschätzt. Wenn diese Bedingung erfüllt ist, kann bewiesen werden, dass die Lösung immer optimal ist.
Im Folgenden werden die folgenden Funktionen verwendet:

• ordnet dem Knoten die bisher vom Startknoten aus benötigten Wegkosten zu
• schätzt die Wegkosten vom Knoten zum Zielknoten
• schätzt somit die Gesamtkosten vom Start- zum Zielknoten

Bedingt durch die Vorgehensweise des Algorithmus wird immer zuerst der Knoten besucht, dem die Funktion den geringsten Funktionswert zuordnet. Wenn also zum Beispiel für einen Knoten gilt: , dann werden zuerst alle Knoten weiter erkundet, für die gilt: . Dadurch ist sichergestellt, dass kein Knoten bei der Wegfindung ausgelassen werden kann, über den ein kürzerer Weg zum Ziel möglich wäre. Hier wird auch klar, warum die Kantengewichte nicht negativ sein dürfen, denn sonst könnte nach einem weit vom Ziel entfernten und daher nicht weiter beachteten Knoten noch eine Kante mit einem hohen negativen Kantengewicht kommen, die den schlecht anmutenden Weg dann doch zum kürzesten macht. Aus diesen Überlegungen ergibt sich der formale Beweis:

Annahme: Der A*-Algorithmus findet eine suboptimale Lösung , wobei die optimale Lösung die Wegkosten hat.
Für jeden vom Algorithmus gefundenen Zielknoten gilt , daraus folgt:

Außerdem gilt:

Da für jeden beliebigen Knoten gilt:

folgt für einen Knoten auf dem kürzesten Pfad zum optimalen Ziel :

Diese beiden Gleichungen kann man nun zu der folgenden zusammenfassen:

Das bedeutet aber, dass der Knoten gar nicht besucht wird, bevor die optimale Lösung gefunden wurde, es wird also zuerst gefunden, das Verfahren ist optimal, q.e.d.

Lösung

Die Aufgabenstellung ist es, eine Menge P an Punkten zu einer dreidimensionalen Oberfläche zu verbinden. Zu diesem Zweck könnte man die Fläche um je einen Punkt auf die Höhe des Punktes heben. Dadurch würde das Terrain allerdings diskret werden, es gäbe zwischen den Höhenstufen senkrechte Absätze, was nicht besonders realistisch ist. Stattdessen sollen die Punkte zu Dreiecken verbunden werden. Das Problem löst man durch eine Delaunay-Triangulierung in der Ebene, anschließend werden die Punkte auf ihre jeweilige Höhe gehoben, wobei die Verbindungslinien erhalten bleiben. So entsteht ein vielflächiges Terrain, der Graph einer stetigen stückweise linearen Funktion.
Die Frage ist nun, wie in der Ebene die Punkte am günstigsten zu Dreiecken verbunden werden können. Welche Art der Verbindung am realistischsten ist, kann nicht festgestellt werden, da wir nur die gemessenen Punkte, nicht aber das wirkliche Terrain als Vergleich kennen. Trotzdem wirken manche Triangulierungen natürlicher als andere:

Von den Werten her könnten die schwarzen Punkte einen Bergrücken beschreiben. Triangulierung a unterstützt diese Vorstellung, da der neue Punkt etwa die gleiche Höhe hat. Bei Triangulierung b gibt es einen scharfen Schnitt in der Kette, der neue Punkt ist auf dem Niveau der äußeren Punkte, was unnatürlich wirkt. Das hier auftretende Problem ist, dass die Höhe des neuen Punktes im Fall b von zwei weit entfernten Punkten bestimmt wird. Das wird dadurch deutlich, dass die Winkel der beiden neuen Dreiecke klein sind.
Es gibt eine endliche Anzahl an Möglichkeiten zur Triangulierung, wobei die Anzahl m der Dreiecke immer gleich ist. Gesucht ist die optimale Triangulierung. Diese zeichnet sich dadurch aus, dass der Winkelvektor maximal ist.
Ein beliebiges Viereck kann auf genau zwei Arten in Dreiecke zerlegt werden (zwei Diagonalen). Die optimale Variante zeichnet sich dadurch aus, dass der kleinste auftretende Winkel größer ist als in der alternativen Triangulierung:

Die Kante ist illegal, da die „geflippte“ Kante zu einem größeren kleinsten Winkel führt. Um zu vermeiden, für jede Version sechs Winkel messen zu müssen, nutzen wir ein Kriterium, dass uns direkt sagt ob eine Kante illegal ist, ohne dass wir die alternative Triangulierung bilden müssen. Hierzu nutzen wir den Satz von Thales in der allgemeinen Form:

Sei ein Kreis, eine Sekante und die Schnittpunkte. Dann ist der sich an einem dritten Punkt ergebene Winkel des Dreiecks abhängig von der Position von :

( innerhalb des Kreises, auf dem Kreis, außerhalb des Kreises)

Das Kriterium ist also, dass bei einer legalen Triangulierung kein Punkt im Umkreis eines Dreiecks anderer Punkte liegen darf. Der Algorithmus zu Delaunay-Triangulierung funktioniert wie folgt: Alle Punkte werden zunächst zufällig permutiert. Anschließend wird der höchste Punkt (z.B. größte y-Koordinate) ermittelt und mit zwei weit entfernten, nicht in der Menge der Punkte enthaltenen Hilfspunkten verbunden, so dass die gesamte Punktwolke innerhalb des entstandenen Dreiecks liegt. Dadurch werden Probleme am Außenrand der Triangulierung verhindert.
Die Punkte werden dann nacheinander dem Graph hinzugefügt, wobei das Delaunay-Kriterium immer aufrecht erhalten wird. Abschließend werden die beiden Hilfsknoten einschließlich aller inzidenten Kanten aus dem Graph gelöscht.

Algorithmus in Pseudocode:

für r = 1 bis n
	Finde das Dreieck p_ijk, das p_r enthält.
	wenn p_r im Inneren des Dreiecks p_ijk liegt
		dann füge die Kanten von p_r zu p_i, p_j und p_k dem Graphen hinzu,
		so dass das alte Dreieck in drei neue aufgeteilt wird.
		LegalizeEdge(p_r, p_ij)
		LegalizeEdge(p_r, p_jk)
		LegalizeEdge(p_r, p_ki)
	sonst // Punkt liegt auf Kante von Dreieck
		teile beide an die Kante angrenzenden Dreiecke in zwei neue.
		LegalizeEdge(p_r, p_il)
		LegalizeEdge(p_r, p_lj)
		LegalizeEdge(p_r, p_jk)
		LegalizeEdge(p_r, p_ki)

Es gibt mehrere Möglichkeiten, den ersten Befehl („finde das Dreieck“) zu implementieren.

1. Nutzung einer QuadEdge Datenstruktur

Vom zuletzt eingefügten Punkt aus wird zunächst ein Orientierungstest gemacht, um im Beispiel links das Dreieck sab zu bestimmen. Anschließend wird die Kante ermittelt, die von line geschnitten wird. Mit Hilfe der QuadEdge Datenstruktur wird der Algorithmus mit dem Dreieck f₁ fortgesetzt. In f₁ werden die Kanten traversiert, bis erneut eine Kante line schneidet. Dies geht rekursiv weiter, bis ein Dreieck nur eine Kante hat, die line schneidet. Dieses Dreieck enthält dann den Punkt dest.

2: Nutzung des gerichteten azyklischen Dalaunay-Graphen

Um mit der gegebenen Struktur einen Punkt zu lokalisieren, starten wir mit dem aus dem höchsten Punkt und den beiden Hilfspunkten bestehenden Dreieck, das die gesamte Punktwolke enthält.
Von dort aus prüfen wir die drei Nachfolger, die beim Einfügen des zweiten Punktes entstanden sind. Nur einer der Nachfolger kann den neuen Punkt enthalten. Das Dreieck selbst existiert allerdings schon nicht mehr, da auch die Nachfolger des Startknotens im Laufe des Hinzufügens neuer Punkte in kleinere Dreiecke unterteilt wurden. Wir können uns aber an der Struktur des Baumes entlanghangeln und finden so irgendwann ein Blatt im Baum. Dieses repräsentiert ein noch existierendes Dreieck im Delaunay-Graph, das den neu eingefügten Punkt enthält.

Lösung

Dateneingabe in Form von:

• Liste, Array, Hashtable
• AVL-Baum

Seien dies die Ermittelten Messwerte u in Abhängigkeit von P:

Um nun linear interpolieren zu können, benötigt man die Steigung der Geraden zwischen den Punkten und und kann daraus eine Funktion für aufstellen:

Bestimmen der beiden nächstgelegenen gemessenen Lastwerte:

Dies könnte man in einer Liste mit folgender Schleife realisieren: (Pseudocode)

for k = 1 to m
for j = 1 to n
		If P(j) <= P
			u(P)= u(j)+(u(j+1)-u(j))/(P(j+1)-P(j))*(P-P(j))
			break
next j
next k

Andere Variante: Baum

Knoten = Root
Suche(Knoten)
if Knoten.value > P
		Suche(Knoten.Left)
if P(j) == null OR Knoten.left.value < P And
Knoten.left.value > P(j) then P(j) = Knoten.left.value
	else
		Suche(Knoten.Right)

Lösung

Ein QuadTree dient in diesem Zusammenhang zur Zerlegung eines zweidimensionalen Gebietes in nichtüberlappende, quadratische Zellen. Der QuadTree muss dazu den folgenden Aufbau haben:

Definition des herkömmlichen QuadTrees

Gegeben ist die Menge an Punkten und das Quadrat , das die Punkte enthält. Wenn in der Menge weniger als zwei Punkte enthalten sind, ist der QuadTree definiert als ein einzelnes Blatt, das den Punkt und das Quadrat speichert. Ansonsten werden die vier Quadranten von nach ihrer Position benannt: Q_NW, Q_NO, Q_SW, Q_SO. Die Unterteilung des Quadrates erfolgt genau in der Mitte, dementsprechend entstehen vier neue Punktmengen:

Der QuadTree enthält dann einen Wurzelknoten , in dem das Quadrat gespeichert ist. Außerdem enthält er untergeordnet vier neue QuadTrees, die jeweils aus einer der oben beschriebenen neuen Punktmengen gebildet werden.

Definition eines der Aufgabenstellung entsprechenden QuadTrees

Die Punkte werden nacheinander eingefügt. Beim Einfügen eines neuen Punktes wird geprüft, ob der neue Knoten einfach als Blatt an einen bestehenden Knoten angefügt werden kann, oder ob der entsprechende Platz schon belegt ist und daher eine neue Unterteilung durchgeführt werden muss. Der QuadTree ist also definiert als ein Punkt mit den Koordinaten (x, y), der bis zu vier Nachfolger haben kann. Die Unterteilung des Rechtecks erfolgt nicht wie bei dem herkömmlichen QuadTree in der Mitte, sondern genau bei den Koordinaten des Punktes. Der Algorithmus funktioniert also nicht rekursiv (wie oben beschrieben), sondern iterativ.

Die Funktion insert funktioniert wie im der Abbildung oben dargestellt:

für r = 1 bis n
	Finde das Rechteck, das p_r enthält.
	wenn das Rechteck nun genau einen Punkt enthält
		dann füge den neuen Punkt p_r als Blatt an den QuadTree an,
		der das Rechteck begrenzt
	sonst // es befinden sich schon Punkt p_m im Rechteck
		unterteile das Rechteck bei den Koordinaten von p_m und füge
		den neuen Punkt p_r als Blatt an den QuadTree an, der den
		Punkt p_m_ enthält.

Maximale Tiefe

Im Gegensatz zum herkömmlichen Quadtree (vergleiche Aufgabe 10) ist die Tiefe des Baumes hier nicht von dem geometrischen Abstand der Punkte abhängig, sondern von ihrer Anordnung und ihrer Anzahl.

Im ungünstigsten Fall sieht der QuadTree so aus wie oben abgebildet. Die Tiefe des Baumes ist dann gleich , da für jeden Knoten eine Unterteilung durchgeführt werden muss.

Damit der dargestellte Fall eintritt, müssen die Punkte allerdings nicht nur die entsprechende Anordnung haben, sondern sie müssen auch genau in der Reihenfolge von p1 nach oben links in den Graphen eingefügt werden. Eine zufällige Permutation vor dem Einfügen verhindert so etwas und kann daher die Tiefe des Baumes reduzieren (im dargestellten Fall um 50%).