Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

Hauptseite | Pakete | Klassenhierarchie | Alphabetische Liste | Auflistung der Klassen | Auflistung der Dateien | Klassen-Elemente

# Verarbeitung.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   Verarbeitung.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/12 11:02:53 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.17 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017
    00018 package main.verarbeitung;
    00019
    00020 /**
    00021  * Die Klasse Verarbeitung sucht einen Weg von Rösselsprüngen in der
    00022  * angegebenen Matrix. Dazu wird die Matrix übergeben, in der die
    00023  * einzelnen Schritte gespeichert werden.<br>
    00024  * Hier ist der Kernalgorithmus des Programms zu finden, der das
    00025  * Problem löst.
    00026  *
    00027  * @version $Revision: 1.17 $
    00028  * @author Simon Tiffert
    00029  */
    00030 public class Verarbeitung
    00031 {
    00032   /** Feld für Matrix */
    00033   private Matrix matrix;
    00034
    00035   /**
    00036    * Der Konstruktor speichert die Matrix und ruft die Rösselsprünge
    00037    * auf. Dabei wird abgefangen, ob die Rekursion erfolgreich war und
    00038    * ein Weg gefunden wurde.
    00039    *
    00040    * @param matrix Zentrale Datenstruktur mit Matrix
    00041    * @throws MatrixNotInitialisedException Matrix nicht initialisiert
    00042    */
    00043   public Verarbeitung(Matrix matrix)
    00044     throws MatrixNotInitialisedException
    00045   {
    00046     // zentrale Datenstruktur
    00047     this.matrix = matrix;
    00048
    00049     // Überprüft, ob die Matrix initialisiert wurde.
    00050     // Wenn die Verarbeitung als Modul eingebunden wird, könnte es
    00051     // dort zu Problemen kommen
    00052     if (!matrix.isInitialisiert())
    00053     {
    00054       throw new MatrixNotInitialisedException();
    00055     }
    00056
    00057     // Rekursiver Aufruf des Kernalgorithmus, mit Überprüfung, ob ein
    00058     // Weg gefunden wurde
    00059     if (roesselSprung(1,
    00060       matrix.getStartpunkt().getY(),
    00061       matrix.getStartpunkt().getX()))
    00062     {
    00063       // markiere den Weg als gefunden
    00064       matrix.setWegGefunden();
    00065     }
    00066   }
    00067
    00068   /**
    00069    * Diese Funktion führt das Backtracking durch.
    00070    * Dabei wird über Rösselsprünge festgelegt, in welchen Richtungen
    00071    * das nächste Feld gesucht wird.
    00072    *
    00073    * @param zaehler Rekursionstiefe sowie aktuelle Sprunganzahl
    00074    * @param y y-Wert der aktuellen Position
    00075    * @param x x-Wert der aktuellen Position
    00076    * @return ob die Rekursion erfolgreich war
    00077    */
    00078   private boolean roesselSprung(int zaehler, int y, int x)
    00079   {
    00080     // überprüfen, ob der aktuelle Punkt innerhalb der Matrix ist
    00081     if (!matrix.isInMatrix(y, x))
    00082     {
    00083       return false;
    00084     }
    00085
    00086     // überprüfen, ob der aktuelle Punkt besetzt ist
    00087     if (matrix.getWert(y, x) != 0)
    00088     {
    00089       return false;
    00090     }
    00091
    00092     // setze auf die aktuelle Position den Wert von zaehler
    00093     matrix.setWert(y, x, zaehler);
    00094
    00095     // wenn zaehler die Maximalanzahl erreicht hat, ist die Rekursion
    00096     // fertig und kann mit true abgebrochen werden
    00097     if (zaehler == matrix.getFeldAnzahl())
    00098     {
    00099       return true;
    00100     }
    00101
    00102     // Rekursionskern:
    00103
    00104     // Richtung NNO - Nordnordost
    00105     if (roesselSprung(zaehler + 1, y - 2, x + 1))
    00106     {
    00107       return true;
    00108     }
    00109
    00110     // Richtung ONO - Ostnordost
    00111     if (roesselSprung(zaehler + 1, y - 1, x + 2))
    00112     {
    00113       return true;
    00114     }
    00115
    00116     // Richtung OSO - Ostsüdost
    00117     if (roesselSprung(zaehler + 1, y + 1, x + 2))
    00118     {
    00119       return true;
    00120     }
    00121
    00122     // Richtung SSO - Südsüdost
    00123     if (roesselSprung(zaehler + 1, y + 2, x + 1))
    00124     {
    00125       return true;
    00126     }
    00127
    00128     // Richtung SSW - Südsüdwest
    00129     if (roesselSprung(zaehler + 1, y + 2, x - 1))
    00130     {
    00131       return true;
    00132     }
    00133
    00134     // Richtung WSW - Westsüdwest
    00135     if (roesselSprung(zaehler + 1, y + 1, x - 2))
    00136     {
    00137       return true;
    00138     }
    00139
    00140     // Richtung WNW - Westnordwest
    00141     if (roesselSprung(zaehler + 1, y - 1, x - 2))
    00142     {
    00143       return true;
    00144     }
    00145
    00146     //  Richtung NNW - Nordnordost
    00147     if (roesselSprung(zaehler + 1, y - 2, x - 1))
    00148     {
    00149       return true;
    00150     }
    00151
    00152     // es wurde kein Weg gefunden, somit besetze die aktuelle Position
    00153     // wieder mit 0, sodass das Feld wieder als freies Feld erkannt
    00154     // wird.
    00155     matrix.setWert(y, x, 0);
    00156
    00157     // Es wurde keine Richtung gefunden
    00158     return false;
    00159   }
    00160
    00161 }

Documentation created with Doxygen 1.3.6 | Fri May 14 11:15:27 2004