Übungen zu Algorithmen und Datenstrukturen II WS 2003/2004 ...

Mag. Thomas Hilpold
Institut für Wirtschaftsinformatik
Software Engineering
Übungen zu Algorithmen und Datenstrukturen II
WS 2003/2004
Übung 2
Name:________________________________Matr.-Nr.:________________Punkte:______
Gruppe: r G1 (15:30-16:15) r G2 (16:15-17:00)
Letzter Abgabetermin: Mi., 19.November 10:00 Uhr
Tutor-Kurzzeichen:
Übung 2: Graphen
Gesucht sind Algorithmen zur Verwaltung von ungerichteten gewichteten Graphen. Die Knoten sind
durchnummeriert. Jedem Knoten ist eine Bezeichnung (Zeichenkette) zugeordnet. Für die alle
Kantenbewertungen w gilt, w >= 0.
Aufgabe 1: Adjazenzmatrix
Vervollständigen sie folgende Adjazenzmatrix (Flugnetz einer kleinen Fluglinie):
2 Punkte
London
340
Paris
930
880
1030
Berlin
520
Wien
1
1
(London
)
Adjazenzmatrix
2
(Berlin)
3
(Wien)
4
(Rom)
5
(Paris)
1120
770
2
3
Rom
4
5
Aufgabe 2: Tiefen- und Breitensuche
12 Punkte
Gesucht sind zwei in Java programmierte Algorithmen für die rekursive Tiefensuche und die nicht
rekursive Breitensuche. Die Knoten sollen in der Reihenfolge, in der sie besucht werden, in eine
zurückzugebende Adjazenzmatrix eingefügt werden. Die Traversierung wird ausgehend von einem
gegebenen Knoten gestartet, sodaß nicht zwingend alle Knoten besucht werden (falls Graph nicht
zusammenhängend).
/**führt eine rekursive Tiefensuche ausgehend vom Knoten start durch;
* liefert neuen Graph mit den besuchten Knoten und den durchwanderten Kanten
*/
AdjMatrix depthFirstSearch(Node start);
/**führt eine nicht rekursive Breitensuche ausgehend vom Knoten start durch;
* liefert neuen Graph mit den besuchten Knoten und den durchwanderten Kanten
*/
AdjMatrix breadthFirstSearch(Node start);
Verwenden Sie für die Breitensuche den Typ Queue zur Verwaltung von Warteschlangen.
type Queue = {
enqueue(int v)
int dequeue()
/**fügt ein neues Element ein am Ende der Warteschlange ein*/
/**liefert das erste Element in Warteschlange*/

}
boolean isEmpty() /**ist die Warteschlagen leer?*/
Implementieren und testen Sie die Algorithmen.
Aufgabe 3: Kürzester Pfad
10 Punkte
Der kürzeste Pfad zwischen zwei Knoten from und to ist jener Pfad, dessen Summe der Kanntengewichte
kleiner ist als die Summe der Gewichte aller anderen Pfade.
Ein kürzester Pfad lässt sich finden, indem man ausgehend von einem Wurzelknoten (from) jeweils
einen noch nicht im Baum enthaltenen Knoten aus dem Graphen hinzufügt, der den kleinsten Abstand
zum Ausgangsknoten (from) hat. Dies wird solange durchgeführt, bis man den Endknoten (to)
erreicht hat.
- Kürzester Pfad: jener Knoten wird dem Baum hinzugefügt, der den kleinsten Abstand zum
Startknoten hat. Endekriterium: Erreichen des Endknotens.
a) Kürzesten Pfad einzeichnen 2 Punkte
Zeichnen Sie in folgende Graphen je einen kürzesten Pfad von Wien nach London bzw. von London
nach Rom ein.
Kürzester Pfad von Wien nach London
Kürzester Pfad von London nach Rom
London
340
Paris
930
880
Berlin
520
London
340
Paris
930
880
Berlin
520
1030
Wien
1030
Wien
1120
770
1120
770
Rom
Rom
b) Kürzesten Pfad in neuem Graph speichern 8 Punkte
Implementieren Sie einen Algorithmus in Java zur Bestimmung von kürzesten Pfaden, wobei das
Ergebnis nicht ausgedruckt, sondern in einem neuen Graphen abgelegt und zurückgeliefert wird.
/**Liefert einen Graph, der einen kürzesten Pfad zwischen zwei Knoten enthält.
* @param from Ausgangspunkt des zu suchendenden kürzesten Pfades
* @param to Endpunkt des zu suchendenden kürzesten Pfades
* @return kürzester Pfad als Graph
*/
AdjMatrix getShortestPath(Node from, Node to);
Das Ergebnis kann später ausgedruckt werden. Sie können dazu die zur Verfügung gestellte Testumgebung
verwenden.
Hinweise zu Aufgabe 2 und 3:
Gegeben ist die Klasse AdjMatrix mit Methoden zur Verwaltung von ungerichteten, gewichteten
Graphen (Adjazenzmatrix). Es werden Knoten vom Typ Node verwaltet.
class AdjMatrix {
2

int [][] m; /**Adjazenzmatrix*/
int maxNrNodes; /**maximale Anzahl von Knoten*/
Node[] node; /**Knoten des Graphen*/
int nrNodes; /**aktuelle Anzahl von Knoten*/
/**erzeugt und initialisiert Datenstrukturen für maxNrOfNodes Knoten */
Graph(int maxNrOfNodes)
/**fügt eine Kante vom Knoten (from) zum Knoten (to) ein */
void insertEdge(Node from, Node to, int weight)
/**löscht die Kante vom Knoten (from) zum Knoten (to) aus dem Graph */
void deleteEdge(Node from, Node to)
/**fügt einen neuen Knoten hinzu */
void addNode(Node node)
/**liefert das Gewicht der Kanten zwischen den Knoten from und to */
int getWeight(int Node, Node to);
/**liefert textuelle Darstellung des Graphen */
String toString();
}
...
class Node {
/**initialisiert einen Konten mit Namen name*/
Node(String name)
}
/**liefert den Namen des Knotens*/
String getName()
Als Beispiel kann Ihnen die Methode getNeighbours(...) dienen. Sie zeigt, wie die zurückzugebende
Adjazenzmatrix aufgebaut werden soll.
3

Testumgebung:
Am Webserver ist eine Testumgebung verfügbar, damit Sie Ihre Arbeiten auf die gesuchten
Algorithmen konzentrieren können. Die Testumgebung besteht aus folgenden Klassen:
- Test.java: enthält das Hauptprogramm, soll verändert werden und ihre Testfälle enthalten
(Dialog nicht unbedingt nötig).
- AdjMatrix.java: Graph, fügen Sie hier (und nur hier!) ihren Code ein
- Node.java: Knotenbeschreibungen
- Queue.java: Warteschlange
- RandomNumbers.java: Zufallszahlen für die Erzeugung von Testfällen
In der Klasse AdjMatrix sind bereits die in den Aufgaben 2 und 3 gesuchten Methoden enthalten.
Allerdings liefern sie nur beispielhafte Ergebnisse, die ausgegeben werden können.
Abgabe:
Abzugeben sind:
- die Klasse AdjMatrix mit den Methoden depthFirstSearch, breadthFirstSearch,
getShortestPath, sowie weiteren Hilfsmethoden und/oder Hilfsvariablen,
- aussagekräftige Testausgabe.
4