Initial commit

2021-01-15 13:08:53 +01:00
commit fe59c35d59
8 changed files with 1162 additions and 0 deletions
--- a/Breitensuche.java
+++ b/Breitensuche.java
@@ -0,0 +1,153 @@
+
+/**
+ * Implementierung der Tiefensuche auf einem ungereichteten,
+ * gewichteten Graphen.
+ */
+public class Breitensuche {
+
+    private Graph g;
+
+    public Breitensuche() {
+        g = new Graph();
+
+        // Aufbau des Graphen
+        // Erstellen der Knoten (Vertices)
+        Vertex koe = new Vertex("Köln");
+        g.addVertex(koe);
+        Vertex dues = new Vertex("Düsseldorf");
+        g.addVertex(dues);
+        Vertex dor = new Vertex("Dortmund");
+        g.addVertex(dor);
+        Vertex bi = new Vertex("Bielefeld");
+        g.addVertex(bi);
+        Vertex hnv = new Vertex("Hannover");
+        g.addVertex(hnv);
+        Vertex bo = new Vertex("Bochum");
+        g.addVertex(bo);
+
+        // Erstellen der Kanten (Edges)
+        g.addEdge(new Edge(koe, dor, 96.0));
+        g.addEdge(new Edge(dues, dor, 70.0));
+        g.addEdge(new Edge(dor, bo, 22.0));
+        g.addEdge(new Edge(bi, hnv, 113.0));
+        g.addEdge(new Edge(bi, dor, 112.0));
+        g.addEdge(new Edge(bi, dues, 178.0));
+        g.addEdge(new Edge(bo, dues, 52.0));
+    }
+
+    /**
+     * Suche nach einem Vertex mit der angegebenen ID mittels der Breitensuche.
+     * @param pVertexID
+     * @return
+     */
+    public boolean findVertex( String pVertexID ) {
+        g.setAllVertexMarks(false); // Markierungen zurücksetzen
+        Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen
+
+        // TODO: Implementiere die Breitensuche als iterativen Algorithmus:
+        //       Reihe dazu die noch nicht markierten Nachbarknoten in die
+        //       searchQueue ein und arbeite die Knoten in ihr der Reihe nach
+        //       ab, bis die Queue leer ist, oder der gesuchte Knoten
+        //       gefunden wurde.
+        // TODO: Ergänze deine Methode um Ausgaben, anhand derer die Abarbeitung
+        //       deutlich wird.
+        // TODO: Wenn dein Algorithmus funnktioniert, kopiere die Methode und
+        //       Erstelle Varianten, bei denen die Reihenfolge der Nachbarknoten
+        //       modifiziert ist. Dazu
+        return false;
+    }
+
+    /**
+     *
+     * @param pVertexID
+     * @return
+     */
+    public boolean findVertexByID( String pVertexID ) {
+        g.setAllVertexMarks(false); // Markierungen zurücksetzen
+        Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen
+
+        // TODO: Ändere die Breitensuche so ab, dass die Knoten so abgearbeitet
+        //       werden, dass die Nachbarknoten in alphabetischer Reihenfolge
+        //       besucht werden.
+        //       Nutze dazu die Hilfsmethode getVertexFromListByID, um aus
+        //       Liste der Nachbarknoten denjenigen, der alphabetisch als
+        //       erstes kommt herauszusuchen.
+        return false;
+    }
+
+    public boolean findVertexByWeight( String pVertexID ) {
+        g.setAllVertexMarks(false); // Markierungen zurücksetzen
+        Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen
+
+        // TODO: Ändere die Breitensuche so ab, dass die Knoten so abgearbeitet
+        //       werden, dass der Nachbarknoten mit der Kante mit dem geringsten
+        //       Gewicht zuerst besucht wird.
+        //       Nutze dazu die Hilfsmethode getVertexFromListByWeight, um aus
+        //       Liste der Nachbarknoten denjenigen mit dem geringsten Gewicht
+        //       herauszusuchen.
+        return false;
+    }
+
+
+    /**
+     * Sucht aus einer Liste von Knoten denjenigen, dessen ID alphabetisch ale
+     * erstes kommt. Der Knoten wird aus der Liste gelöscht und dann zurück
+     * gegeben.
+     * @param pVertices
+     * @return
+     */
+    private Vertex getVertexFromListByID( List<Vertex> pVertices ) {
+        pVertices.toFirst();
+        Vertex v = pVertices.getContent();
+        do {
+          pVertices.next();
+
+          if( pVertices.hasAccess() &&
+              pVertices.getContent().getID().compareToIgnoreCase(v.getID()) < 0 ) {
+              v = pVertices.getContent();
+          }
+        } while( pVertices.hasAccess() );
+
+        pVertices.toFirst();
+        while( pVertices.hasAccess() ) {
+            if( pVertices.getContent().getID().equals(v.getID()) ) {
+                break;
+            }
+            pVertices.next();
+        }
+        pVertices.remove();
+        return v;
+    }
+
+    /**
+     * Sucht aus einer Liste von Knoten denjenigen, dessen Kantengewicht zum
+     * Konten <code>pCurrentVertex</code> am geringsten ist. Der Knoten wird
+     * aus der Liste gelöscht und dann zurück
+     * gegeben.
+     * @param pVertices
+     * @return
+     */
+    private Vertex getVertexFromListByWeight( Vertex pCurrentVertex, List<Vertex> pVertices ) {
+        pVertices.toFirst();
+        Vertex v = pVertices.getContent();
+        double weight = g.getEdge(pCurrentVertex, v).getWeight();
+        do {
+            pVertices.next();
+
+            if( pVertices.hasAccess() &&
+                g.getEdge(pCurrentVertex, pVertices.getContent()).getWeight() < weight ) {
+                v = pVertices.getContent();
+            }
+        } while( pVertices.hasAccess() );
+
+        pVertices.toFirst();
+        while( pVertices.hasAccess() ) {
+            if( pVertices.getContent().getID().equals(v.getID()) ) {
+                break;
+            }
+            pVertices.next();
+        }
+        pVertices.remove();
+        return v;
+    }
+}