Version 6.6.0 (2025-02-11): Originalversion auf Lehrerfortbildungsserver (2022)

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo.java

@@ -0,0 +1,172 @@
+package algorithmen;
+
+import java.lang.Thread;
+import java.nio.file.*;
+import graph.*;
+import java.util.List;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.scene.control.ButtonType;
+import javafx.application.Platform;
+
+
+/**
+ *
+ * description
+ *
+ * @version 1.0 from 26.04.2019
+ * @author 
+ */
+
+public abstract class GraphAlgo extends Thread {
+
+    // Anfang Attribute
+    private boolean stepping;
+    private boolean waitforrepaint;
+    private boolean waitforclick;
+    protected boolean inArbeit;
+    private GraphPlotter gp;
+    private Knoten startKnoten;
+    private int speed =100;
+    private Hilfe hilfe;
+    protected Graph g;
+    private List<String> aktuellerZustand;
+    // Ende Attribute
+
+    // Anfang Methoden
+    public GraphAlgo() {
+        stepping = true;    
+        waitforrepaint = false;
+        waitforclick = false;
+        aktuellerZustand = null;
+        setDaemon(true);
+    }
+
+    public void setGUIElemente(GraphPlotter graphPlotter, Hilfe hilfe) {
+        gp = graphPlotter;
+        g = gp.getGraph();
+        this.hilfe = hilfe;
+        if (hilfe != null) hilfe.setGraphPlotter(gp);
+    }
+    
+    public void setGraph(Graph g) {
+        this.g = g;
+        gp = null;
+        hilfe = null;
+    }
+
+    public void step() {
+        if(gp == null) return;
+        try{
+            gp.updateImage();
+            aktuellerZustand = g.getStatus();
+            waitforclick = true;
+            if (hilfe != null) hilfe.setReviewAllowed(true);
+            int i = 0;
+            while((waitforclick && (stepping || i*10 < speed)) && !isInterrupted()){
+              Thread.sleep(10);
+              i++;
+            }
+            if (hilfe != null) hilfe.setReviewAllowed(false);
+            g.setStatus(aktuellerZustand);
+            aktuellerZustand = null;
+        }catch(Exception e) {
+            // Erneutes Stop, damit nicht stop während des Sleeps hier abgefangen wird.
+            stop();
+        }
+    }
+
+    public boolean getWaitforrepaint() {
+        return waitforrepaint;
+    }
+
+    public void setWaitforrepaint(boolean waitforrepaintNeu) {
+        waitforrepaint = waitforrepaintNeu;
+    }
+
+    public boolean getWaitforclick() {
+        return waitforclick;
+    }
+
+    public void setWaitforclick(boolean waitforclickNeu) {
+        waitforclick = waitforclickNeu;
+    }
+
+    public void setStepping(boolean stepping) {
+        this.stepping = stepping;
+    }
+
+    public void setSpeed(int delay) {
+        this.speed = delay;
+    }
+
+    public void run()
+    {
+        if(!inArbeit && gp != null)
+        {
+            // System.out.println("Algorithmus gestartet");
+            inArbeit = true;
+            try{
+                if (hilfe != null) hilfe.setReviewAllowed(false);
+                fuehreAlgorithmusAus();
+                // System.out.println("Algorithmus beendet");
+            } catch( ThreadDeath e){
+                // System.out.println("Algorithmus vorzeitig beendet."); 
+            }
+            if (hilfe != null) hilfe.setReviewAllowed(true);
+            inArbeit = false;
+            return;
+        }
+        else
+        {
+            return;
+        }
+    }
+    // Ende Methoden
+
+    public void setStartKnoten(Knoten k) {
+        startKnoten = k;
+    }
+
+    public Knoten getStartKnoten() {
+        if (startKnoten != null) {
+            return startKnoten;
+        } else {
+            return g.getKnoten(0);
+        } // end of if-else
+    }
+
+    public abstract void fuehreAlgorithmusAus();
+
+    public abstract String getBezeichnung();
+
+    public void melde(String s) {
+        info(s);
+        Platform.runLater(() -> {
+                Alert meldung = new Alert(AlertType.INFORMATION, s, ButtonType.OK);
+                meldung.setTitle("Information");
+                meldung.setHeaderText(null);
+                meldung.showAndWait();
+            });
+    }
+
+    public void info(String s) {
+        if(hilfe != null) hilfe.append(s+"\n");
+    }
+
+    public void resetInfo() {
+        if(hilfe != null) hilfe.loescheAlles();
+    }
+
+    public void infoIndentMore() {
+        if(hilfe != null) hilfe.indentMore();
+
+    }
+
+    public void infoIndentLess() {
+        if(hilfe != null) hilfe.indentLess();
+
+    }
+
+
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_BellmanFord.java

@@ -0,0 +1,83 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus findet die kürzesten Pfade in einem gewichteten Graphen.
+ * Algorithmus: Bellman-Ford
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_BellmanFord extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Kürzester Pfad (Bellman-Ford)";
+    }
+
+    private String knoteninfo(Knoten k) {
+        if (!k.getInfotext().equals("")) {
+            return k.getInfotext()+" (Wert "+k.getDoubleWert()+")";
+        } else {
+            return "Knoten Nr. "+g.getNummer(k)+" (Wert "+k.getDoubleWert()+")";
+        }
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        for(Knoten k : g.getAlleKnoten()) {
+            k.setWert(1000);
+        }
+        info("Setze alle Entfernungen auf unendlich (1000)");
+        getStartKnoten().setWert(0);
+        info("Setze Startknoten auf Entfernung 0");
+        step();
+        for(int i = 0; i < g.getAnzahlKnoten()-1; i++) {
+            info(""+i+". Durchgang");
+            infoIndentMore();
+            for(Kante k: g.getAlleKanten()) {
+                info("Kante von "+knoteninfo(k.getStart())+" nach "+knoteninfo(k.getZiel()));
+                Knoten von = k.getStart();
+                Knoten nach = k.getZiel();
+                if(von.getDoubleWert()+k.getGewicht() < nach.getDoubleWert()){
+                    nach.setWert(von.getDoubleWert()+k.getGewicht());
+                    List<Kante> alterWeg = g.getEingehendeKanten(nach, ka -> ka.isMarkiert());
+                    if(alterWeg.size()>0) alterWeg.get(0).setMarkiert(false);
+                    info("Neue Entfernung für "+knoteninfo(nach)+":"+nach.getDoubleWert());
+                    k.setMarkiert(true);
+                }
+                if(!g.isGerichtet() && nach.getDoubleWert()+k.getGewicht() < von.getDoubleWert()){
+                    von.setWert(nach.getDoubleWert()+k.getGewicht());
+                    info("Neue Entfernung für "+knoteninfo(von)+":"+von.getDoubleWert());
+                    List<Kante> alterWeg = g.getEingehendeKanten(von, ka -> ka.isMarkiert());
+                    if(alterWeg.size()>0) alterWeg.get(0).setMarkiert(false);
+                    k.setMarkiert(true);
+                }
+                step();
+            }
+            infoIndentLess();
+            step();
+        }
+        info("Zyklenkontrolle");
+        for(Kante k: g.getAlleKanten()) {
+            if(k.getStart().getDoubleWert()+k.getGewicht() < k.getZiel().getDoubleWert()){
+                melde("Es gibt einen Zyklus negativen Gewichts");
+                info("Es gibt einen Zyklus negativen Gewichts");
+                g.initialisiereAlleKnoten();
+                return;
+            }
+        }
+        step();
+    } // end of for
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_Breitensuche.java

@@ -0,0 +1,72 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus nummeriert alle Knoten des Graphen.
+ * Algorithmus: Breitensuche mit ToDo-Liste (Schlange)
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_Breitensuche extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "Nummerierung (Breitensuche)";
+    }
+
+// Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        int nr = 0;
+        info("Erzeuge leere toDo-Liste und füge Startknoten hinzu");
+        List<Knoten> toDo = new ArrayList<Knoten>();
+        toDo.add(getStartKnoten());
+
+        while(toDo.size()>0) {
+            info("Nimm ersten Knoten aus der toDo-Liste (momentan "+toDo.size()+" Elemente) heraus");
+            Knoten k = toDo.remove(0);
+            nr++;
+            infoIndentMore();
+            k.setBesucht(false);
+            k.setMarkiert(true);
+            k.setWert(nr);
+            info("Markiere den Knoten und gib ihm die Nummer "+nr);
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isMarkiert()){
+                    if( !toDo.contains(n)) {
+                        toDo.add(n);
+                        g.getKante(k,n).setMarkiert(true);
+                        n.setBesucht(true);
+                        info("- ist noch nicht markiert, füge der ToDo-Liste am Ende hinzu.\n"
+                             +"  toDo-Liste hat jetzt "+toDo.size()+" Elemente");
+                    } else {
+                        info("- ist schon in ToDo-Liste");
+                    }
+                } else {
+                    info("- ist schon markiert");
+                }
+            }
+            infoIndentLess();
+            infoIndentLess();
+            step();
+        }
+        info("ToDo-Liste fertig abgearbeitet");
+
+    } // end
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_ColoringBacktracking.java

