/*
* YAV (Yet another Visualiser)
* (c) 2004 by Robin Quast
* Version 1.0 (04.03.2004)
*
* erstellt im Rahmen der Diplomarbeit
* "Theorie und Java- Realisierung
* ausgewählter Algorithmen zur
* Bestimmung kürzester Wege in Graphen"
*
* betreut durch Prof. Dr. Lenze
* an der Fachhochschule Dortmund
* im SS 2003/ WS 2003/2004
*
* @(#)Node.java 1.0 04/03/09
*/
import java.*;
import java.io.*;
/** Diese Klasse stellt Knoten dar, die z.B. innerhalb von Graphen benutzt werden
* können. Dabei können die einzelnen Knoten untereinander verglichen werden.
* Als Wertebasis ist Integer vorgesehen.
*/
public class Node
implements Comparable, Serializable
{
/** Der Wert eines Knotens. Hierbei darf auch direkt auf den Wert zugefriffen
* werden. Dies kann unter Umständen die Performance erhöhen. Es kann aber auch über
* getValue() und setValue() der Wert gesetzt, bzw. gelesen werden.
*/
public int value;
/** Konstruktor, der einen Knoten mit Wert 0 initialisiert
*/
public Node () {
value=-1;
}
/** Konstruktor, der einen Knoten mit dem Wert v initialisiert.
*/
public Node (int v) {
value=v;
}
/** Konstruktor, der einen Knoten mit dem Wert des Knotens n initialisiert.
*/
public Node (Node n) {
this.value=n.value;
}
/** gibt den Wert des Knotens zurück. Dies kann auch direkt über die Klassenvariablen
* value erfolgen. Aus Geschwindigkeitsgründen kann dies durchaus sinnvoll sein.
*/
public int getValue () {
return this.value;
}
/** setzt den Wert des Knotens auf den Integerwert v.
*/
public void setValue (int v) {
this.value=v;
}
/** vergleicht den Werte des Knotens mit dem übergebenen Wert. Ist
* Knoten == v, so wird 0 zurückgegeben. Gilt hingegen Knoten < v, so
* wird -1 zurückgegeben. Ist Knoten > v, ist der Rückgabewert 1.
*/
public int compareTo (int v) {
int rc=0;
if (value==v) rc=0;
if (value<v) rc=-1;
if (value>v) rc=1;
return rc;
}
/** vergleicht den Werte des Knotens mit dem Wert des übergebenen Knotens. Ist
* Knoten == n.value, so wird 0 zurückgegeben. Gilt hingegen Knoten < n.value, so
* wird -1 zurückgegeben. Ist Knoten > n.value, ist der Rückgabewert 1.
*/
public int compareTo (Node n) {
return compareTo(n.getValue());
}
/** vergleicht den Werte des Knotens mit dem Wert des übergebenen Obkektes.
* Das Objekt wird nach Note gecastet und anschliessen werden die gleichen
* Prüfungen durchgeführt, wie bei compareTo (Node n).Ist
* Knoten == n.value, so wird 0 zurückgegeben. Gilt hingegen Knoten < n.value, so
* wird -1 zurückgegeben. Ist Knoten > n.value, ist der Rückgabewert 1.
*/
public int compareTo (Object n) {
return compareTo ((Node) n);
}
/** vergleicht den Wert des Knotens mit dem Wert des übergebenen Knotens.
* Gilt Knoten > n dann wird true zurückgegeben, sonst false.
*/
public boolean greater (Node n) {
return greater (n.value);
}
/** vergleicht den Wert des Knotens mit dem übergebenen Wert v
* Gilt Knoten > v dann wird true zurückgegeben, sonst false.
*/
public boolean greater (int v) {
if (v < value) return true;
else return false;
}
/** vergleicht den Wert des Knotens mit dem Wert des übergebenen Knotens.
* Gilt Knoten < n dann wird true zurückgegeben, sonst false.
*/
public boolean less (Node n) {
return less(n.value);
}
/** vergleicht den Wert des Knotens mit dem übergebenen Wert v
* Gilt Knoten < v dann wird true zurückgegeben, sonst false.
*/
public boolean less (int v) {
if (v > value) return true;
else return false;
}
/** vergleicht den Wert des Knotens mit dem Wert des übergebenen Knotens.
* Gilt Knoten = n dann wird true zurückgegeben, sonst false.
*/
public boolean equal (Node n) {
return equal(n.value);
}
/** vergleicht den Wert des Knotens mit dem übergebenen Wert v
* Gilt Knoten = v dann wird true zurückgegeben, sonst false.
*/
public boolean equal (int v) {
if (v == value) return true;
else return false;
}
/** Gibt den Wert des Knotens als String zurück.
*/
public String toString() {
String rc;
rc = "" + value;
return rc;
}
/* Routinen, die die Funktionalität der Klasse demonstrieren und testen.
*/
/* public static void main(String[] args) {
// test
System.out.println("Testen der Node Klasse.\n");
System.out.println("Anlegen der Knoten 3, 7 und Kopie von 7...");
Node drei = new Node(3);
Node sieben = new Node(7);
Node kopie_von_sieben = new Node(sieben);
System.out.println("drei.getValue() " + drei.getValue());
System.out.println("sieben.getValue() " + sieben.getValue());
System.out.println("kopie_von_sieben.getValue() " + kopie_von_sieben.getValue()+"\n");
System.out.println("drei < sieben " +drei.less(sieben));
System.out.println("drei > sieben " +drei.greater(sieben));
System.out.println("drei = sieben " +drei.equal(sieben));
System.out.println("kopie_von_sieben = sieben " +kopie_von_sieben.equal(sieben));
System.out.println("drei.compareTo(sieben) " +drei.compareTo(sieben)+"\n");
System.out.println("drei.toString()= "+drei.toString());
}
*/
}
|