HeapElement.java

/*
 *     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
 *
 *  @(#)HeapElement.java  1.0 04/03/09
 */

/** Implementierung eines einfachen Heap Elements, das aus einem Knoten (Node) 
 * und einem Integer Schlüssel besteht.
 */
public class HeapElement 
implements Comparable {
  
  Node knoten = null;
  int key = 0;
  
  /** Konstruktor, der initiale Werte vergibt. <I>Knoten = new Node()</I>
   * und <I>key=0</i>
   */
  public HeapElement() {
    knoten = new Node();
    key = 0;  
  }
  
  /** Konstruktor, der ein Heap Element mit dem Knoten <i>n</i> und dem 
   * Schlüssel <i>schluessel</I> anlegt.
   */
  public HeapElement(Node n, int schluessel) {
    knoten = new Node(n);
    key = schluessel;  
  }
  
  /** Gibt den Knoten des HeapElements zurück.
   */
  public Node getNode() {
    return knoten;
  }

  /** Gibt den Knotenwert, bzw. den Knotennamen zurück.
   * Hier wird nicht der Schlüsselwert  zurückgegeben.
   */
  public int getNodeValue() {
    return knoten.value;
  }
  
  /** Gibt den Schlüssel des HeapElements zurück.
   */
  public int getKey() {
    return key;
  }

  /** Setzt den Knoten auf den übergebenen Knoten.
   */  
  public void setNode(Node n) {
    knoten = new Node(n);
  }

  /** Setze den Schlüssel auf den übergebenen Wert.
   */  
  public void setKey(int k) {
    key = k;
  }

  /** Vergleicht den Schlüssel mit dem des übergebenen Heap Elements.
   * Ist der Schlüssel des übergebenen Elements kleiner, dann wird -1
   * zurückgegeben. Ist der Schlüssel größer, dann wird 1 zurückgegeben.
   * Sind beide Schlüssel gleich, dann wird 0 zurückgegeben.
   */    
  public int compareTo (HeapElement he) {
    int rc=0;
    if (he.getKey() == keyrc=0;
    if (he.getKey() < keyrc=1;
    if (he.getKey() > keyrc=-1;
    return rc;
  }

  /** Vergleicht den Schlüssel mit dem des übergebenen Heap Elements.
   * Ist der Schlüssel des übergebenen Elements kleiner, dann wird -1
   * zurückgegeben. Ist der Schlüssel größer, dann wird 1 zurückgegeben.
   * Sind beide Schlüssel gleich, dann wird 0 zurückgegeben.
   */    
  public int compareTo (Object obj) {
    int rc=0;
    HeapElement he = (HeapElementobj;
    if (he.getKey() == keyrc=0;
    if (he.getKey() < keyrc=1;
    if (he.getKey() > keyrc=-1;
    return rc;
  }
  
  /** Gibt einen String zurück, der das Heap Element erpräsentieren soll.
   * Das HeapElement mit dem Knoten 1 und dem Schlüssel 7 wird als
   * Paar (1,7) im String dargestellt.
   */  
  public String toString() {
    return "("+knoten+", "+key+")";
  }
  
/*    public static void main(String[] args) {
      // test
      
      System.out.println("Testen der HeapElement Klasse.\n");
      System.out.println("Anlegen des HeapElements mit Knoten 3 und Schlüssel 7...");
      Node drei = new Node(3); 
      HeapElement he1=new HeapElement(drei,7);
      System.out.println(he1+"\n");
    System.out.println("Anlegen des HeapElements mit Knoten 4 und Schlüssel 5...");
      Node vier = new Node(4); 
      HeapElement he2=new HeapElement(vier,5);
      System.out.println(he2+"\n");
    
    int vergleich = he2.compareTo((Object) he1);
    System.out.println("Vergleich he2 mit he1="+vergleich);

    vergleich = he1.compareTo((Object) he2);
    System.out.println("Vergleich he1 mit he2="+vergleich);
  }  
  */
}
Java2html