@@ -0,0 +1,93 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus färbt einen Graphen, so dass keine benachbarten Knoten
+ * die gleiche Farbe haben und möglichst wenige Farben benutzt werden.
+ * Algorithmus: Backtracking
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_ColoringBacktracking extends GraphAlgo {
+
+    // Anfang Attribute
+    int besteAnzahl;
+    List<String> beste;
+
+    public  String getBezeichnung() {
+        return "Map Coloring (Vollständing)";
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        besteAnzahl = Integer.MAX_VALUE;
+        bestimmeColoring(0);
+        g.setStatus(beste);
+        step();
+    }
+
+    private void bestimmeColoring(int benutzteFarben) {
+        int min = Integer.MAX_VALUE;
+
+        List<Knoten> knoten = g.getAlleKnoten(k->k.getFarbe()<=0);
+        List<String> status = g.getStatus();
+        if(knoten.size() == 0) {
+            if(benutzteFarben < besteAnzahl)  {
+                besteAnzahl = benutzteFarben;
+                beste = status;
+                info("Neue beste Lösung: "+besteAnzahl+" Farben");
+            }
+            else {
+                info("Keine neue beste Lösung");
+            }
+            step();
+            return;
+        }
+
+        Knoten aktuellerKnoten = knoten.get(0);
+        info("Bearbeite einen noch nicht gefärbten Knoten: Knoten Nr. "+g.getNummer(aktuellerKnoten));
+        infoIndentMore();
+
+        boolean[] farbenliste = new boolean[g.getAnzahlKnoten()+1];
+        List<Knoten> nachbarn = g.getNachbarknoten(aktuellerKnoten);
+        info("Setze alle Farbe der Farbenliste auf unbenutzt und prüfe alle Nachbarknoten");
+        infoIndentMore();
+        // speichere alle Farben in dem Array farbenliste[], die in der Adjazenzliste vom Knoten k als Wert vorkommen
+        for (Knoten k : nachbarn){
+            info("Knoten "+g.getNummer(k)+": Setze Farbe "+k.getFarbe()+" auf benutzt");
+            farbenliste[k.getFarbe()]=true;
+        }
+        infoIndentLess();
+
+        info("Teste alle zulässigen Farben");
+        infoIndentMore();
+        for(int i=1; i<5; i++) {
+            if(!farbenliste[i]){
+                aktuellerKnoten.setFarbe(i);
+                info("Setze Knoten "+g.getNummer(aktuellerKnoten)+" auf Farbe "+i);
+                if(knoten.size()>1) step();
+                infoIndentMore();
+                bestimmeColoring(Math.max(i, benutzteFarben));
+                info("Kehre zu Knoten Nr. "+g.getNummer(aktuellerKnoten)+" zurück");
+                infoIndentLess();
+            } else {
+                info("Farbe "+i+" ist benutzt");
+            }
+        }
+        infoIndentLess();
+
+        aktuellerKnoten.setFarbe(0);
+        infoIndentLess();
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_ColoringGreedy.java

@@ -0,0 +1,71 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus färbt einen Graphen, so dass keine benachbarten Knoten
+ * die gleiche Farbe haben und möglichst wenige Farben benutzt werden.
+ * Algorithmus: Näherungslösung mit Greedy-Algorithmus
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+public class GraphAlgo_ColoringGreedy extends GraphAlgo {
+
+  // Anfang Attribute
+
+  
+  
+  public  String getBezeichnung() {
+    return "Map-Coloring (Greedy)";
+  }
+  
+
+  // Ende Attribute
+  
+  // Anfang Methoden
+  public void fuehreAlgorithmusAus() {
+    List<Knoten> knoten = g.getAlleKnoten();
+    info("Wiederhole für jeden Knoten");
+    for (Knoten aktuellerKnoten: knoten ) {
+      // Liste in der die Farben der adjazenten Knoten abgehakt werden. Die Farben
+      // sind von 1 bis n (# Knoten) kodiert und werden spaeter in Farben decodiert 
+      boolean[] farbenliste = new boolean[g.getAnzahlKnoten()+1];
+      List<Knoten> nachbarn = g.getNachbarknoten(aktuellerKnoten);
+
+      info("Bearbeite Knoten "+g.getNummer(aktuellerKnoten));
+      infoIndentMore();
+      info("Setze alle Farbe der Farbenliste auf unbenutzt");
+      info("Wiederhole für jeden Nachbarknoten");
+      infoIndentMore();
+      // speichere alle Farben in dem Array farbenliste[], die in der Adjazenzliste vom Knoten k als Wert vorkommen
+      for (Knoten k : nachbarn){
+        info("Knoten "+g.getNummer(k)+": Setze Farbe "+k.getFarbe()+" auf benutzt");
+        farbenliste[k.getFarbe()]=true;
+      }
+      infoIndentLess();
+      
+      info("Suche in Farbenliste nach unbenutzer Farbe");
+      infoIndentMore();
+      // faerbe den Knoten k (setze den Farbwert des Knotens) mit der niedrigst-moeglichen Farbe (kleinster Index > 0 in der farbenliste)
+      for (int i=1; i<farbenliste.length; i++){
+        if (!farbenliste[i]) {
+          info("Farbe "+i+" ist unbenutzt");
+          infoIndentLess();
+          aktuellerKnoten.setFarbe(i);
+          info("Setze Knoten "+g.getNummer(aktuellerKnoten)+" auf Farbe "+i);
+          break;
+        }
+        info("Farbe "+i+" ist benutzt");
+      }
+      infoIndentLess();
+      step();
+    } // end of for
+  }
+  
+  // Ende Methoden
+  
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_ColoringGreedyRandom.java

@@ -0,0 +1,74 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+import java.util.Collections;
+
+import graph.*;
+/**
+ * Dieser Algorithmus färbt einen Graphen, so dass keine benachbarten Knoten
+ * die gleiche Farbe haben und möglichst wenige Farben benutzt werden.
+ * Algorithmus: Näherungslösung mit Greedy-Algorithmus (Knotenreihenfolge zufällig)
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_ColoringGreedyRandom extends GraphAlgo {
+
+  // Anfang Attribute
+
+  
+  
+  public  String getBezeichnung() {
+    return "Map-Coloring (Greedy,Random)";
+  }
+  
+
+  // Ende Attribute
+  
+  // Anfang Methoden
+  public void fuehreAlgorithmusAus() {
+    List<Knoten> knoten = g.getAlleKnoten();
+    Collections.shuffle(knoten);
+    info("Wiederhole für jeden Knoten");
+    for (Knoten aktuellerKnoten: knoten ) {
+      // Liste in der die Farben der adjazenten Knoten abgehakt werden. Die Farben
+      // sind von 1 bis n (# Knoten) kodiert und werden spaeter in Farben decodiert 
+      boolean[] farbenliste = new boolean[g.getAnzahlKnoten()+1];
+      List<Knoten> nachbarn = g.getNachbarknoten(aktuellerKnoten);
+
+      info("Bearbeite Knoten "+g.getNummer(aktuellerKnoten));
+      infoIndentMore();
+      info("Setze alle Farbe der Farbenliste auf unbenutzt");
+      info("Wiederhole für jeden Nachbarknoten");
+      infoIndentMore();
+      // speichere alle Farben in dem Array farbenliste[], die in der Adjazenzliste vom Knoten k als Wert vorkommen
+      for (Knoten k : nachbarn){
+        info("Knoten "+g.getNummer(k)+": Setze Farbe "+k.getFarbe()+" auf benutzt");
+        farbenliste[k.getFarbe()]=true;
+      }
+      infoIndentLess();
+      
+      info("Suche in Farbenliste nach unbenutzer Farbe");
+      infoIndentMore();
+      // faerbe den Knoten k (setze den Farbwert des Knotens) mit der niedrigst-moeglichen Farbe (kleinster Index > 0 in der farbenliste)
+      for (int i=1; i<farbenliste.length; i++){
+        if (!farbenliste[i]) {
+          info("Farbe "+i+" ist unbenutzt");
+          infoIndentLess();
+          aktuellerKnoten.setFarbe(i);
+          info("Setze Knoten "+g.getNummer(aktuellerKnoten)+" auf Farbe "+i);
+          break;
+        }
+        info("Farbe "+i+" ist benutzt");
+      }
+      infoIndentLess();
+      step();
+    } // end of for
+  }
+  
+  // Ende Methoden
+  
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_Dijkstra.java

@@ -0,0 +1,87 @@
+package algorithmen;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus findet die kürzesten Pfade in einem gewichteten Graphen.
+ * Algorithmus: Dijkstra
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_Dijkstra extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Kürzester Pfad (Dijkstra)";
+    }
+
+    // Anfang Methoden
+
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+
+        info("Erzeuge leere toDo-Liste und füge Startknoten hinzu");
+        List<Knoten> toDo = new ArrayList<Knoten>();
+        getStartKnoten().setBesucht(true);
+        getStartKnoten().setWert(0);
+        toDo.add(getStartKnoten());
+
+        while(toDo.size()>0) {
+            info("Sortiere toDo-Liste");
+            Collections.sort(toDo);
+            info("Nimm ersten Knoten aus der toDo-Liste (momentan "+toDo.size()+" Elemente) heraus");
+            Knoten k = toDo.remove(0);
+            infoIndentMore();
+            k.setMarkiert(true);
+            info("Markiere den Knoten");
+            info("Er hat Entfernung "+k.getIntWert());
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isMarkiert()){
+                    info("- ist noch nicht markiert");
+                    Kante ka = g.getKante(k, n);
+                    if(!n.isBesucht() || n.getDoubleWert() > k.getDoubleWert()+ka.getGewicht()){
+                        if(n.isBesucht()) {
+                            List<Kante> eingehend = g.getEingehendeKanten(n, ka2 -> !ka2.isGeloescht() && ka2.isMarkiert());
+                            Kante alterWeg = eingehend.get(0);
+                            // Kante alterWeg = g.beschraenkeKantenAuf(g.getEingehendeKanten(n), Graph.MARKIERT, Graph.NICHTGELOESCHT).get(0);
+                            // alterWeg.setGeloescht(true); 
+                            // alterWeg.setMarkiert(false);
+                            alterWeg.setGeloescht(true); 
+                            alterWeg.setMarkiert(false);
+
+                            info(" loesche bisherigen Weg dorthin");
+                        }
+                        n.setWert(k.getIntWert()+ka.getGewicht());
+                        if(!toDo.contains(n)) toDo.add(n);
+                        ka.setMarkiert(true);
+                        n.setBesucht(true);
+                        info("  setze Entfernung "+(n.getDoubleWert())+" und füge ggf. ToDo-Liste hinzu.");
+                        info("  toDo-Liste hat jetzt "+toDo.size()+" Elemente");
+                    } else {
+                        info("  keine neue beste Entfernung");
+                        ka.setGeloescht(true);
+                    }
+                } 
+            }
+            infoIndentLess();
+            infoIndentLess();
+            step();
+        }
+        info("ToDo-Liste fertig abgearbeitet");
+
+    } // end
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetBacktracking.java

@@ -0,0 +1,78 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Backtracking
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetBacktracking extends GraphAlgo {
+
+    // Anfang Attribute
+    int besteAnzahl;
+    List<String> beste;
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Vollständig)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        long starttime = System.currentTimeMillis();
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        besteAnzahl = Integer.MAX_VALUE;
+        bestimmeDominierendeMenge(0);
+        g.setStatus(beste);
+        long endtime = System.currentTimeMillis();
+        melde("Minimale dominierende Menge in "+((endtime-starttime)/1000)+" Sekunden gefunden.");
+        step();
+    }
+
+
+
+    private void bestimmeDominierendeMenge(int knoten) {
+        List<String> status = g.getStatus();
+      
+        List<Knoten> markierte = g.getAlleKnoten(kn->kn.isMarkiert());  
+        List<Knoten> nichtbesucht = g.getAlleKnoten(kn->!kn.isBesucht() && !kn.isMarkiert());  
+  
+        // Verbessert die Laufzeit deutlich, aber verhindert das exponentielle Wachstum nicht
+        // if(markierte.size() >=besteAnzahl) return;
+        
+        Knoten k = g.getKnoten(knoten);
+        if(k != null && nichtbesucht.size()>0) {
+          bestimmeDominierendeMenge(knoten+1);
+          g.setStatus(status);
+          k.setMarkiert(true);
+          k.setBesucht(false);
+          for(Knoten n: g.getNachbarknoten(k, kn->!kn.isBesucht() && !kn.isMarkiert())) {
+              n.setBesucht(true);
+          }
+          bestimmeDominierendeMenge(knoten+1);
+          g.setStatus(status);
+        } else {
+          step();
+            
+          if(nichtbesucht.size()==0){
+              if(markierte.size() < besteAnzahl)  {
+                besteAnzahl = markierte.size();
+                beste = status;
+            }
+          }
+ 
+        }
+    }
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGenetisch.java

@@ -0,0 +1,149 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+import java.util.Random;
+import java.util.Arrays;
+
+import graph.*;
+
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Genetischer Algorithmus
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGenetisch extends GraphAlgo {
+
+    private int popGroesse=500;
+    private int fitGroesse=80;
+    private int[][] population;
+    private int[][] fittest;
+    private int generation;
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "Dominierende Menge (Genetisch)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        population = new int[popGroesse][g.getAnzahlKnoten()];
+        double[] bewertungen = new double[popGroesse];
+        for(int i=0; i<popGroesse; i++) {
+            population[i] = erzeugeZufaelligeTeilmenge();
+            bewertungen[i] = getBewertung(population[i]);
+        }
+        fittest = new int[fitGroesse][g.getAnzahlKnoten()];
+        for(int i=0; i < fitGroesse; i++) {
+            int beste = 0;
+            for(int j=1; j<popGroesse; j++) {
+                if(bewertungen[j] > bewertungen[beste]) {
+                    beste = j;
+                }
+            }
+            fittest[i] = population[beste];
+            bewertungen[beste] = Double.MIN_VALUE;
+        }
+        showTeilmenge(fittest[0]);
+
+        Random r = new Random();
+        for(generation = 0; generation < 100; generation++) {
+            for(int j=0; j <fitGroesse; j++) {
+                population[j]=fittest[j];
+                bewertungen[j] = getBewertung(population[j]);
+            }
+            for(int j=fitGroesse; j<popGroesse; j++) {
+                int i1 = r.nextInt(fitGroesse);
+                int i2 = r.nextInt(fitGroesse);
+                population[j] = mutiere(kreuze(fittest[i1],fittest[i2]));
+                bewertungen[j] = getBewertung(population[j]);
+            }
+            fittest = new int[fitGroesse][g.getAnzahlKnoten()];
+            for(int i=0; i < fitGroesse; i++) {
+                int beste = 0;
+                for(int j=1; j<popGroesse; j++) {
+                    if(bewertungen[j] > bewertungen[beste]) {
+                        beste = j;
+                    }
+                }
+                fittest[i] = population[beste];
+                bewertungen[beste] = Double.MIN_VALUE;
+            }
+            showTeilmenge(fittest[0]);
+            this.info("Bisher beste dominierende Menge (Generation "+generation+"): "+(g.getAnzahlKnoten()-getBewertung(fittest[0]))+" Knoten.");
+            step();
+        }
+
+        step();
+    }
+
+    public int[] erzeugeZufaelligeTeilmenge(){
+        Random r = new Random();
+        int[] teilmenge = new int[g.getAnzahlKnoten()];
+
+        for(int i=0; i< g.getAnzahlKnoten(); i++) {
+            teilmenge[i] = r.nextInt(2);
+        }
+        return teilmenge;
+    }
+
+    public int[] kreuze(int[] tm1, int[] tm2) {
+        Random r = new Random();
+        int crossover = r.nextInt(tm1.length);
+        int[] new_tm = Arrays.copyOf(tm1, tm1.length);
+        for(int j = crossover; j< tm2.length; j++) {
+            new_tm[j] = tm2[j];
+        }
+        return new_tm;
+    }
+
+    public int[] mutiere(int[] tm) {
+        Random r = new Random();
+        int anz_mut = r.nextInt(3);
+        int[] new_tm = Arrays.copyOf(tm, tm.length);
+        for(int z =0; z<anz_mut; z++) {
+            int pos1 = r.nextInt(tm.length);
+            if(new_tm[pos1]==0) new_tm[pos1]=1; else new_tm[pos1]=0;
+        }
+        return new_tm;
+    }
+
+    public void showTeilmenge(int[] tm) {
+        g.initialisiereAlleKnoten();
+        for(int i=0; i<tm.length; i++) {
+            if(tm[i]==1) {
+                g.getKnoten(i).setMarkiert(true);
+                g.getKnoten(i).setBesucht(false);
+                for(Knoten k : g.getNachbarknoten(g.getKnoten(i))) {
+                    if(!k.isMarkiert()) k.setBesucht(true);
+                }
+            }
+        }
+    }
+
+    public double getBewertung(int[] tm) {
+        int anz_ueberdeckt = 0;
+        for(int i=0; i<tm.length; i++) {
+            if(tm[i]==0)
+            {
+                for(Knoten k: g.getNachbarknoten(g.getKnoten(i))) {
+                    if(tm[g.getNummer(k)]==1) {
+                        anz_ueberdeckt++;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return anz_ueberdeckt;
+    }
+
+
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyA.java

@@ -0,0 +1,78 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  Nimm den Knoten mit den meisten  Nachbarn
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyA extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (a))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  Nimm den Knoten mit den meisten  Nachbarn
+     */
+    private Knoten bestimmeBesten() {
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert());
+
+        info("Wiederhole für jeden noch nicht markierten Knoten");
+        infoIndentMore();
+        for(Knoten k : knoten) {
+            List<Knoten> nachbarn = g.getNachbarknoten(k);
+            k.setWert(nachbarn.size());
+            info("Setze Wert von Knoten Nr. "+g.getNummer(k)+" auf "+nachbarn.size()+" Nachbarn");
+        }
+        infoIndentLess();
+        info("Sortiere die Liste");
+        knoten.sort(Comparator.comparing(Knoten::getIntWert).reversed());
+        Knoten bester = knoten.get(0);
+        info("Nimm den Knoten mit den meisten Nachbarn => Knoten Nr. "+g.getNummer(bester));
+        return bester;
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyB.java

@@ -0,0 +1,77 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  Nimm den Knoten mit den wenigsten Nachbarn 
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyB extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (b))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  Nimm den Knoten mit den wenigsten Nachbarn
+     */
+    private Knoten bestimmeBesten() {
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert());
+
+        info("Wiederhole für jeden noch nicht markierten Knoten");
+        infoIndentMore();
+        for(Knoten k : knoten) {
+            List<Knoten> nachbarn = g.getNachbarknoten(k);
+            k.setWert(nachbarn.size());
+            info("Setze Wert von Knoten Nr. "+g.getNummer(k)+" auf "+nachbarn.size()+" Nachbarn");
+        }
+        infoIndentLess();
+        info("Sortiere die Liste");
+        knoten.sort(Comparator.comparing(Knoten::getIntWert));
+        Knoten bester = knoten.get(0);
+        info("Nimm den Knoten mit den wenigsten Nachbarn => Knoten Nr. "+g.getNummer(bester));
+        return bester;
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyC.java

@@ -0,0 +1,79 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  Nimm den Knoten mit den meisten  Nachbarn
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyC extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (c))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  Nimm den Knoten mit den meisten  Nachbarn
+     */
+    private Knoten bestimmeBesten() {
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert());
+
+        info("Wiederhole für jeden noch nicht markierten Knoten");
+        infoIndentMore();
+        for(Knoten k : knoten) {
+            List<Knoten> nachbarn = g.getNachbarknoten(k, kn -> !kn.isMarkiert() && !kn.isBesucht());
+            k.setWert(nachbarn.size());
+            if(!k.isMarkiert() && !k.isBesucht()) k.setWert(k.getIntWert()+1);
+            info("Setze Wert von Knoten Nr. "+g.getNummer(k)+" auf "+nachbarn.size()+" neu überdeckte Knoten");
+        }
+        infoIndentLess();
+        info("Sortiere die Liste");
+        knoten.sort(Comparator.comparing(Knoten::getIntWert).reversed());
+        Knoten bester = knoten.get(0);
+        info("Nimm den Knoten mit den meisten neu überdeckten Knoten => Knoten Nr. "+g.getNummer(bester));
+        return bester;
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyD.java

@@ -0,0 +1,79 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  Nimm den Knoten mit den meisten  Nachbarn
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyD extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (d))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  Nimm den Knoten mit den meisten  Nachbarn
+     */
+    private Knoten bestimmeBesten() {
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert());
+
+        info("Wiederhole für jeden noch nicht markierten Knoten");
+        infoIndentMore();
+        for(Knoten k : knoten) {
+            List<Knoten> nachbarn = g.getNachbarknoten(k, kn -> !kn.isMarkiert() && !kn.isBesucht());
+            k.setWert(nachbarn.size());
+            if(!k.isMarkiert() && !k.isBesucht()) k.setWert(k.getIntWert()+1);
+            info("Setze Wert von Knoten Nr. "+g.getNummer(k)+" auf "+nachbarn.size()+" neu überdeckte Knoten");
+        }
+        infoIndentLess();
+        info("Sortiere die Liste");
+        knoten.sort(Comparator.comparing(Knoten::getIntWert));
+        Knoten bester = knoten.get(0);
+        info("Nimm den Knoten mit den wenigsten neu überdeckten Knoten => Knoten Nr. "+g.getNummer(bester));
+        return bester;
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyE.java

@@ -0,0 +1,98 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyE extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (e))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+     */
+
+    private Knoten bestimmeBesten() {
+        Random r= new Random();
+
+        List<Knoten> markierte = g.getAlleKnoten(k->k.isMarkiert() );
+        List<Knoten> nichtabgedeckte = g.getAlleKnoten(k->!k.isMarkiert() );
+        if(markierte.size()==0) return g.getKnoten(r.nextInt(g.getAnzahlKnoten()));
+
+        List<Knoten> entfernung3 = new ArrayList<Knoten>();
+        List<String> status =  g.getStatus();
+        for(Knoten start: markierte) {
+            info("Bestimme Entfernung von Knoten "+g.getKnoteninfo(start,false)+" zu allen anderen Knoten");
+
+            g.initialisiereAlleKnoten();
+            GraphAlgo moore = new GraphAlgo_Moore();
+            moore.setGraph(g);
+            moore.setStartKnoten(start);
+            moore.fuehreAlgorithmusAus();
+
+            entfernung3 = g.getAlleKnoten(k->k.getIntWert()==3);
+            entfernung3.retainAll(nichtabgedeckte);
+            info("Habe "+entfernung3.size()+" Knoten mit Entfernung 3 gefunden.");
+            if(entfernung3.size()>0)  break;
+        }
+        Knoten bester;
+        if(entfernung3.size()>0) {
+            info("Wähle zufällig einen von diesen");
+            bester = entfernung3.get(r.nextInt(entfernung3.size()));
+        } else {
+            info("Wählen einen zufälligen Knoten aus");
+            bester = nichtabgedeckte.get(r.nextInt(nichtabgedeckte.size()));
+        }
+        bester.setFarbe(5);
+        step();
+        g.setStatus(status);
+        return bester;
+    }      
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyF.java

@@ -0,0 +1,98 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyF extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (f))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+     */
+
+    private Knoten bestimmeBesten() {
+        Random r= new Random();
+
+        List<Knoten> markierte = g.getAlleKnoten(k->k.isMarkiert() );
+        List<Knoten> nichtabgedeckte = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht() );
+        if(markierte.size()==0) return g.getKnoten(r.nextInt(g.getAnzahlKnoten()));
+
+        List<Knoten> entfernung2 = new ArrayList<Knoten>();
+        List<String> status =  g.getStatus();
+        for(Knoten start: markierte) {
+            info("Bestimme Entfernung von Knoten "+g.getKnoteninfo(start,false)+" zu allen anderen Knoten");
+
+            g.initialisiereAlleKnoten();
+            GraphAlgo moore = new GraphAlgo_Moore();
+            moore.setGraph(g);
+            moore.setStartKnoten(start);
+            moore.fuehreAlgorithmusAus();
+
+            entfernung2 = g.getAlleKnoten(k->k.getIntWert()==2);
+            entfernung2.retainAll(nichtabgedeckte);
+            info("Habe "+entfernung2.size()+" noch nicht überdeckte Knoten mit Entfernung 2 gefunden.");
+            if(entfernung2.size()>0)  break;
+        }
+        Knoten bester;
+        if(entfernung2.size()>0) {
+            info("Wähle zufällig einen von diesen");
+            bester = entfernung2.get(r.nextInt(entfernung2.size()));
+        } else {
+            info("Wählen einen zufälligen Knoten aus");
+            bester = nichtabgedeckte.get(r.nextInt(nichtabgedeckte.size()));
+        }
+        bester.setFarbe(5);
+        step();
+        g.setStatus(status);
+        return bester;
+    }      
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyG.java

@@ -0,0 +1,98 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyG extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (g))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  ein nicht abgedeckten Knoten, der von einem beliebigen schon ausgewählten Knoten die Entfernung 3 hat
+     */
+
+    private Knoten bestimmeBesten() {
+        Random r= new Random();
+
+        List<Knoten> markierte = g.getAlleKnoten(k->k.isMarkiert() );
+        List<Knoten> nichtabgedeckte = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht() );
+        if(markierte.size()==0) return g.getKnoten(r.nextInt(g.getAnzahlKnoten()));
+
+        List<Knoten> entfernung3 = new ArrayList<Knoten>();
+        List<String> status =  g.getStatus();
+        for(Knoten start: markierte) {
+            info("Bestimme Entfernung von Knoten "+g.getKnoteninfo(start,false)+" zu allen anderen Knoten");
+
+            g.initialisiereAlleKnoten();
+            GraphAlgo moore = new GraphAlgo_Moore();
+            moore.setGraph(g);
+            moore.setStartKnoten(start);
+            moore.fuehreAlgorithmusAus();
+
+            entfernung3 = g.getAlleKnoten(k->k.getIntWert()==3);
+            entfernung3.retainAll(nichtabgedeckte);
+            info("Habe "+entfernung3.size()+" noch nicht überdeckte Knoten mit Entfernung 3 gefunden.");
+            if(entfernung3.size()>0)  break;
+        }
+        Knoten bester;
+        if(entfernung3.size()>0) {
+            info("Wähle zufällig einen von diesen");
+            bester = entfernung3.get(r.nextInt(entfernung3.size()));
+        } else {
+            info("Wählen einen zufälligen Knoten aus");
+            bester = nichtabgedeckte.get(r.nextInt(nichtabgedeckte.size()));
+        }
+        bester.setFarbe(5);
+        step();
+        g.setStatus(status);
+        return bester;
+    }      
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyH.java

@@ -0,0 +1,101 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  ein nicht abgedeckten Knoten, der von möglichst vielen schon ausgewählten Knoten die Entfernung 3 hat
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyH extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (h))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  ein nicht abgedeckten Knoten, der von möglichst vielen schon ausgewählten Knoten die Entfernung 3 hat
+     */
+    private Knoten bestimmeBesten() {
+        Random r = new Random();
+        List<Knoten> markierte = g.getAlleKnoten(k->k.isMarkiert() );
+        List<Knoten> nichtabgedeckte = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht() );
+        if(markierte.size()==0) return g.getKnoten(r.nextInt(g.getAnzahlKnoten()));
+
+        List<Knoten> entfernung3 = new ArrayList<Knoten>();
+        List<String> status =  g.getStatus();
+        g.initialisiereAlleKnoten();
+        List<String> zaehlstatus = g.getStatus();
+
+        for(Knoten start: markierte) {
+            info("Bestimme Entfernung von Knoten "+g.getKnoteninfo(start,false)+" zu allen anderen Knoten");
+            g.initialisiereAlleKnoten();
+            GraphAlgo moore = new GraphAlgo_Moore();
+            moore.setGraph(g);
+            moore.setStartKnoten(start);
+            moore.fuehreAlgorithmusAus();
+
+            entfernung3 = g.getAlleKnoten(k->k.getIntWert()==3);
+            entfernung3.retainAll(nichtabgedeckte);
+            info("Habe "+entfernung3.size()+" noch nicht überdeckte Knoten mit Entfernung 3 gefunden ");
+            g.setStatus(zaehlstatus);
+            for(Knoten kandidat: entfernung3) {
+                kandidat.setWert(kandidat.getIntWert()+1);
+            }
+            info("... und erhöher die Anzahl bei diesen Knoten");
+            zaehlstatus= g.getStatus();
+
+        }
+        info("Sortiere die Knoten nach der Anzahl der ausgewählten Knoten mit Abstand 3");
+        nichtabgedeckte.sort(Comparator.comparing(Knoten::getIntWert).reversed());
+
+        Knoten bester = nichtabgedeckte.get(0);
+        bester.setFarbe(5);
+        info("Nehme den besten");
+        step();
+        g.setStatus(status);
+        return bester;
+    } 
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_DominatingSetGreedyI.java

@@ -0,0 +1,114 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.nio.file.*;
+import java.util.Random;
+
+import graph.*;
+/**
+ * Dieser Algorithmus bestimmt die kleinste dominierende Menge in einem Graphen
+ * und bestimmt den Zeitbedarf.
+ * Algorithmus: Greedy mit Strategie:
+ *  ein nicht abgedeckten Knoten, der von den ausgewählten Knoten eine möglichst große Entfernung hat
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_DominatingSetGreedyI extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Dominierende Menge (Greedy (i))";
+    }
+
+    /** Bestimmt besten Knoten nach Strategie:
+     *  ein nicht abgedeckten Knoten, der von den ausgewählten Knoten eine möglichst große Entfernung hat
+     */   
+
+    private Knoten bestimmeBesten() {
+        Random r = new Random();
+        List<Knoten> markierte = g.getAlleKnoten(k->k.isMarkiert() );
+        List<Knoten> nichtabgedeckte = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht() );
+        if(markierte.size()==0) return g.getKnoten(r.nextInt(g.getAnzahlKnoten()));
+
+        List<String> status =  g.getStatus();
+        g.initialisiereAlleKnoten();
+        for(Knoten k : g.getAlleKnoten()) {
+            k.setWert(Integer.MAX_VALUE);
+            k.setMarkiert(false);
+        }
+        info("Setze alle Entfernungen auf unendlich");
+        List<Knoten> toDo = new ArrayList<Knoten>();
+
+        for(Knoten start: markierte) {
+            for(Knoten k : g.getAlleKnoten()) {
+                k.setBesucht(false);
+                k.setMarkiert(false);
+            }
+            info("Bestimme Entfernung von Knoten "+g.getKnoteninfo(start,false)+" zu allen anderen Knoten");
+
+            start.setBesucht(true);
+            start.setWert(0);
+            toDo.add(start);
+
+            while(toDo.size()>0) {
+                Knoten k = toDo.remove(0);
+                k.setMarkiert(true);
+                for(Knoten n : g.getNachbarknoten(k)) {
+                    if(!n.isBesucht() && n.getIntWert()>k.getIntWert()+1){
+                        n.setWert(k.getIntWert()+1);
+                        toDo.add(n);
+                        g.getKante(k,n).setMarkiert(true);
+                        n.setBesucht(true);
+                    } 
+                }
+            }
+            info("... und reduziere Entfernung, wenn nötig.");
+
+        }
+        info("Sortiere Knoten nach Entfernung");
+        nichtabgedeckte.sort(Comparator.comparing(Knoten::getIntWert).reversed());
+
+        Knoten bester = nichtabgedeckte.get(0);
+        bester.setFarbe(5);
+        info("... und nimm den am weitesten entfernten");
+        step();
+        g.setStatus(status);
+        return bester;
+    } 
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        List<Knoten> knoten = g.getAlleKnoten(k->!k.isMarkiert() && !k.isBesucht());
+        info("Solange es noch nicht überdeckte Knoten gibt, wiederhole...");
+        int nr = 1;
+        while(knoten.size() > 0) {
+            info("Bestimme "+(nr++)+". hinzuzufügenden Knoten");
+            infoIndentMore();
+            Knoten bester = bestimmeBesten();
+            bester.setMarkiert(true);
+            bester.setBesucht(false);
+            info("Markiere diesen Knoten ...");
+            List<Knoten> nachbarn = g.getNachbarknoten(bester,kn->!kn.isMarkiert() && !kn.isBesucht());
+            for(Knoten k : nachbarn) {
+                k.setBesucht(true);
+            }
+            info("... und setze alle bisher nicht überdeckten Nachbarn auf besucht");
+            knoten = g.getAlleKnoten(kn->!kn.isMarkiert() && !kn.isBesucht());
+            step();
+            infoIndentLess();
+        }// end of while
+
+    } 
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_EulerkreisExistenz.java

@@ -0,0 +1,84 @@
+package algorithmen;
+
+import java.util.ArrayList;
+import java.util.List;
+import graph.*;
+/**
+ * Dieser Algorithmus testet, ob ein Eulerkreis existiert.
+ * Algorithmus: Zunächst wird auf geraden Grad der Knoten getestet, danach 
+ * mit Tiefensuche der Zusammenhang des Graphen überprüft.
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_EulerkreisExistenz extends GraphAlgo {
+
+    public  String getBezeichnung() {
+        return "Eulerkreis (Existenz)";
+    }
+
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+
+        boolean gradOk = true;
+        info("Setze gradOK auf true");
+        for(Knoten k: g.getAlleKnoten()) {
+            info("Knoten "+g.getNummer(k)+" hat Grad "+g.getNachbarknoten(k).size());
+            if(g.getNachbarknoten(k).size() % 2 != 0) {
+                gradOk = false;
+                info("Setze gradOK auf false");
+            }
+        }
+        info("Alle Knoten untersucht");
+        step();
+
+        if(!gradOk) {
+            melde("Es gibt keinen Euler-Kreis, da der Grad nicht immer gerade ist");
+            return;
+        }
+
+        List<Knoten> toDo = new ArrayList<Knoten>();
+        getStartKnoten().setBesucht(true);
+        toDo.add(getStartKnoten());
+        info("Erzeuge leere toDo-Liste und füge Startknoten hinzu");
+
+        int nr=0;
+        while(toDo.size()>0) {
+            info("Nimm ersten Knoten aus der toDo-Liste (momentan "+toDo.size()+" Elemente) heraus");
+            Knoten k = toDo.remove(0);
+            nr++;
+            infoIndentMore();
+            k.setMarkiert(true);
+            k.setWert(nr);
+            info("Markiere den Knoten und gib ihm die Nummer "+nr);
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isBesucht()){
+                    info("- kennzeichne als besucht, füge der ToDo-Liste am Anfang hinzu.");
+                    toDo.add(0, n);
+                    g.getKante(k,n).setMarkiert(true);
+                    n.setBesucht(true);
+                    info("  toDo-Liste hat jetzt "+toDo.size()+" Elemente");
+                } else {
+                    info("- ist schon als besucht gekennzeichnet.");
+                }
+            }
+            infoIndentLess();
+            infoIndentLess();
+            step();
+        }
+        if(nr == g.getAnzahlKnoten()) {
+            melde("Es gibt einen Euler-Kreis");
+        } else 
+        {
+            melde("Es gibt keinen Euler-Kreis, da der Graph nicht zusammenhängend ist.");
+        }
+
+    } // end
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_MST_Kruskal.java

@@ -0,0 +1,85 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+
+/**
+ *
+ * Dieser Algorithmus sucht einen minimal Spanning Tree
+ * Algorithmus: Kruskal
+ *
+ * @version 1.0 from 11.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_MST_Kruskal extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "MST (Kruskal)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        int farbe = 1;
+        List<Kante> kanten = g.getAlleKanten();
+        List<Knoten> knoten = g.getAlleKnoten();
+        info("Hole eine Liste aller Kanten und eine aller Knoten");
+        Collections.sort(kanten);
+        info("Sortiere Kanten aufsteigend");
+        info("Wiederhole für alle Kanten:");
+        for (Kante k: kanten) {
+            info("Bearbeite Kante mit Gewicht: "+k.getGewicht());
+            infoIndentMore();
+            int f1 = k.getStart().getFarbe();
+            int f2 = k.getZiel().getFarbe();
+            if(f1 == 0 && f2 == 0) {
+                info("Beide Knoten gehören noch zu keinem Teilgraphen");
+                k.getStart().setFarbe(farbe);
+                k.getZiel().setFarbe(farbe);
+                k.setMarkiert(true);
+                info("=> setze beide auf Farbe "+farbe+" und markiere die Kante");
+                farbe++;
+            } else
+            if(f1 == 0) {
+                info("Der Knoten Nr. "+g.getNummer(k.getStart())+" gehört noch zu keinem Teilgraphen");
+                k.getStart().setFarbe(f2);
+                k.setMarkiert(true);
+                info("=> setze ihn auf die Farbe des Knotens Nr. "+g.getNummer(k.getZiel())+" und markiere die Kante");
+            } else
+            if(f2 == 0) {
+                info("Der Knoten Nr. "+g.getNummer(k.getZiel())+" gehört noch zu keinem Teilgraphen");
+                k.getZiel().setFarbe(f1);
+                k.setMarkiert(true);
+                info("=> setze ihn auf die Farbe des Knotens Nr. "+g.getNummer(k.getStart())+" und markiere die Kante");
+            } else
+            if(f1 == f2) {
+                info("Beide Knoten gehören zum gleichen Teilgraphen");
+                k.setGeloescht(true);
+                info("lösche die Kante");
+            } else 
+            {
+                info("Beide Knoten gehören zu unterschiedlichen Teilgraphen");
+                int min = Math.min(f1,f2);
+                int max = Math.max(f1,f2);
+                for(Knoten k1 : knoten) {
+                    if(k1.getFarbe() == max) k1.setFarbe(min);
+                }
+                info("=> färbe alle Knoten mit Farbe "+max+" mit der Farbe "+min);
+                k.setMarkiert(true);
+                info("   und markiere die Kante");
+            }
+            infoIndentLess();
+            step();
+        }
+    } // end of for
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_MST_Prim.java

@@ -0,0 +1,85 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+
+/**
+ *
+ * Dieser Algorithmus sucht einen minimal Spanning Tree
+ * Algorithmus: Prim
+ *
+ * @version 1.0 from 11.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_MST_Prim extends GraphAlgo {
+
+    // Anfang Attribute
+
+    // Ende Attribute
+    public  String getBezeichnung() {
+        return "MST (Prim)";
+    }
+
+    public void fuehreAlgorithmusAus() {
+        int markiert = 0;
+        List<Knoten> knoten;
+        List<Kante> kanten;
+        knoten = g.getAlleKnoten();
+        kanten = g.getAlleKanten();
+
+        if(knoten.size()==0) return;
+
+        Collections.sort(kanten);
+        info("Sortiere die Kanten nach ihrem Gewicht:");
+        infoIndentMore();
+        for(Kante ka2 : kanten) {
+            info("Kante ("+g.getNummer(ka2.getStart())+"-"+g.getNummer(ka2.getZiel())+") mit Gewicht "+ka2.getGewicht());
+        }
+        infoIndentLess();
+        if(getStartKnoten()!= null) {
+            getStartKnoten().setMarkiert(true);
+            info("Setze Startknoten auf markiert");
+        } else {
+
+            knoten.get(0).setMarkiert(true);
+            info("Setze einen beliebigen Knoten auf markiert");
+        }
+        markiert++;
+        step();
+
+        while(knoten.size() > markiert) {
+            info("Suche Kante mit dem geringsten Gewicht von markiertem Teilbaum zu unmarkiertem Teilbaum");
+            infoIndentMore();
+            Kante ka=null;
+            for(Kante ka2 : kanten) {
+                if(ka2.getStart().isMarkiert() != ka2.getZiel().isMarkiert()) {
+                    ka = ka2;
+                    break;
+                }
+                if(ka2.getStart().isMarkiert() && ka2.getZiel().isMarkiert()) {
+                    info("Kante ("+g.getNummer(ka2.getStart())+"-"+g.getNummer(ka2.getZiel())+") mit Gewicht "+ka2.getGewicht()+": Beide Knoten schon markiert.");
+                } else {
+                    info("Kante ("+g.getNummer(ka2.getStart())+"-"+g.getNummer(ka2.getZiel())+") mit Gewicht "+ka2.getGewicht()+": Beide Knoten noch nicht markiert.");
+                } 
+
+            }
+            infoIndentLess();
+            if(ka != null) {
+                ka.setMarkiert(true);
+                kanten.remove(ka);
+                info("Kante ("+g.getNummer(ka.getStart())+"-"+g.getNummer(ka.getZiel())+") mit Gewicht "+ka.getGewicht()+" gefunden. Markiere sie.");
+                ka.getStart().setMarkiert(true);
+                ka.getZiel().setMarkiert(true);
+                markiert++;
+                info("Markiere die angrenzenden Knoten.");
+            }
+            step();
+        }    
+
+    }
+
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_Moore.java

@@ -0,0 +1,69 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus findet die kürzesten Pfade in einem ungewichteten Graphen.
+ * Algorithmus: Algorithmus A von Moore
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_Moore extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "Kürzester Pfad (Moore)";
+    }
+
+// Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+       
+        info("Erzeuge leere toDo-Liste und füge Startknoten hinzu");
+        List<Knoten> toDo = new ArrayList<Knoten>();
+        getStartKnoten().setBesucht(true);
+        getStartKnoten().setWert(0);
+        toDo.add(getStartKnoten());
+
+        while(toDo.size()>0) {
+            info("Nimm ersten Knoten aus der toDo-Liste (momentan "+toDo.size()+" Elemente) heraus");
+            Knoten k = toDo.remove(0);
+            infoIndentMore();
+            k.setMarkiert(true);
+            info("Markiere den Knoten");
+            info("Er hat Entfernung "+k.getIntWert());
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isBesucht()){
+                        n.setWert(k.getIntWert()+1);
+                        toDo.add(n);
+                        info("- ist noch nicht markiert, setze Entfernung "+(k.getIntWert()+1)+" und füge der ToDo-Liste am Ende hinzu.");
+                        g.getKante(k,n).setMarkiert(true);
+                        n.setBesucht(true);
+                        info("  toDo-Liste hat jetzt "+toDo.size()+" Elemente");
+                } else {
+                    info("- ist schon markiert");
+                }
+            }
+            infoIndentLess();
+            infoIndentLess();
+            step();
+        }
+        info("ToDo-Liste fertig abgearbeitet");
+
+    } // end
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TSPBacktracking.java

@@ -0,0 +1,112 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+
+import graph.*;
+
+/**
+  *
+  * Dieser Algorithmus sucht einen möglichst kurzen Hamilton-Kreis (Traveling
+  * Salesman Problem).
+  * Algorithmus: Backtracking
+  *
+  * @version 1.0 from 11.12.2020
+  * @author Thomas Schaller
+  */
+
+public class GraphAlgo_TSPBacktracking extends GraphAlgo {
+
+  private List<String> besteLoesung = null;
+  private double besteStrecke = Double.MAX_VALUE;
+  private Knoten start;
+    
+  // Anfang Attribute
+
+  
+  public String getBezeichnung() {
+    return "TSP (Vollständig)";
+  }
+
+  
+
+
+  // Anfang Methoden
+  public void fuehreAlgorithmusAus() {
+     start = this.getStartKnoten();
+     probiere(start);
+     g.setStatus(besteLoesung);
+      step();
+      melde("beste Route gefunden:" +getInfo());
+  } // end of for
+  
+  public void probiere(Knoten akt) {
+     boolean fertig = true;
+     infoIndentMore();
+     akt.setMarkiert(true);
+     info("Markiere Knoten Nr."+g.getNummer(akt));
+     step();
+
+     List<Knoten> nochNichtBesucht = g.getAlleKnoten(kn->!kn.isMarkiert());
+     if(nochNichtBesucht.isEmpty()) {
+       info("Keine weiteren nicht besuchten Knoten übrig");
+       g.getKante(akt,start).setMarkiert(true);  
+       info("Markiere Kante zum Startpunkt");
+       List<Kante> gewaehlteKanten = g.getAlleKanten(ka->ka.isMarkiert());
+       double laenge = 0;
+       for(Kante k:gewaehlteKanten) {
+         laenge+=k.getGewicht();
+       }   
+       info("Summiere alle Streckenlängen: Gesamtlänge ist "+laenge);
+       if(laenge < besteStrecke) {
+           info("Neue beste Strecke => merke diese Strecke");
+           besteStrecke = laenge;
+           besteLoesung = g.getStatus();;
+       }
+       step();
+       infoIndentLess();
+       g.getKante(akt,start).setMarkiert(false);
+       akt.setMarkiert(false);
+       info("Kehre zum vorherigen Knoten zurück");
+       step();
+       return;
+    }
+           
+     info("untersuche alle ausgehenden Kanten:");
+     List<Kante> kanten = g.getAusgehendeKanten(akt);
+     for(Kante k: kanten) {
+        if(!k.getAnderesEnde(akt).isMarkiert()) {
+          k.setMarkiert(true);
+          info("Kante zu Knoten Nr. "+g.getNummer(k.getAnderesEnde(akt))+"=> nicht markiert, probiere diesen Weg");
+          probiere(k.getAnderesEnde(akt));
+          k.setMarkiert(false);
+        } else {
+          info("Kante zu Knoten Nr. "+g.getNummer(k.getAnderesEnde(akt))+"=> schon markiert, kein sinnvoller Weg");
+        }
+     }
+
+     akt.setMarkiert(false);
+     info("kehre zu vorherigem Knoten zurück");
+     infoIndentLess();
+     step(); 
+  }
+  
+  public String getInfo() {
+    List<Kante> kanten = g.getAlleKanten();
+    double laenge = 0;
+    int anz =0;
+    for(Kante k:kanten) {
+        if(k.isMarkiert()) {
+            laenge+=k.getGewicht();
+            anz++;
+        }
+    }
+    
+    return "Weglänge ("+anz+" von "+g.getAnzahlKnoten()+" Kanten): "+laenge+" km. Bisher beste Gesamtlösung "+this.besteStrecke+" km";
+}
+  
+  
+  // Ende Methoden
+  
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TSPGenetisch.java

@@ -0,0 +1,182 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+import java.util.Random;
+import java.util.Arrays;
+
+import graph.*;
+
+/**
+ *
+ * description
+ *
+ * @version 1.0 from 26.04.2019
+ * @author 
+ */
+
+public class GraphAlgo_TSPGenetisch extends GraphAlgo {
+
+    private int popGroesse=500;
+    private int fitGroesse=80;
+    private int[][] population;
+    private int[][] fittest;
+    private int generation;
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "TSP (Genetisch)";
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        population = new int[popGroesse][g.getAnzahlKnoten()+1];
+        double[] rundreiseLaenge = new double[popGroesse];
+        for(int i=0; i<popGroesse; i++) {
+            population[i] = erzeugeZufaelligeRundreise();
+            rundreiseLaenge[i] = getLaenge(population[i]);
+        }
+        fittest = new int[fitGroesse][g.getAnzahlKnoten()+1];
+        for(int i=0; i < fitGroesse; i++) {
+            int beste = 0;
+            for(int j=1; j<popGroesse; j++) {
+                if(rundreiseLaenge[j] < rundreiseLaenge[beste]) {
+                    beste = j;
+                }
+            }
+            fittest[i] = population[beste];
+            rundreiseLaenge[beste] = Double.MAX_VALUE;
+        }
+        showRundreise(fittest[0]);
+
+        Random r = new Random();
+        for(generation = 0; generation < 300; generation++) {
+
+            for(int j=0; j <fitGroesse; j++) {
+                population[j]=fittest[j];
+                rundreiseLaenge[j] = getLaenge(population[j]);
+            }
+            for(int j=fitGroesse; j<popGroesse; j++) {
+                int i1 = r.nextInt(fitGroesse);
+                int i2 = r.nextInt(fitGroesse);
+                population[j] = mutiere2(kreuze(fittest[i1],fittest[i2]));
+                rundreiseLaenge[j] = getLaenge(population[j]);
+            }
+
+            fittest = new int[fitGroesse][g.getAnzahlKnoten()+1];
+            for(int i=0; i < fitGroesse; i++) {
+                int beste = 0;
+                for(int j=1; j<popGroesse; j++) {
+                    if(rundreiseLaenge[j] < rundreiseLaenge[beste]) {
+                        beste = j;
+                    }
+                }
+                fittest[i] = population[beste];
+                rundreiseLaenge[beste] = Double.MAX_VALUE;
+            }
+            showRundreise(fittest[0]);
+            step();
+        }
+
+        step();
+    }
+
+    public int[] erzeugeZufaelligeRundreise(){
+        Random r = new Random();
+        int[] rundreise = new int[g.getAnzahlKnoten()+1];
+
+        for(int i=0; i< g.getAnzahlKnoten(); i++) rundreise[i] = i;
+        for(int i=0; i< 1000; i++) {
+            int p1 = r.nextInt(rundreise.length-2)+1;
+            int p2 = r.nextInt(rundreise.length-2)+1;
+            int d = rundreise[p1];
+            rundreise[p1] = rundreise[p2];
+            rundreise[p2] = d;
+        }
+        rundreise[g.getAnzahlKnoten()]=rundreise[0];
+        return rundreise;
+    }
+
+    public int[] kreuze(int[] rr1, int[] rr2) {
+        Random r = new Random();
+        int crossover = r.nextInt(rr1.length);
+        int[] new_r = Arrays.copyOf(rr1, rr1.length);
+        for(int j = 0; j< rr2.length-1; j++) {
+            boolean schonEnthalten = false;
+            for(int i = 0; i<crossover; i++) {
+                if(rr2[j] == new_r[i]) {
+                    schonEnthalten=true;
+                    break;
+                }
+            }
+            if(!schonEnthalten) {
+                new_r[crossover] = rr2[j];
+                crossover++;
+            }
+        }
+        rr2[rr2.length-1] = rr2[0];
+        return new_r;
+    }
+
+    public int[] mutiere(int[] rr) {
+        Random r = new Random();
+        int anz_mut = r.nextInt(3);
+        int[] new_r = Arrays.copyOf(rr, rr.length);
+        for(int z =0; z<anz_mut; z++) {
+            int pos1 = r.nextInt(rr.length-1);
+            int pos2 = r.nextInt(rr.length-1);
+            int d = new_r[pos1];
+            new_r[pos1] = new_r[pos2];
+            new_r[pos2] = d;
+        }
+        new_r[new_r.length-1] = new_r[0];
+        return new_r;
+    }
+
+    public int[] mutiere2(int[] rr) {
+        Random r = new Random();
+        int start= r.nextInt(rr.length-1);
+        int laenge = r.nextInt(7);
+        int[] new_r = Arrays.copyOf(rr, rr.length);
+        for(int i=0; i< laenge; i++) {
+            new_r[(start+laenge-1-i)%(rr.length-1)]=rr[(start+i)%(rr.length-1)];
+        }
+        new_r[new_r.length-1] = new_r[0];
+        return new_r;
+    }
+
+    public void showRundreise(int[] rundreise) {
+        g.initialisiereAlleKanten();
+        for(int i=0; i<rundreise.length-1; i++) {
+            g.getKante(rundreise[i],rundreise[i+1]).setMarkiert(true);
+
+        }
+        info(getInfo());
+    }
+
+    public double getLaenge(int[] rundreise) {
+        double laenge = 0;   
+        for(int i=0; i<rundreise.length-1; i++) {
+            laenge += g.getKante(rundreise[i],rundreise[i+1]).getGewicht();
+        }
+        return laenge;
+    }
+
+    public String getInfo() {
+        List<Kante> kanten = g.getAlleKanten();
+        double laenge = 0;
+        int anz =0;
+        for(Kante k:kanten) {
+            if(k.isMarkiert()) {
+                laenge+=k.getGewicht();
+                anz++;
+            }
+        }
+
+        //return ""+generation+";"+laenge;
+        return "Bisher beste Weglänge (Generation "+generation+"): "+laenge+" km.";
+    }
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TSPGreedy.java

@@ -0,0 +1,81 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+import java.util.Collections;
+
+import graph.*;
+
+/**
+ *
+ * Dieser Algorithmus sucht einen möglichst kurzen Hamilton-Kreis (Traveling
+ * Salesman Problem).
+ * Algorithmus: Greedy
+ * Strategie: Verlängere den Weg immer mit der kürzesten Kante, die vom aktuellen Ende der Route ausgeht.
+ * vlg. Minimal Spanning Tree (Prim)
+ *
+ * @version 1.0 from 11.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_TSPGreedy extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "TSP (Greedy: Knoten)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        Knoten start = this.getStartKnoten();
+        Knoten akt = start;
+        Kante min;
+        int anz = 0;
+        int laenge = 0;
+        info("Starte mit Knoten Nr. "+g.getNummer(start));
+        do{
+            akt.setMarkiert(true);
+            info("Markiere diesen Knoten");
+            final Knoten aktK = akt;
+            min = null;
+            List<Kante> kanten = g.getAusgehendeKanten(akt, ka -> !ka.getAnderesEnde(aktK).isMarkiert());
+            info("Betrachte alle ausgehenden Kanten zu unmarkierten Knoten.\n und sortiere diese Kanten nach Gewicht.");
+            if(kanten.size() > 0) {
+                Collections.sort(kanten);
+                min = kanten.get(0);
+                info("Kürzeste Kante geht zu Knoten "+g.getNummer(min.getAnderesEnde(akt)));
+                laenge += min.getGewicht();
+                anz++;
+                min.setMarkiert(true);
+                info("Markiere diese Kante (Länge "+laenge+" nach "+anz+" von "+g.getAlleKnoten().size()+" Knoten)");
+                akt = min.getAnderesEnde(akt);
+                info("mache mit diesem Knoten weiter");
+            }
+            step();
+        }while (min!=null);
+        g.getKante(akt,start).setMarkiert(true);
+        info("Markiere die Kante vom letzten Knoten zum Startknoten");
+        step(); 
+        melde("Route gefunden: "+getInfo());
+    } // end of for
+
+    public String getInfo() {
+        List<Kante> kanten = g.getAlleKanten();
+        double laenge = 0;
+        int anz =0;
+        for(Kante k:kanten) {
+            if(k.isMarkiert()) {
+                laenge+=k.getGewicht();
+                anz++;
+            }
+        }
+
+        return "Weglänge ("+anz+" von "+g.getAnzahlKnoten()+" Kanten): "+laenge+" km.";
+    }
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TSPGreedy2.java

@@ -0,0 +1,172 @@
+package algorithmen;
+
+import java.util.List;
+import java.nio.file.*;
+import java.util.Comparator;
+import java.util.Collections;
+
+import graph.*;
+
+/**
+ *
+ * Dieser Algorithmus sucht einen möglichst kurzen Hamilton-Kreis (Traveling
+ * Salesman Problem).
+ * Algorithmus: Greedy
+ * Strategie: Sortiere Kanten der Länge nach. Füge sie der Reihe nach der Route hinzu, wenn nicht schon ein
+ * Weg zwischen den beiden Knoten vorhanden ist und die Knoten nicht schon Grad zwei erreicht haben.
+ * vgl. Minimal Spanning Tree (Kruskal)
+ *
+ * @version 1.0 from 11.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_TSPGreedy2 extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "TSP (Greedy: kürzeste Kante)";
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        int farbe = 1;
+        int anzkanten = 0;
+        List<Kante> kanten = g.getAlleKanten();
+        List<Knoten> knoten = g.getAlleKnoten();
+        info("Hole eine Liste aller Kanten und eine aller Knoten");
+        Collections.sort(kanten);
+        info("Sortiere Kanten aufsteigend");
+        info("Wiederhole für jede Kante");
+        for (Kante k: kanten) {
+            info("Bearbeite Kante mit Gewicht: "+k.getGewicht());
+            infoIndentMore();
+            int f1 = k.getStart().getFarbe();
+            int f2 = k.getZiel().getFarbe();
+            if(f1 == 0 && f2 == 0) {
+                info("Beide Knoten gehören noch zu keinem Teilgraphen");
+                k.getStart().setFarbe(farbe);
+                k.getZiel().setFarbe(farbe);
+                k.setMarkiert(true);
+                anzkanten++;
+                info("=> setze beide auf Farbe "+farbe+" und markiere die Kante");
+                farbe++;
+            } else
+            if(f1 == 0 && g.getAusgehendeKanten(k.getZiel(), k2->k2.isMarkiert()).size()==1) {
+                info("Der Knoten Nr. "+g.getNummer(k.getStart())+" gehört noch zu keinem Teilgraphen und verlängert eine Route");
+                k.getStart().setFarbe(f2);
+                k.setMarkiert(true);
+                anzkanten++;
+                info("=> setze ihn auf die Farbe des Knotens Nr. "+g.getNummer(k.getZiel())+" und markiere die Kante");
+            } else
+            if(f2 == 0 && g.getAusgehendeKanten(k.getStart(), k2->k2.isMarkiert()).size()==1) {
+                info("Der Knoten Nr. "+g.getNummer(k.getZiel())+" gehört noch zu keinem Teilgraphen und verlängert eine Route");
+                k.getZiel().setFarbe(f1);
+                k.setMarkiert(true);
+                anzkanten++;
+                info("=> setze ihn auf die Farbe des Knotens Nr. "+g.getNummer(k.getStart())+" und markiere die Kante");
+            } else
+            if(f1 == f2) {
+                if(anzkanten == g.getAnzahlKnoten()-1 && istRoutenende(k.getZiel()) && istRoutenende(k.getStart())){
+                    k.setMarkiert(true);
+                    info("=> markiere die Kante und schließe damit die Rundreise");  
+                    infoIndentLess();
+                    step();
+                    break;
+                } else {
+                    info("Beide Knoten gehören zum gleichen Teilgraphen");
+                }
+            } else 
+            if(istRoutenende(k.getZiel()) && istRoutenende(k.getStart())){
+                info("Beide Knoten gehören zu unterschiedlichen Teilgraphen, die vereinigt werden können.");
+                int min = Math.min(f1,f2);
+                int max = Math.max(f1,f2);
+                for(Knoten k1 : knoten) {
+                    if(k1.getFarbe() == max) k1.setFarbe(min);
+                }
+                info("=> färbe alle Knoten mit Farbe "+max+" mit der Farbe "+min);
+                k.setMarkiert(true);
+                anzkanten++;
+                info("   und markiere die Kante");
+            }
+            infoIndentLess();
+            step();
+        }
+        melde("Rundreise gefunden:"+ getInfo());
+    }
+
+    private boolean istRoutenende(Knoten k) {
+        return g.getAusgehendeKanten(k, k2->k2.isMarkiert()).size()==1;
+    }
+    // Knoten start = this.getStartKnoten();
+
+    // List<Kante> kanten = g.getAlleKanten();
+    // kanten.sort(Comparator.comparingDouble(Kante::getGewicht));
+
+    // for(Kante k: kanten) {
+    // for (Knoten v: g.getAlleKnoten()) v.setBesucht(false);
+    // if(!findeWeg(k.getStart(), k.getZiel()) && bestimmeGrad(k.getStart())!=2 && bestimmeGrad(k.getZiel())!=2) {
+    // k.setMarkiert(true);
+    // } else {
+    // k.setMarkiert(true);
+    // boolean alleZwei=true;
+    // for(Knoten v: g.getAlleKnoten()) {
+    // if(bestimmeGrad(v) != 2) {
+    // alleZwei = false;
+    // }
+    // }
+    // if(alleZwei) {
+    // break;
+    // }
+    // k.setMarkiert(false);
+    // }
+    // step(); 
+    // } // end of for
+    // step();
+    // melde("Rundreise gefunden:"+ getInfo());
+    // }
+
+    private int bestimmeGrad(Knoten k) {
+        List<Kante> kantenV = g.getAusgehendeKanten(k, k2->k2.isMarkiert());
+        return kantenV.size();
+    }
+
+    // /**
+    // * Hilfsmethode zum kurzsichtigen Algorithmus.
+    // * Findet die minimale Kante von einem gegebenen StartKnoten.
+    // *
+    // * @param  Knoten startKnoten  Der StartKnoten, von dem aus die Adjazenzliste durchlaufen wird
+    // * @return  Kante   Die gesuchte minimale Kante
+    // */
+    // public boolean findeWeg(Knoten s, Knoten z) {
+    // if(s==z) return true;
+
+    // boolean gefunden = false;
+    // s.setBesucht(true);
+    // List<Kante> kanten = g.getAusgehendeKanten(s);
+    // for (Kante k: kanten) {
+    // if(k.isMarkiert()) { // Nur markierte Kanten zaehlen als Weg
+    // if(!k.getAnderesEnde(s).isBesucht()) {
+    // if(findeWeg(k.getAnderesEnde(s), z)) return true;
+    // }
+    // }
+    // } // end of for
+    // return false;
+    // }
+
+    public String getInfo() {
+        List<Kante> kanten = g.getAlleKanten();
+        double laenge = 0;
+        int anz =0;
+        for(Kante k:kanten) {
+            if(k.isMarkiert()) {
+                laenge+=k.getGewicht();
+                anz++;
+            }
+        }
+
+        return "Weglänge ("+anz+" von "+g.getAnzahlKnoten()+" Kanten): "+laenge+" km.";
+    }
+
+    // Ende Methoden
+}

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TSPGreedyOpt.java

@@ -0,0 +1,112 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.nio.file.*;
+
+import graph.*;
+
+/**
+ *
+ * Dieser Algorithmus sucht einen möglichst kurzen Hamilton-Kreis (Traveling
+ * Salesman Problem).
+ * Algorithmus: Greedy mit anschließender Optimierung: 
+ * Jeder Knoten wird der Reihe nach aus der Rundreise entfernt und dort wieder eingefügt, wo die Rundreise
+ * sich am wenigsten verlängert. Diese Optimierung wird 5x wiederholt.
+ *
+ * @version 1.0 from 11.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_TSPGreedyOpt extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public String getBezeichnung() {
+        return "TSP (Greedy: Knoten + Optimierung)";
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        Knoten start = this.getStartKnoten();
+        Knoten akt = start;
+        List<Knoten> reihung = new ArrayList<Knoten>();
+        reihung.add(start);
+        Kante min;
+        do{
+            List<Kante> kanten = g.getAusgehendeKanten(akt);
+            min = null;
+            double mindist = Double.MAX_VALUE;
+            for(Kante k: kanten) {
+                if(!k.getAnderesEnde(akt).isMarkiert()) {
+                    if(min == null || mindist > k.getGewicht()) {
+                        min = k;
+                        mindist = k.getGewicht();
+                    }
+                }
+            }
+            akt.setMarkiert(true);
+            if(min != null) {
+                min.setMarkiert(true);
+                akt = min.getAnderesEnde(akt);
+                reihung.add(akt);
+            }
+            step();
+        }while (min!=null);
+        g.getKante(akt,start).setMarkiert(true);
+        step();
+        // Versuch der Optimierung
+        for(int o=0; o<5 ; o++)
+            for(Knoten kn : g.getAlleKnoten()) {
+                List<Kante> markierteKanten = g.getAusgehendeKanten(kn, ka->ka.isMarkiert());
+                for(Kante k: markierteKanten){
+                    k.setMarkiert(false);
+                }
+                g.getKante(markierteKanten.get(0).getAnderesEnde(kn),markierteKanten.get(1).getAnderesEnde(kn)).setMarkiert(true);
+                double laengeBest = Double.MAX_VALUE;
+                Kante kanteBest = null;
+                for(Kante k2: g.getAlleKanten()) {
+                    if(k2.isMarkiert()) {
+                        double laengeNeu = g.getKante(k2.getStart(),kn).getGewicht()+g.getKante(k2.getZiel(),kn).getGewicht()-k2.getGewicht() ;
+                        if(laengeBest > laengeNeu) {
+                            laengeBest = laengeNeu;
+                            kanteBest = k2;
+                        }
+                    }
+                }
+                kanteBest.setMarkiert(false);
+                g.getKante(kanteBest.getStart(),kn).setMarkiert(true);
+                g.getKante(kanteBest.getZiel(),kn).setMarkiert(true); 
+                step();
+            }
+        step(); 
+        melde("Rundreise gefunden:"+ getInfo());
+
+    } // end of for
+
+    public double getLaenge() {
+        List<Kante> kanten = g.getAlleKanten();
+        double laenge = 0;
+        for(Kante k:kanten) {
+            if(k.isMarkiert()) laenge+=k.getGewicht();
+        }
+        return laenge;
+    }
+
+    public String getInfo() {
+        List<Kante> kanten = g.getAlleKanten();
+        double laenge = 0;
+        int anz =0;
+        for(Kante k:kanten) {
+            if(k.isMarkiert()) {
+                laenge+=k.getGewicht();
+                anz++;
+            }
+        }
+
+        return "Weglänge ("+anz+" von "+g.getAnzahlKnoten()+" Kanten): "+laenge+" km.";
+    }
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_Tiefensuche.java

@@ -0,0 +1,73 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus nummeriert alle Knoten des Graphen.
+ * Algorithmus: Tiefensuche mit ToDo-Liste (Stapel)
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_Tiefensuche extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Nummerierung (Tiefensuche)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        int nr = 0;
+        info("Erzeuge leere toDo-Liste und füge Startknoten hinzu");
+        List<Knoten> toDo = new ArrayList<Knoten>();
+        toDo.add(getStartKnoten());
+
+        while(toDo.size()>0) {
+            info("Nimm ersten Knoten aus der toDo-Liste (momentan "+toDo.size()+" Elemente) heraus");
+            Knoten k = toDo.remove(0);
+            nr++;
+            infoIndentMore();
+            k.setBesucht(false);
+            k.setMarkiert(true);
+            k.setWert(nr);
+            info("Markiere den Knoten und gib ihm die Nummer "+nr);
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isMarkiert()){
+                    if( !toDo.contains(n)) {
+                        toDo.add(0, n);
+                        g.getKante(k,n).setMarkiert(true);
+                        n.setBesucht(true);
+                        info("- ist noch nicht markiert, füge der ToDo-Liste am Anfang hinzu.\n"+
+                             "  toDo-Liste hat jetzt "+toDo.size()+" Elemente");
+                    } else {
+                       info("- ist schon in ToDo-Liste");
+                    }
+                } else {
+                    info("- ist schon markiert");
+                }
+            }
+            infoIndentLess();
+            infoIndentLess();
+            step();
+        }
+        info("ToDo-Liste fertig abgearbeitet");
+
+    } // end
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_TiefensucheRek.java

@@ -0,0 +1,60 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus nummeriert alle Knoten des Graphen.
+ * Algorithmus: Tiefensuche rekursiv
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_TiefensucheRek extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Nummerierung (Tiefensuche rekursiv)";
+    }
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        nummeriere(getStartKnoten(), 0);
+    } // end
+
+    private int nummeriere(Knoten k, int nr) {
+        // Abbruchbedingung
+        if(k.isBesucht()) {
+            info("Untersuche "+g.getKnoteninfo(k,false)+" => ist schon besucht");
+        } else {
+            nr++;
+            k.setBesucht(true);
+            k.setWert(nr);
+            info("Untersuche "+g.getKnoteninfo(k,false)+" => bekommt Nummer: "+nr);
+            step();
+            info("Untersuche Nachbarn von "+g.getKnoteninfo(k,false));
+            infoIndentMore();
+            List<Knoten> nachbarn = g.getNachbarknoten(k);
+            for(Knoten n : nachbarn) {
+                nr = nummeriere(n,nr);
+            }
+            info("Keine weiteren Nachbarn von "+g.getKnoteninfo(k,false));
+            infoIndentLess();
+            step();
+        }
+        return nr;
+
+    }
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_ZyklusBacktracking.java

@@ -0,0 +1,80 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus ist ein Beispiel für einen Backtracking-Algorithmus.
+ * Er sucht einen Zyklus im Graphen.
+ * Algorithmus: Backtracking
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_ZyklusBacktracking extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Zyklensuche (Backtracking)";
+    }
+
+    public void fuehreAlgorithmusAus() {
+        List<String> loesung = backtracking(getStartKnoten());
+        if(loesung != null) g.setStatus(loesung);
+        step();
+    }
+
+    public List<String> backtracking(Knoten k){
+
+        List<String> loesung = null;
+
+        info("Untersuche Knoten "+g.getNummer(k));
+
+        // Abbruchbedingung
+        if (k.isMarkiert()) {
+            // Ausführung unterbrechen
+            info("Knoten ist schon bearbeitet => Zyklus gefunden");
+            step();
+            loesung = g.getStatus();
+        } else {
+
+            List<String> aktuellerZustand = g.getStatus();
+            info("Knoten ist noch nicht bearbeitet => Speichere Zustand des Graphen");
+
+            // Aktion mit Knoten durchführen, z.B. markieren
+            k.setMarkiert(true);
+            info("Markiere den Knoten und betrachte alle nicht markierten, ausgehenden Kanten");
+            // Ausführung unterbrechen
+            step();
+
+            // Probiere alle Möglichkeiten (
+            // hier alle nicht markierten, ausgehenden Kanten
+            List<Kante> ausgehend = g.getAusgehendeKanten(k, ka->!ka.isMarkiert());
+            infoIndentMore();
+            int nr=1;
+            for(Kante ausgehendeKante : ausgehend) {
+                k.setMarkiert(true);
+                ausgehendeKante.setMarkiert(true);
+                info("Probiere Kante "+nr);
+                infoIndentMore();
+                Knoten nachbar = ausgehendeKante.getAnderesEnde(k);
+                loesung =  backtracking(nachbar);
+                infoIndentLess();
+                g.setStatus(aktuellerZustand);
+                info("Kehre zurück");
+                step();
+                if(loesung != null) break;
+                nr++;
+            }
+            infoIndentLess();
+        }
+        return loesung;
+    }
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/GraphAlgo_toplogischeSortierung.java

@@ -0,0 +1,71 @@
+package algorithmen;
+
+import java.util.List;
+import java.util.Collections;
+import java.nio.file.*;
+
+import graph.*;
+/**
+ * Dieser Algorithmus findet eine topologische Sortierung des Graphen.
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_toplogischeSortierung extends GraphAlgo {
+
+    // Anfang Attribute
+
+    public  String getBezeichnung() {
+        return "Topologische Sortierung";
+    }
+
+
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        String reihenfolge = "";
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+        info("Bestimme die Anzahl der eingehenden Kanten für jeden Knoten");
+        infoIndentMore();
+        List<Knoten> knoten = g.getAlleKnoten();
+        for(Knoten k: knoten) {
+            k.setWert(g.getEingehendeKanten(k).size());
+            info("Setze Wert von von "+g.getKnoteninfo(k, false)+" auf "+g.getEingehendeKanten(k).size());
+        }
+        infoIndentLess();
+        step();
+        
+        while(knoten.size()>0) {
+          Collections.sort(knoten);
+          info("Sortiere die noch nicht markierten Knoten nach ihrem Wert");
+          Knoten k = knoten.get(0);
+          k.setMarkiert(true);
+          info("Nimm Knoten "+g.getKnoteninfo(k,false)+" und markiere ihn.");
+
+          if(k.getIntWert() != 0) {
+              melde("Fehler: Wert ist nicht 0 - Zyklus vorhanden");
+              knoten.clear();
+              return;
+          } else {
+             reihenfolge += " "+g.getKnoteninfo(k, false);
+             info("Füge ihn der Liste hinzu: "+reihenfolge);
+             knoten.remove(k);
+             for(Knoten k2 : g.getNachbarknoten(k)) {
+               k2.setWert(k2.getIntWert()-1);
+             }
+             info("Reduziere den Wert aller Nachbarn von Knoten "+g.getNummer(k)+" um 1");
+          }
+          step();
+        }
+        melde("Topologische Sortierung: "+reihenfolge);
+        
+        
+    } // end
+
+    // Ende Methoden
+
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/algorithmen/package.bluej

@@ -0,0 +1,261 @@
+#BlueJ package file
+dependency1.from=GraphAlgo_DominatingSetGreedyE
+dependency1.to=GraphAlgo
+dependency1.type=UsesDependency
+dependency2.from=GraphAlgo_DominatingSetGreedyE
+dependency2.to=GraphAlgo_Moore
+dependency2.type=UsesDependency
+dependency3.from=GraphAlgo_DominatingSetGreedyF
+dependency3.to=GraphAlgo
+dependency3.type=UsesDependency
+dependency4.from=GraphAlgo_DominatingSetGreedyF
+dependency4.to=GraphAlgo_Moore
+dependency4.type=UsesDependency
+dependency5.from=GraphAlgo_DominatingSetGreedyG
+dependency5.to=GraphAlgo
+dependency5.type=UsesDependency
+dependency6.from=GraphAlgo_DominatingSetGreedyG
+dependency6.to=GraphAlgo_Moore
+dependency6.type=UsesDependency
+dependency7.from=GraphAlgo_DominatingSetGreedyH
+dependency7.to=GraphAlgo
+dependency7.type=UsesDependency
+dependency8.from=GraphAlgo_DominatingSetGreedyH
+dependency8.to=GraphAlgo_Moore
+dependency8.type=UsesDependency
+objectbench.height=133
+objectbench.width=750
+package.divider.horizontal=0.6003172085646312
+package.divider.vertical=0.8309178743961353
+package.editor.height=668
+package.editor.width=1133
+package.editor.x=533
+package.editor.y=122
+package.frame.height=928
+package.frame.width=1297
+package.numDependencies=8
+package.numTargets=31
+package.showExtends=true
+package.showUses=true
+readme.height=60
+readme.name=@README
+readme.width=49
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=GraphAlgo_ColoringGreedyRandom
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=250
+target1.x=600
+target1.y=590
+target10.height=50
+target10.name=GraphAlgo_DominatingSetGreedyF
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=240
+target10.x=290
+target10.y=420
+target11.height=50
+target11.name=GraphAlgo_DominatingSetGreedyG
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=250
+target11.x=290
+target11.y=470
+target12.height=50
+target12.name=GraphAlgo_TSPGreedy
+target12.showInterface=false
+target12.type=ClassTarget
+target12.width=230
+target12.x=600
+target12.y=160
+target13.height=50
+target13.name=GraphAlgo_DominatingSetGreedyD
+target13.showInterface=false
+target13.type=ClassTarget
+target13.width=250
+target13.x=290
+target13.y=320
+target14.height=50
+target14.name=GraphAlgo_TSPGenetisch
+target14.showInterface=false
+target14.type=ClassTarget
+target14.width=230
+target14.x=600
+target14.y=340
+target15.height=50
+target15.name=GraphAlgo_DominatingSetGreedyE
+target15.showInterface=false
+target15.type=ClassTarget
+target15.width=240
+target15.x=290
+target15.y=370
+target16.height=50
+target16.name=GraphAlgo_DominatingSetGenetisch
+target16.showInterface=false
+target16.type=ClassTarget
+target16.width=250
+target16.x=290
+target16.y=640
+target17.height=50
+target17.name=GraphAlgo_ZyklusBacktracking
+target17.showInterface=false
+target17.type=ClassTarget
+target17.width=220
+target17.x=20
+target17.y=640
+target18.height=50
+target18.name=GraphAlgo_DominatingSetGreedyH
+target18.showInterface=false
+target18.type=ClassTarget
+target18.width=250
+target18.x=290
+target18.y=520
+target19.height=50
+target19.name=GraphAlgo_DominatingSetGreedyI
+target19.showInterface=false
+target19.type=ClassTarget
+target19.width=240
+target19.x=290
+target19.y=570
+target2.height=50
+target2.name=GraphAlgo_Tiefensuche
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=210
+target2.x=20
+target2.y=170
+target20.height=50
+target20.name=GraphAlgo_Moore
+target20.showInterface=false
+target20.type=ClassTarget
+target20.width=210
+target20.x=20
+target20.y=440
+target21.height=50
+target21.name=GraphAlgo_BellmanFord
+target21.showInterface=false
+target21.type=ClassTarget
+target21.width=210
+target21.x=20
+target21.y=560
+target22.height=50
+target22.name=GraphAlgo_Breitensuche
+target22.showInterface=false
+target22.type=ClassTarget
+target22.width=210
+target22.x=20
+target22.y=290
+target23.height=50
+target23.name=GraphAlgo_toplogischeSortierung
+target23.showInterface=false
+target23.type=ClassTarget
+target23.width=240
+target23.x=20
+target23.y=370
+target24.height=50
+target24.name=GraphAlgo_DominatingSetBacktracking
+target24.showInterface=false
+target24.type=ClassTarget
+target24.width=270
+target24.x=290
+target24.y=100
+target25.height=50
+target25.name=GraphAlgo_ColoringGreedy
+target25.showInterface=false
+target25.type=ClassTarget
+target25.width=240
+target25.x=600
+target25.y=530
+target26.height=50
+target26.name=GraphAlgo_EulerkreisExistenz
+target26.showInterface=false
+target26.type=ClassTarget
+target26.width=210
+target26.x=20
+target26.y=100
+target27.height=50
+target27.name=GraphAlgo_TiefensucheRek
+target27.showInterface=false
+target27.type=ClassTarget
+target27.width=210
+target27.x=20
+target27.y=230
+target28.height=50
+target28.name=GraphAlgo_TSPGreedy2
+target28.showInterface=false
+target28.type=ClassTarget
+target28.width=230
+target28.x=600
+target28.y=220
+target29.height=50
+target29.name=GraphAlgo_ColoringBacktracking
+target29.showInterface=false
+target29.type=ClassTarget
+target29.width=240
+target29.x=600
+target29.y=470
+target3.height=50
+target3.name=GraphAlgo_MST_Prim
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=230
+target3.x=890
+target3.y=100
+target30.height=50
+target30.name=GraphAlgo_Dijkstra
+target30.showInterface=false
+target30.type=ClassTarget
+target30.width=210
+target30.x=20
+target30.y=500
+target31.height=50
+target31.name=GraphAlgo_TSPGreedyOpt
+target31.showInterface=false
+target31.type=ClassTarget
+target31.width=230
+target31.x=600
+target31.y=280
+target4.height=50
+target4.name=GraphAlgo_TSPBacktracking
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=230
+target4.x=600
+target4.y=100
+target5.height=50
+target5.name=GraphAlgo_DominatingSetGreedyB
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=240
+target5.x=290
+target5.y=220
+target6.height=50
+target6.name=GraphAlgo
+target6.showInterface=false
+target6.type=AbstractTarget
+target6.width=90
+target6.x=310
+target6.y=10
+target7.height=50
+target7.name=GraphAlgo_DominatingSetGreedyC
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=240
+target7.x=290
+target7.y=270
+target8.height=50
+target8.name=GraphAlgo_MST_Kruskal
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=230
+target8.x=890
+target8.y=160
+target9.height=50
+target9.name=GraphAlgo_DominatingSetGreedyA
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=250
+target9.x=290
+target9.y=170

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/01_eulerkreis/01_4inseln.csv

@@ -0,0 +1,21 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,inseln4.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+188,244,3,2,1
+196,127,0,2
+331,164,0,1,3
+315,297,0,2

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/01_eulerkreis/02_5inseln.csv

@@ -0,0 +1,22 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,inseln5.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+196,130,4,1
+319,168,0,3,4,2
+403,199,1,4
+312,284,1,4
+199,225,0,1,2,3

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/01_eulerkreis/03_zusammenhang_beispiel1.csv

@@ -0,0 +1,31 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Größe der Knoten
+vertexSize,19
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+122,257,2,1
+284,196,0,3,10,11
+191,353,0,3,8
+332,293,1,2
+438,240,6,5,7
+448,402,4,6,7
+218,273,4,5,9
+198,431,4,5,9
+334,382,2,11
+107,365,6,7
+488,195,1,11
+488,326,1,8,10

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/01_eulerkreis/04_zusammenhang_beispiel2.csv

@@ -0,0 +1,31 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Größe der Knoten
+vertexSize,19
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,0
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+122,257,2,1
+284,196,0,3,10,11,6
+191,353,0,3,8
+332,293,1,2
+438,240,5,7
+448,402,4,6,7
+218,273,1,5,9
+198,431,4,5,9
+334,382,2,11
+107,365,6,7
+488,195,1,11
+488,326,1,8,10

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/02_topologischesortierung/01_aufbausimulation1.csv

@@ -0,0 +1,26 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,siedlerohnefischer.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,1
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list,infotext
+Farm,284,83,1,3
+Mühle,533,109,2
+Bäckerei,690,154,6,5
+Schweinefarm,124,239,4
+Metzger,171,404,5,6
+Kohlemine,425,441,7,8
+Erzmine,734,308,7
+Eisenschmelze,552,336,8
+Werkzeugmacher,401,258,0,4,5,7

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/02_topologischesortierung/02_aufbausimulation2.csv

@@ -0,0 +1,27 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,siedler.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,1
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list,infotext
+Farm,285,101,1,3
+Mühle,531,105,2
+Bäckerei,694,159
+Schweinefarm,119,239,4
+Metzger,167,409
+Kohlemine,423,445,7,8
+Erzmine,724,314,7
+Eisenschmelze,537,326,8
+Werkzeugmacher,389,246,0,4
+Fischerhütte,741,456,6,5

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/01_seerosenteich.csv

@@ -0,0 +1,20 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,00e090,FF0000,A0A0A0
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,teich.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/02_deutschlandkarte.csv

@@ -0,0 +1,60 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Kantenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,AAAAAA,FF0000,A0A0A0
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,deutschland_bundeslaende_bunt.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzmatrix vor. 
+# Jede Zeile steht fuer einen Knoten, durch Kommas getrennt stehen die Kantengewicht zu jedem anderen Knoten.
+matrix,infotext
+Aachen,25,415,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,60.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Augsburg,314,654,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,61.0,-,-,-,-,-,-,-,-,-,-,-,83.0,-,-
+Bayreuth,358,502,-,-,-,-,-,-,-,187.0,-,-,-,-,-,-,-,-,-,-,-,-,-,198.0,-,-,-,-,-,-,74.0,-,-,159.0,-,-,-,-,-,-,-,147.0
+Berlin,457,250,-,-,-,-,-,125.0,-,-,-,-,91.0,-,-,-,-,-,-,-,-,-,-,184.0,-,131.0,-,-,-,130.0,-,-,-,-,-,-,200.0,-,-,-,-,-
+Bremen,192,196,-,-,-,-,-,-,-,-,-,-,-,-,-,-,110.0,118.0,-,-,-,-,-,-,-,-,-,-,-,-,-,120.0,-,-,-,-,-,-,-,-,110.0,-
+Cottbus,509,312,-,-,-,-,-,-,138.0,-,-,-,119.0,-,-,-,-,-,-,-,-,-,-,244.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Dresden,488,375,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,140.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Erfurt,313,400,-,-,-,-,-,-,-,-,-,-,-,-,180.0,-,-,-,-,135.0,-,-,-,170.0,-,209.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Essen,82,348,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,188.0,-,-,75.0,-,-,-,-,-,87.0,-,-,-,-,-,-,-,-,-,-,-,-,-
+Frankfurt/Main,178,476,-,-,-,-,-,-,-,-,-,-,-,-,95.0,-,-,-,-,-,-,125.0,-,-,-,-,106.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Frankfurt/Oder,523,269,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Freiburg,124,683,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,130.0,-,-,-,-,-,175.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Fulda,234,438,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,105.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,100.0
+Garmisch-Part.,337,723,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,155.0,-,-,89.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Hamburg,261,153,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,154.0,-,-,85.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,120.0,-,-,-,-,-
+Hannover,244,267,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,238.0,-,-,-,-,-,136.0,-,-,-,-,-,135.0,-,-,-,-,-,-,-,-,-,-
+Karlsruhe,153,598,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,58.0,-,-,-,-,-,-,-,-,-,-,81.0,-,-,-,-
+Kassel,222,374,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,243.0,-,-,247.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Kiel,270,83,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,139.0,-,-,-,-,-
+Koblenz,114,462,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,110.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,128.0,-,-,-
+Köln,77,390,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,217.0,-,-,-
+Leipzig,403,362,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,108.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Lindau,203,712,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,216.0,-,126.0,-,-
+Magdeburg,356,293,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Mannheim,173,544,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,117.0,-,-,-,-,-,162.0
+München,372,672,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,162.0,-,180.0,106.0,-,-,-,-,-,-,-,-
+Münster,113,309,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,60.0,-,-,-,-,-,-,-,-,-,-
+Neubrandenburg,433,156,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,103.0,-,187.0,-,-,-,-,-
+Nürnberg,335,550,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,105.0,-,-,-,-,-,-,-,108.0
+Osnabrück,144,274,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Passau,472,625,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,128.0,-,-,-,-,-,-,-,-
+Regensburg,405,584,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Rostock,381,111,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,90.0,-,-,-,-,-
+Saarbrücken,67,561,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,103.0,-,-,-
+Schwerin,343,143,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Stuttgart,205,614,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,100.0,-,157.0
+Trier,48,508,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Ulm,256,647,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Wilhelmshaven,148,159,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+Würzburg,269,512,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/03_badenbaden.csv

@@ -0,0 +1,199 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,9
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,badenbaden.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+645,600,1,91.0,52,32.0
+655,690,0,91.0,2,62.0
+685,636,1,62.0,3,58.0,5,139.0
+686,578,2,58.0,4,122.0,52,54.0
+700,457,3,122.0,8,15.0,54,47.0
+782,536,2,139.0,6,59.0,16,154.0,17,139.0
+758,482,5,59.0,10,30.0
+768,407,8,74.0,10,46.0,50,92.0
+715,458,4,15.0,7,74.0,9,64.0
+779,463,8,64.0,11,13.0,15,88.0
+764,453,6,30.0,7,46.0,11,17.0
+781,450,9,13.0,10,17.0,12,98.0
+832,366,11,98.0,14,43.0,13,96.0
+860,274,12,96.0,51,48.0,64,123.0,96,53.0,97,100.0
+874,377,12,43.0,15,57.0
+861,432,9,88.0,14,57.0,16,27.0
+886,422,5,154.0,15,27.0,56,32.0
+914,491,5,139.0,19,128.0,57,24.0
+926,564,21,131.0,57,70.0,92,148.0
+817,575,17,128.0,20,33.0,22,212.0
+839,599,19,33.0,21,48.0
+822,644,18,131.0,20,48.0,99,112.0
+691,745,19,212.0,23,18.0,24,71.0
+703,758,22,18.0
+629,780,22,71.0,25,63.0,98,38.0
+598,725,24,63.0,26,37.0,27,32.0
+564,739,25,37.0,30,96.0
+589,694,25,32.0,28,77.0,29,68.0
+592,617,27,77.0,29,34.0,37,61.0
+562,632,27,68.0,28,34.0,30,33.0,32,67.0
+533,648,26,96.0,29,33.0,31,65.0,104,20.0
+518,585,30,65.0,32,10.0,105,20.0
+524,577,29,67.0,31,10.0,33,14.0
+519,564,32,14.0,34,29.0,45,32.0
+546,554,33,29.0,39,23.0,35,36.0
+534,520,34,36.0,38,22.0,44,19.0,41,26.0
+585,499,40,19.0,37,57.0,38,34.0
+590,556,28,61.0,36,57.0,39,21.0
+555,514,35,22.0,36,34.0,39,46.0
+569,558,34,23.0,37,21.0,38,46.0
+596,483,36,19.0,54,60.0,41,69.0,48,75.0
+528,495,35,26.0,40,69.0,43,25.0
+483,503,45,38.0,43,20.0,46,43.0
+503,499,41,25.0,42,20.0,44,33.0
+517,529,35,19.0,43,33.0,45,18.0
+501,537,33,32.0,42,38.0,44,18.0
+465,464,42,43.0,47,36.0,176,58.0
+480,431,46,36.0,55,58.0,109,59.0
+602,408,40,75.0,49,31.0,55,70.0
+608,378,48,31.0,50,116.0,93,66.0
+715,332,7,92.0,49,116.0,51,109.0,60,120.0
+820,301,13,48.0,50,109.0,58,72.0
+633,570,0,32.0,3,54.0,53,47.0
+639,523,52,47.0,54,62.0
+653,463,4,47.0,40,60.0,53,62.0
+538,437,47,58.0,48,70.0
+910,401,16,32.0,80,170.0,65,108.0
+938,495,17,24.0,18,70.0
+821,229,51,72.0,59,25.0
+841,214,58,25.0,60,62.0
+782,233,50,120.0,59,62.0,61,14.0
+770,225,60,14.0,62,41.0,111,68.0
+801,198,61,41.0,97,73.0,115,105.0
+911,139,73,80.0,97,55.0
+953,194,13,123.0,69,144.0,95,64.0,96,79.0
+911,293,56,108.0,66,148.0,96,32.0
+1043,227,65,148.0,79,43.0
+1323,213,78,179.0,68,127.0
+1199,185,67,127.0,69,103.0,94,74.0
+1096,175,64,144.0,68,103.0,79,59.0,70,82.0
+1051,106,69,82.0,76,48.0,71,64.0,95,69.0
+987,114,70,64.0,73,24.0,72,54.0,95,47.0
+950,154,71,54.0
+976,93,63,80.0,71,24.0,74,90.0
+1056,52,73,90.0,76,20.0,75,92.0
+1140,14,74,92.0
+1073,63,70,48.0,74,20.0,77,236.0
+1306,103,76,236.0
+1147,244,67,179.0,79,62.0
+1086,233,66,43.0,69,59.0,78,62.0,80,75.0
+1040,292,56,170.0,79,75.0,83,68.0,82,90.0
+1221,299,82,92.0
+1129,308,80,90.0,81,92.0,83,73.0
+1071,352,80,68.0,82,73.0,84,53.0,92,115.0
+1113,384,83,53.0,88,261.0,85,60.0
+1168,361,84,60.0,86,73.0
+1239,377,85,73.0,87,142.0
+1376,340,86,142.0
+1029,631,84,261.0,89,150.0
+908,720,88,150.0,90,24.0
+887,709,89,24.0,91,108.0
+799,771,90,108.0,106,73.0
+1031,460,18,148.0,83,115.0
+561,331,49,66.0,110,101.0,112,38.0,125,39.0
+1272,171,68,74.0
+1005,157,64,64.0,70,69.0,71,47.0
+911,261,13,53.0,64,79.0,65,32.0
+870,175,13,100.0,62,73.0,63,55.0
+654,808,24,38.0,99,125.0,100,62.0
+754,733,21,112.0,98,125.0
+592,811,98,62.0,101,68.0
+524,809,100,68.0,102,83.0,104,154.0
+441,807,101,83.0,103,165.0,144,70.0
+493,650,102,165.0,105,62.0,104,22.0
+514,655,30,20.0,101,154.0,103,22.0
+498,588,31,20.0,103,62.0
+840,831,91,73.0,107,170.0
+1008,804,106,170.0,108,142.0
+1108,703,107,142.0
+459,376,47,59.0,125,74.0,122,42.0,139,51.0,176,54.0
+644,274,93,101.0,111,67.0,114,41.0
+707,251,61,68.0,110,67.0,115,31.0
+543,298,93,38.0,113,44.0,124,35.0
+579,272,112,44.0,116,23.0,114,72.0
+640,233,110,41.0,113,72.0,116,71.0,115,60.0
+699,221,62,105.0,111,31.0,114,60.0
+571,250,113,23.0,114,71.0,117,60.0
+516,274,116,60.0,123,48.0,118,42.0
+489,242,117,42.0,119,43.0,135,53.0
+446,246,118,43.0,120,72.0,136,81.0
+419,179,119,72.0,126,21.0,133,61.0
+523,106,133,67.0
+463,334,109,42.0,123,32.0,134,35.0
+483,309,117,48.0,122,32.0,124,30.0,135,36.0
+512,315,112,35.0,123,30.0,125,24.0
+522,337,93,39.0,109,74.0,124,24.0
+433,194,120,21.0,129,39.0,128,39.0,127,43.0
+470,215,126,43.0
+472,190,126,39.0,129,20.0,131,30.0
+465,171,126,39.0,128,20.0,130,25.0,132,25.0
+475,148,129,25.0,132,19.0,133,15.0
+499,177,128,30.0,132,19.0
+488,162,129,25.0,130,19.0,131,19.0
+464,138,120,61.0,121,67.0,130,15.0
+431,320,122,35.0,139,30.0,135,44.0,137,60.0
+457,284,118,53.0,123,36.0,134,44.0
+369,221,119,81.0,142,56.0,140,58.0,137,62.0
+385,281,134,60.0,136,62.0,138,32.0
+359,299,137,32.0,140,82.0,139,75.0,178,25.0
+417,347,109,51.0,134,30.0,138,75.0,177,64.0
+312,232,136,58.0,138,82.0,141,52.0
+320,181,140,52.0,143,83.0,142,30.0
+348,169,136,56.0,141,30.0,143,74.0
+326,98,141,83.0,142,74.0
+371,814,102,70.0,145,56.0
+317,801,144,56.0,146,81.0
+335,722,145,81.0,147,59.0,157,141.0
+277,731,146,59.0,148,146.0
+164,824,147,146.0,149,113.0
+64,771,148,113.0,150,62.0
+123,752,149,62.0,165,102.0,151,167.0
+243,636,150,167.0,152,48.0,156,65.0
+213,598,151,48.0,153,46.0,154,49.0
+167,593,152,46.0
+202,550,152,49.0,179,34.0,155,69.0,163,38.0
+266,525,154,69.0,156,65.0,161,49.0
+286,587,151,65.0,155,65.0,157,47.0
+333,581,146,141.0,156,47.0,158,62.0
+368,530,157,62.0,159,69.0
+332,471,158,69.0,175,70.0,160,51.0
+282,483,159,51.0,162,26.0,163,79.0
+313,511,155,49.0,162,52.0
+262,500,160,26.0,161,52.0
+208,512,154,38.0,160,79.0,174,72.0,164,229.0
+5,617,163,229.0,167,77.0
+34,703,150,102.0,166,117.0
+130,636,165,117.0
+9,540,164,77.0,168,183.0
+170,454,167,183.0,169,42.0,173,35.0
+129,463,168,42.0,170,58.0
+137,406,169,58.0,171,71.0
+70,429,170,71.0,172,66.0
+9,453,171,66.0
+203,441,168,35.0,174,101.0
+136,517,163,72.0,173,101.0
+393,437,159,70.0,177,71.0,176,38.0
+427,420,46,58.0,109,54.0,175,38.0
+359,375,139,64.0,175,71.0,178,69.0
+337,310,138,25.0,177,69.0
+171,563,154,34.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/04_inseln.csv

@@ -0,0 +1,25 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,2_mst_insel_karte_trans.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+579,272,3,700.0,1,310.0,7,130.0,2,500.0
+356,334,0,310.0,3,180.0,4,200.0,2,110.0,7,420.0,6,350.0
+429,245,0,500.0,1,110.0,7,90.0,6,170.0,4,460.0
+291,436,0,700.0,1,180.0,5,230.0,4,190.0
+262,251,1,200.0,2,460.0,3,190.0,5,100.0,6,80.0
+113,199,3,230.0,4,100.0,6,70.0
+290,113,1,350.0,2,170.0,4,80.0,5,70.0,7,380.0
+501,166,0,130.0,1,420.0,2,90.0,6,380.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/05_gerichtet.csv

@@ -0,0 +1,30 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,0
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Kantenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,000000,FF0000,A0A0A0
+# Knotenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: nichts, markiert, besucht, besucht und markiert
+# mind. 12 Farben müssen angegeben werden.vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,1
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+130,30,2,5.0
+40,90,0,8.0,3,2.0,4,18.0
+220,90,1,10.0,3,3.0
+130,170,4,12.0,6,30.0
+40,230,5,4.0
+130,280,3,14.0,6,26.0
+220,230,2,16.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/06_negative_kantengewichte.csv

@@ -0,0 +1,24 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,0
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,1
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+130,30,1,8.0,2,5.0
+40,90,0,8.0,3,2.0,4,18.0,2,-6.0
+220,90,0,5.0,1,-6.0,6,16.0,3,3.0
+130,170,1,2.0,2,3.0,5,14.0,6,-10.0,4,-3.0
+40,230,1,18.0,3,-3.0,5,4.0
+130,280,3,14.0,4,4.0,6,26.0
+220,230,2,16.0,3,-10.0,5,26.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/03_routenplanung/07_negative_kantengewichte2.csv

@@ -0,0 +1,24 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,1
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,1
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+130,30,1,8.0,2,5.0
+40,90,0,8.0,3,2.0,4,18.0,2,-6.0
+220,90,0,5.0,1,-6.0,6,16.0,3,5.0
+130,170,1,2.0,2,5.0,5,14.0,6,-10.0,4,-3.0
+40,230,1,18.0,3,-3.0,5,4.0
+130,280,3,14.0,4,4.0,6,26.0
+220,230,2,16.0,3,-10.0,5,26.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/01_eisverkaeufer_blanko.csv

@@ -0,0 +1,17 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,eis2.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/02_eisverkaeufer.csv

@@ -0,0 +1,51 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Größe der Knoten
+vertexSize,17
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,eis2.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+15,16,1,21
+112,15,0,15,2
+218,14,1,7,3
+328,13,2,4,6
+405,13,3,5
+406,80,4,10,6
+326,81,3,5,8,7
+223,80,2,6,13,14,15
+326,174,6,9,28,13
+366,174,8,10,12
+409,175,5,9,11
+416,232,10,31,12
+374,237,9,11,30
+222,175,7,8,27,17,14
+173,122,7,13,16
+111,82,1,7,16,20
+110,123,14,15,17
+109,174,13,16,26,18
+64,173,17,23,19
+63,129,18,20,22
+64,81,15,19,21
+16,80,0,20,22
+17,128,19,21,23
+18,172,18,22,24
+18,294,23,25
+109,294,24,29,26
+109,246,17,25,27
+221,246,13,26,28
+325,247,8,27,29
+327,296,25,28,30
+373,297,12,29,31
+416,294,11,30

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/03_graph_knoten5.csv

@@ -0,0 +1,22 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,2
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,0
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# gerichtet 1, ungerichtet 0
+directed,0
+# Der Graph liegt hier in Form einer Adjazenzliste vor.
+# Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+list
+247,228,1,3
+458,188,0,4
+358,310,4,3
+252,400,0,2,4
+436,461,1,2,3