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

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/04_graph_knoten6.csv

@@ -0,0 +1,23 @@
+# 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
+229,211,1,3,2
+458,188,0,4,5
+358,310,0,4
+252,400,0,4
+444,439,1,2,3,5
+525,331,1,4

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/05_graph_knoten7.csv

@@ -0,0 +1,24 @@
+# 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
+229,211,3,2,6
+431,265,4,5,2
+358,310,0,1,4,6,3
+252,400,0,2,4
+444,439,1,2,3,5
+525,331,1,4,6
+390,71,0,2,5

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/06_graph_knoten8.csv

@@ -0,0 +1,25 @@
+# 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
+229,211,3,2,6
+431,265,4,5,2
+358,310,0,1,4,6,3
+252,400,0,2,4
+444,439,1,2,3,5
+525,331,1,4,6,7
+390,71,0,2,5,7
+610,168,5,6

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/07_graph_knoten9.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,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
+229,211,3,2,6
+431,265,4,5,2
+358,310,0,1,4,6,3
+252,400,0,2,4
+444,439,1,2,3,5,8
+525,331,1,4,6,7,8
+390,71,0,2,5,7
+610,168,5,6,8
+614,426,4,5,7

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/08_graph_knoten10.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,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
+229,211,3,2,6
+431,265,4,5,2
+358,310,0,1,4,6,3
+252,400,0,2,4
+444,439,1,2,3,5,8
+525,331,1,4,6,7,8,9
+390,71,0,2,5,7,9
+610,168,5,6,8,9
+614,426,4,5,7
+524,191,5,6,7

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/09_graph_knoten15.csv

@@ -0,0 +1,32 @@
+# 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
+229,211,3,2,6,13,12
+431,265,4,5,2
+358,310,0,1,4,6,3
+252,400,0,2,4,14,13
+434,403,1,2,3,5,8,14
+525,331,1,4,6,7,8,9
+390,71,0,2,5,7,9,12,11
+610,168,5,6,8,9,11
+614,426,4,5,7,10,14
+524,191,5,6,7
+752,325,8,11
+671,91,6,7,10
+239,78,0,6,13
+161,288,0,3,12
+338,481,3,4,8

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/10_graph_domknoten6.csv

@@ -0,0 +1,45 @@
+# 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,infotext
+*,123,150,17,18,19,20
+*,412,130,21,22
+*,361,360,12,9,14,13
+*,153,366,15,16
+*,174,540,7,8,6
+*,654,374,11,23,24,25,26,10,27
+,91,486,4,14,7,16
+,249,484,4,6,14,9
+,294,541,4,9,10,27
+,359,467,2,7,8,10,14
+,513,461,5,8,9,11,27
+,519,362,5,10,12
+,466,289,2,11,23,22
+,305,250,2,20,15,14,22
+,283,382,2,6,7,9,13,15
+,188,302,3,13,14
+,51,252,3,6,17,20
+,61,147,0,16,18
+,76,69,0,17,19
+,203,69,0,18,20,21
+,273,165,0,13,16,19,21
+,421,55,1,19,20,22
+,546,117,1,12,13,21,23,24
+,614,259,5,12,22,24
+,696,294,5,22,23,25
+,730,400,5,24,26
+,725,543,5,25,27
+,643,523,5,8,10,26

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/04_dominierendemenge/11_graph_domkonten10.csv

@@ -0,0 +1,59 @@
+# 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,infotext
+*,109,94,34,31,32,33
+*,474,118,35,36,37,38
+*,466,345,19,18,17,16
+*,224,417,25,24,22
+*,272,257,23,20,21
+*,375,568,12,9,10,11
+*,91,552,29,30
+*,45,316,27,26,28
+*,539,514,14,13,15
+,298,517,5,24,10,29
+,402,482,5,9,15,16,23
+,448,569,5,14,15
+,324,608,5,29
+,562,451,8,17,14,16,15
+,602,542,8,11,13
+,473,508,8,10,11,13
+,452,404,2,10,13,19
+,548,356,2,13,36,18
+,492,264,2,17,35
+,405,327,2,16,23
+,316,188,4,40,32
+,213,218,4,32,31,27,28,22
+,227,315,3,21,24
+,352,309,4,10,19,24,35
+,280,377,3,9,22,23
+,147,420,3,28,26,29,30
+,59,388,7,25,30
+,76,269,7,21,34,31
+,118,325,7,21,25
+,171,573,6,9,12,25,30
+,76,486,6,25,26,29
+,101,163,0,21,27
+,193,134,0,20,21,41
+,192,45,0,41,34,38
+,42,46,0,27,33
+,419,157,1,18,23,40
+,548,181,1,17,37
+,568,68,1,36,38
+,406,60,1,33,37,40
+*,302,102,41,40
+,361,114,20,35,38,39
+,248,72,32,33,39

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/05_repraesentation/01_graph1.csv

@@ -0,0 +1,24 @@
+# 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,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,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
+130,30,1,2
+40,90,0,2,3,4
+220,90,0,1,6,3
+130,170,1,2,4,5,6
+40,230,1,3,5
+130,280,3,4,6
+220,230,2,3,5

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/05_repraesentation/02_graph2.csv

@@ -0,0 +1,19 @@
+# Der Graph ist durch kommagetrennte Werte kodiert. Der Graph liegt hier in Form einer Adjazenzmatrix vor. Jede Zeile steht fuer einen Knoten, durch Komma getrennt steht der adjazente Knoten mit dem zugehoerigen Kantengewicht.
+#
+# Header:
+# gerichtet 1, ungerichtet 0
+directed,0
+# gewichtet 1, ungewichtet 0
+weighted,1
+# Knotenfarben
+vertextColor,A0A0A0,FF0000,0000FF,00FF00,FFFF00,00FFFF,FF00FF,FF8080
+#
+# Graph:
+matrix
+130,30,-,8.0,5.0,-,-,-,-
+40,90,8.0,-,10.0,2.0,18.0,-,-
+220,90,5.0,10.0,-,3.0,-,-,16.0
+130,170,-,2.0,3.0,-,12.0,14.0,30.0
+40,230,-,18.0,-,12.0,-,4.0,-
+130,280,-,-,-,14.0,4.0,-,26.0
+220,230,-,-,16.0,30.0,-,26.0,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/01_deutschlandkarte.csv

@@ -0,0 +1,65 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0,446.0,123.0,240.0,721.0,466.0,330.0,740.0,475.0,354.0,345.0,307.0,556.0,145.0,60.0,573.0,625.0,496.0,284.0,650.0,206.0,715.0,472.0,256.0,683.0,570.0,642.0,321.0,590.0,408.0,255.0,505.0,418,367
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0,422.0,601.0,365.0,649.0,340.0,335.0,117.0,720.0,600.0,221.0,432.0,820.0,430.0,538.0,431.0,184.0,530.0,297.0,61.0,620.0,729.0,180.0,580.0,232.0,167.0,782.0,356.0,742.0,149.0,475.0,83.0,825,243
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0,187.0,494.0,264.0,414.0,457.0,187.0,334.0,596.0,460.0,337.0,278.0,693.0,345.0,431.0,198.0,372.0,295.0,329.0,244.0,520.0,494.0,74.0,635.0,273.0,159.0,547.0,446.0,562.0,264.0,485.0,252.0,682,147
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0,288.0,480.0,564.0,91.0,800.0,474.0,686.0,279.0,258.0,670.0,367.0,343.0,610.0,553.0,184.0,739.0,131.0,657.0,596.0,450.0,130.0,426.0,410.0,625.0,511.0,237.0,745.0,200.0,631.0,725.0,604.0,485,490
+Bremen,192,196,-,-,-,-,-,496.0,478.0,351.0,249.0,450.0,467.0,722.0,388.0,856.0,110.0,118.0,595.0,288.0,205.0,415.0,315.0,367.0,780.0,251.0,541.0,766.0,170.0,353.0,590.0,120.0,796.0,690.0,277.0,590.0,228.0,645.0,524.0,660.0,110,490
+Cottbus,509,312,-,-,-,-,-,-,138.0,320.0,608.0,585.0,119.0,800.0,490.0,686.0,430.0,378.0,670.0,502.0,511.0,633.0,683.0,244.0,739.0,233.0,660.0,596.0,579.0,304.0,426.0,528.0,478.0,440.0,382.0,768.0,359.0,631.0,748.0,604.0,598,485
+Dresden,479,388,-,-,-,-,-,-,-,220.0,581.0,485.0,177.0,700.0,390.0,586.0,492.0,385.0,570.0,402.0,573.0,533.0,583.0,140.0,639.0,228.0,560.0,496.0,597.0,366.0,325.0,590.0,378.0,340.0,444.0,668.0,421.0,531.0,648.0,504.0,660,385
+Erfurt,313,400,-,-,-,-,-,-,-,-,367.0,268.0,366.0,533.0,180.0,515.0,376.0,289.0,403.0,135.0,459.0,318.0,373.0,170.0,567.0,209.0,339.0,425.0,384.0,438.0,264.0,373.0,459.0,344.0,435.0,453.0,480.0,435.0,433.0,447.0,451,298
+Essen,82,348,-,-,-,-,-,-,-,-,-,256.0,600.0,524.0,297.0,736.0,350.0,258.0,397.0,188.0,454.0,160.0,75.0,475.0,655.0,384.0,327.0,646.0,87.0,599.0,465.0,135.0,676.0,560.0,525.0,359.0,474.0,472.0,292.0,535.0,290,360
+Frankfurt/Main,178,476,-,-,-,-,-,-,-,-,-,-,661.0,262.0,95.0,502.0,509.0,362.0,135.0,190.0,599.0,125.0,185.0,407.0,430.0,445.0,106.0,412.0,280.0,704.0,235.0,340.0,330.0,326.0,686.0,188.0,629.0,200.0,235.0,310.0,500,130
+Frankfurt/Oder,523,269,-,-,-,-,-,-,-,-,-,-,-,873.0,547.0,759.0,382.0,331.0,743.0,440.0,446.0,683.0,626.0,211.0,812.0,202.0,730.0,669.0,523.0,279.0,499.0,483.0,559.0,584.0,317.0,815.0,306.0,704.0,799.0,677.0,558,647
+Freiburg,124,683,-,-,-,-,-,-,-,-,-,-,-,-,357.0,490.0,759.0,624.0,130.0,457.0,852.0,333.0,435.0,642.0,175.0,700.0,195.0,400.0,548.0,942.0,378.0,556.0,480.0,480.0,935.0,312.0,881.0,207.0,360.0,268.0,716,318
+Fulda,234,438,-,-,-,-,-,-,-,-,-,-,-,-,-,477.0,410.0,272.0,238.0,105.0,504.0,227.0,277.0,311.0,390.0,346.0,166.0,382.0,304.0,605.0,202.0,290.0,412.0,295.0,577.0,290.0,525.0,260.0,345.0,270.0,450,100
+Garmisch-Part.,337,723,-,-,-,-,-,-,-,-,-,-,-,-,-,-,869.0,742.0,360.0,575.0,960.0,580.0,675.0,513.0,155.0,615.0,444.0,89.0,763.0,813.0,267.0,755.0,293.0,195.0,866.0,508.0,855.0,300.0,611.0,181.0,915,389
+Hamburg,260,155,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,154.0,640.0,312.0,85.0,520.0,381.0,387.0,806.0,271.0,580.0,772.0,260.0,235.0,616.0,200.0,816.0,710.0,140.0,690.0,120.0,668.0,624.0,686.0,220,512
+Hannover,244,267,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,500.0,238.0,238.0,410.0,295.0,252.0,656.0,136.0,433.0,647.0,190.0,395.0,476.0,135.0,676.0,567.0,327.0,553.0,269.0,526.0,487.0,536.0,225,369
+Karlsruhe,156,588,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,330.0,731.0,206.0,310.0,515.0,273.0,576.0,58.0,270.0,421.0,815.0,253.0,429.0,459.0,353.0,802.0,188.0,754.0,81.0,233.0,160.0,589,195
+Kassel,222,374,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,405.0,243.0,243.0,278.0,490.0,247.0,265.0,482.0,200.0,508.0,309.0,190.0,509.0,404.0,477.0,383.0,428.0,360.0,361.0,370.0,345,209
+Kiel,270,83,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,600.0,493.0,485.0,895.0,369.0,671.0,882.0,348.0,280.0,702.0,297.0,911.0,800.0,194.0,778.0,139.0,762.0,714.0,715.0,315,605
+Koblenz,114,462,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,110.0,454.0,501.0,496.0,145.0,521.0,243.0,760.0,350.0,300.0,580.0,445.0,687.0,203.0,635.0,270.0,128.0,381.0,460,248
+Köln,77,390,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,488.0,604.0,417.0,247.0,578.0,144.0,646.0,415.0,200.0,611.0,510.0,562.0,283.0,521.0,367.0,217.0,484.0,360,300
+Leipzig,403,362,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,564.0,108.0,497.0,436.0,450.0,322.0,266.0,410.0,461.0,349.0,375.0,585.0,364.0,471.0,568.0,444.0,485,410
+Lindau,203,712,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,727.0,363.0,194.0,683.0,879.0,301.0,733.0,364.0,310.0,932.0,480.0,908.0,216.0,417.0,126.0,888,309
+Magdeburg,356,293,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,505.0,522.0,342.0,269.0,360.0,291.0,563.0,449.0,316.0,611.0,311.0,573.0,599.0,537.0,366,460
+Mannheim,174,539,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,347.0,350.0,761.0,248.0,410.0,444.0,343.0,731.0,117.0,686.0,138.0,146.0,214.0,570,162
+München,372,672,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,668.0,731.0,162.0,655.0,180.0,106.0,771.0,413.0,773.0,210.0,522.0,124.0,825,294
+Münster,113,312,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,529.0,490.0,60.0,695.0,585.0,471.0,427.0,398.0,502.0,361.0,560.0,220,385
+Neubrandenburg,433,156,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,567.0,436.0,762.0,644.0,103.0,870.0,187.0,764.0,871.0,741.0,474,752
+Nürnberg,335,550,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,485.0,205.0,105.0,615.0,356.0,604.0,213.0,309.0,188.0,645,108
+Osnabrück,144,274,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,746.0,585.0,367.0,478.0,317.0,557.0,412.0,610.0,160,390
+Passau,472,625,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,128.0,814.0,562.0,803.0,400.0,618.0,310.0,860,323
+Regensburg,393,583,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,702.0,455.0,699.0,286.0,504.0,208.0,740,207
+Rostock,381,111,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,848.0,90.0,809.0,821.0,791.0,424,702
+Saarbrücken,67,561,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,822.0,210.0,103.0,303.0,633,309
+Schwerin,343,143,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,789.0,763.0,771.0,335,612
+Stuttgart,205,614,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,307.0,100.0,717,157
+Trier,48,508,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,418.0,515,351
+Ulm,256,647,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,770,180
+Wilhelmshaven,149,155,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,554
+Würzburg,269,512,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/02_deutschlandkarte_4staedte.csv

@@ -0,0 +1,29 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0
+Augsburg,322,655,-,-,239.0,593.0
+Bayreuth,358,502,-,-,-,352.0
+Berlin,457,250,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/03_deutschlandkarte_5staedte.csv

@@ -0,0 +1,30 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0
+Augsburg,322,655,-,-,239.0,593.0,715.0
+Bayreuth,358,502,-,-,-,352.0,572.0
+Berlin,457,250,-,-,-,-,375.0
+Bremen,192,196,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/04_deutschlandkarte_6staedte.csv

@@ -0,0 +1,31 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0
+Berlin,457,250,-,-,-,-,375.0,125.0
+Bremen,192,196,-,-,-,-,-,496.0
+Cottbus,509,312,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/05_deutschlandkarte_7staedte.csv

@@ -0,0 +1,32 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0
+Bremen,192,196,-,-,-,-,-,496.0,478.0
+Cottbus,509,312,-,-,-,-,-,-,138.0
+Dresden,479,388,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/06_deutschlandkarte_8staedte.csv

@@ -0,0 +1,33 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0,446.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0,422.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0,187.0
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0,288.0
+Bremen,192,196,-,-,-,-,-,496.0,478.0,351.0
+Cottbus,509,312,-,-,-,-,-,-,138.0,320.0
+Dresden,479,388,-,-,-,-,-,-,-,220.0
+Erfurt,313,400,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/07_deutschlandkarte_9staedte.csv

@@ -0,0 +1,34 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0,446.0,123.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0,422.0,601.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0,187.0,494.0
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0,288.0,480.0
+Bremen,192,196,-,-,-,-,-,496.0,478.0,351.0,249.0
+Cottbus,509,312,-,-,-,-,-,-,138.0,320.0,608.0
+Dresden,479,388,-,-,-,-,-,-,-,220.0,581.0
+Erfurt,313,400,-,-,-,-,-,-,-,-,367.0
+Essen,82,348,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/06_travelingsalesman/08_deutschlandkarte_10staedte.csv

@@ -0,0 +1,35 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,FF0000,A0A0A0
+# Knotenfarben: Farbbeschreibung (z.B. red) oder RGB-Hexcode (z.B. #FF0000) oder invisible
+# Reihenfolge: markiert (+1), besucht(+2), beendet(+4), z.B. markiert+beender=>6.Farbe 
+vertexColor,A0A0A0,FF0000,FFFF00,00FFFF,AA00AA,888800,008888,880088,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0,446.0,123.0,240.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0,422.0,601.0,365.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0,187.0,494.0,264.0
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0,288.0,480.0,564.0
+Bremen,192,196,-,-,-,-,-,496.0,478.0,351.0,249.0,450.0
+Cottbus,509,312,-,-,-,-,-,-,138.0,320.0,608.0,585.0
+Dresden,479,388,-,-,-,-,-,-,-,220.0,581.0,485.0
+Erfurt,313,400,-,-,-,-,-,-,-,-,367.0,268.0
+Essen,82,348,-,-,-,-,-,-,-,-,-,256.0
+Frankfurt/Main,178,476,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/01_coloring_land.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,0
+# Kantenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,606060,FF5080,D0D0D0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,1_coloring_news_trans.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
+161,53,1,3
+227,142,0,2
+154,227,1,3
+65,147,0,2

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/02_coloring_land.csv

@@ -0,0 +1,24 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,2_coloring_news_trans.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
+177,46,1,3
+226,143,0,2,3
+147,227,1,3
+83,134,0,1,2

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/03_coloring_land.csv

@@ -0,0 +1,29 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,3_coloring_land1_trans.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
+38,66,1,7
+111,61,0,2
+170,119,1,3,7
+188,236,2,4,8
+206,315,3,5
+129,316,4,6,8
+54,310,5,7
+30,210,0,2,6,8
+119,259,3,5,7

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/04_coloring_land.csv

@@ -0,0 +1,28 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,4_coloring_land2_trans.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
+66,130,1,6,7
+146,51,0,2,7
+257,38,1,3,7
+384,53,2,4,7
+380,180,3,5,7
+289,255,4,6
+114,237,0,5,7
+216,151,0,1,2,3,4,6

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/05_coloring_land.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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,6_coloring_land4_trans.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
+71,49,1,5
+170,70,0,2,5
+164,231,1,3,5
+94,290,2,4,5
+33,280,3,5
+60,120,0,1,2,3,4

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/06_coloring_land.csv

@@ -0,0 +1,30 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,5_coloring_land3_trans.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
+35,46,1,9,8
+140,49,0,3,2,7,8
+189,25,1,3
+278,74,1,2,4,7
+370,60,3,5,7
+423,263,4,6,7
+148,267,5,7,8,9
+280,170,1,3,4,5,6,8
+90,130,0,1,6,7,9
+26,224,0,6,8

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/07_coloring_painter.csv

@@ -0,0 +1,42 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Größe der Knoten
+vertexSize,12
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,7_coloring_maler_trans.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# 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
+80,40,-,0.0,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+114,28,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+145,29,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+170,53,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+193,69,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-
+114,84,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-
+136,87,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-
+211,88,-,-,-,-,-,-,-,-,0.0,0.0,-,-,-,-,-,-,-,-,-,-
+190,131,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+209,149,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-
+209,170,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-
+172,189,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-
+121,199,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-
+121,229,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-
+120,250,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,0.0,0.0,-,-
+92,289,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-
+146,272,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-
+180,250,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-
+177,290,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0
+182,314,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/08_karte_eu.csv

@@ -0,0 +1,49 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,karte_eu.png
+#
+# Graph:
+# gewichtet 1, ungewichtet 0
+weighted,0
+# 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
+500,224,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+489,145,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+390,160,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+135,329,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+502,259,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+493,294,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+454,356,-,-,-,-,-,-,-,0.0,0.0,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-
+409,419,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,0.0,0.0,-,-,-,-,-,-,-,-,-,-
+336,405,-,-,-,-,-,-,-,-,-,0.0,0.0,0.0,0.0,0.0,-,0.0,-,-,-,-,-,-,-,-,-,-,-
+330,304,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+285,366,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+272,397,-,-,-,-,-,-,-,-,-,-,-,-,0.0,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-
+291,417,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-,-,-,-,-
+245,478,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,0.0,-,-,-
+341,511,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,0.0,-,-,-,-
+401,457,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,0.0,-,-,-,-,0.0,-,-,-,-
+457,432,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-,-,-
+463,462,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,0.0,0.0,-,-,-,-
+540,474,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-,-
+553,535,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-,-,-
+520,603,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+429,492,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-,-,-
+403,487,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+134,591,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,0.0,-,-
+76,572,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+705,646,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-
+409,684,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/07_mapcoloring/09_karte_usa.csv

@@ -0,0 +1,72 @@
+# 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,0
+# 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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,karte_usa.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
+154,82,1,2
+88,140,0,2,9,11
+199,160,0,1,3,4,9,10
+261,108,2,4,5,6
+310,213,2,3,6,7,8,10
+430,112,3,6,21
+446,190,3,4,5,7,20,21
+433,249,4,6,8,16,20
+328,326,4,7,10,13,15,16
+129,263,1,2,10,11,12
+228,297,2,4,8,9,12
+66,308,1,9,12
+205,413,9,10,11,13
+309,416,8,12,14
+480,480,13,15,17,18
+485,403,8,14,16,18,19
+474,333,7,8,15,19
+583,499,14,18,35
+578,416,14,15,17,19,30,35
+577,362,15,16,18,20,25,28,30
+557,249,6,7,19,21,22,25
+538,160,5,6,20,22
+623,196,20,21,23,25
+654,139,22
+700,207,26,27
+634,296,19,20,22,26,28
+686,289,24,25,27,28
+740,270,24,26,28,29,37
+706,353,19,25,26,27,29,30,49
+784,308,27,28,37,46,49
+681,389,18,19,28,31,33,34,35,49
+826,373,30,32,49
+807,421,31,33
+750,425,30,32,34,36
+694,484,30,33,35,36
+638,468,17,18,30,34
+791,527,33,34
+823,245,27,29,38,45,46
+861,186,37,39,42,43,45
+898,150,38,40,41,42
+920,163,39,41,42
+947,113,39,40
+918,186,38,39,40,43,44
+909,217,38,42,44
+943,203,42,43
+897,257,37,38,46
+850,280,29,37,45,49
+113,549
+333,607
+829,332,28,29,30,31,46

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/01_muddy_city.csv

@@ -0,0 +1,29 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# 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,1_mst_muddy_city_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
+123,41,1,5.0,2,3.0,4,4.0
+295,56,0,5.0,3,3.0,5,2.0,2,3.0,9,4.0
+197,90,0,3.0,1,3.0,5,3.0,6,4.0,4,5.0
+377,97,1,3.0,9,2.0
+75,141,0,4.0,2,5.0,7,2.0,6,4.0
+251,144,1,2.0,2,3.0,9,3.0,8,3.0,6,4.0
+160,196,2,4.0,4,4.0,5,4.0,8,2.0,7,3.0
+50,244,4,2.0,6,3.0,8,3.0
+232,255,5,3.0,6,2.0,7,3.0,9,4.0
+358,202,1,4.0,3,2.0,5,3.0,8,4.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/02_deutschlandkarte.csv

@@ -0,0 +1,65 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,1
+# Größe der Knoten
+vertexSize,10
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,0
+# Kantenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,invisible,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,00a0FF,a400FF,FFa400,FF00a4,00FFa4,a4FF00
+# 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,-,570.0,532.0,637.0,369.0,739.0,651.0,446.0,123.0,240.0,721.0,466.0,330.0,740.0,475.0,354.0,345.0,307.0,556.0,145.0,60.0,573.0,625.0,496.0,284.0,650.0,206.0,715.0,472.0,256.0,683.0,570.0,642.0,321.0,590.0,408.0,255.0,505.0,418.0,367.0
+Augsburg,322,655,-,-,239.0,593.0,715.0,574.0,472.0,422.0,601.0,365.0,649.0,340.0,335.0,117.0,720.0,600.0,221.0,432.0,820.0,430.0,538.0,431.0,184.0,530.0,297.0,61.0,620.0,729.0,180.0,580.0,232.0,167.0,782.0,356.0,742.0,149.0,475.0,83.0,825.0,243.0
+Bayreuth,358,502,-,-,-,352.0,572.0,339.0,237.0,187.0,494.0,264.0,414.0,457.0,187.0,334.0,596.0,460.0,337.0,278.0,693.0,345.0,431.0,198.0,372.0,295.0,329.0,244.0,520.0,494.0,74.0,635.0,273.0,159.0,547.0,446.0,562.0,264.0,485.0,252.0,682.0,147.0
+Berlin,457,250,-,-,-,-,375.0,125.0,214.0,288.0,480.0,564.0,91.0,800.0,474.0,686.0,279.0,258.0,670.0,367.0,343.0,610.0,553.0,184.0,739.0,131.0,657.0,596.0,450.0,130.0,426.0,410.0,625.0,511.0,237.0,745.0,200.0,631.0,725.0,604.0,485.0,490.0
+Bremen,192,196,-,-,-,-,-,496.0,478.0,351.0,249.0,450.0,467.0,722.0,388.0,856.0,110.0,118.0,595.0,288.0,205.0,415.0,315.0,367.0,780.0,251.0,541.0,766.0,170.0,353.0,590.0,120.0,796.0,690.0,277.0,590.0,228.0,645.0,524.0,660.0,110.0,490.0
+Cottbus,509,312,-,-,-,-,-,-,138.0,320.0,608.0,585.0,119.0,800.0,490.0,686.0,430.0,378.0,670.0,502.0,511.0,633.0,683.0,244.0,739.0,233.0,660.0,596.0,579.0,304.0,426.0,528.0,478.0,440.0,382.0,768.0,359.0,631.0,748.0,604.0,598.0,485.0
+Dresden,479,388,-,-,-,-,-,-,-,220.0,581.0,485.0,177.0,700.0,390.0,586.0,492.0,385.0,570.0,402.0,573.0,533.0,583.0,140.0,639.0,228.0,560.0,496.0,597.0,366.0,325.0,590.0,378.0,340.0,444.0,668.0,421.0,531.0,648.0,504.0,660.0,385.0
+Erfurt,313,400,-,-,-,-,-,-,-,-,367.0,268.0,366.0,533.0,180.0,515.0,376.0,289.0,403.0,135.0,459.0,318.0,373.0,170.0,567.0,209.0,339.0,425.0,384.0,438.0,264.0,373.0,459.0,344.0,435.0,453.0,480.0,435.0,433.0,447.0,451.0,298.0
+Essen,82,348,-,-,-,-,-,-,-,-,-,256.0,600.0,524.0,297.0,736.0,350.0,258.0,397.0,188.0,454.0,160.0,75.0,475.0,655.0,384.0,327.0,646.0,87.0,599.0,465.0,135.0,676.0,560.0,525.0,359.0,474.0,472.0,292.0,535.0,290.0,360.0
+Frankfurt/Main,178,476,-,-,-,-,-,-,-,-,-,-,661.0,262.0,95.0,502.0,509.0,362.0,135.0,190.0,599.0,125.0,185.0,407.0,430.0,445.0,106.0,412.0,280.0,704.0,235.0,340.0,330.0,326.0,686.0,188.0,629.0,200.0,235.0,310.0,500.0,130.0
+Frankfurt/Oder,523,269,-,-,-,-,-,-,-,-,-,-,-,873.0,547.0,759.0,382.0,331.0,743.0,440.0,446.0,683.0,626.0,211.0,812.0,202.0,730.0,669.0,523.0,279.0,499.0,483.0,559.0,584.0,317.0,815.0,306.0,704.0,799.0,677.0,558.0,647.0
+Freiburg,124,683,-,-,-,-,-,-,-,-,-,-,-,-,357.0,490.0,759.0,624.0,130.0,457.0,852.0,333.0,435.0,642.0,175.0,700.0,195.0,400.0,548.0,942.0,378.0,556.0,480.0,480.0,935.0,312.0,881.0,207.0,360.0,268.0,716.0,318.0
+Fulda,234,438,-,-,-,-,-,-,-,-,-,-,-,-,-,477.0,410.0,272.0,238.0,105.0,504.0,227.0,277.0,311.0,390.0,346.0,166.0,382.0,304.0,605.0,202.0,290.0,412.0,295.0,577.0,290.0,525.0,260.0,345.0,270.0,450.0,100.0
+Garmisch-Part.,337,723,-,-,-,-,-,-,-,-,-,-,-,-,-,-,869.0,742.0,360.0,575.0,960.0,580.0,675.0,513.0,155.0,615.0,444.0,89.0,763.0,813.0,267.0,755.0,293.0,195.0,866.0,508.0,855.0,300.0,611.0,181.0,915.0,389.0
+Hamburg,260,155,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,154.0,640.0,312.0,85.0,520.0,381.0,387.0,806.0,271.0,580.0,772.0,260.0,235.0,616.0,200.0,816.0,710.0,140.0,690.0,120.0,668.0,624.0,686.0,220.0,512.0
+Hannover,244,267,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,500.0,238.0,238.0,410.0,295.0,252.0,656.0,136.0,433.0,647.0,190.0,395.0,476.0,135.0,676.0,567.0,327.0,553.0,269.0,526.0,487.0,536.0,225.0,369.0
+Karlsruhe,156,588,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,330.0,731.0,206.0,310.0,515.0,273.0,576.0,58.0,270.0,421.0,815.0,253.0,429.0,459.0,353.0,802.0,188.0,754.0,81.0,233.0,160.0,589.0,195.0
+Kassel,222,374,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,405.0,243.0,243.0,278.0,490.0,247.0,265.0,482.0,200.0,508.0,309.0,190.0,509.0,404.0,477.0,383.0,428.0,360.0,361.0,370.0,345.0,209.0
+Kiel,270,83,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,600.0,493.0,485.0,895.0,369.0,671.0,882.0,348.0,280.0,702.0,297.0,911.0,800.0,194.0,778.0,139.0,762.0,714.0,715.0,315.0,605.0
+Koblenz,114,462,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,110.0,454.0,501.0,496.0,145.0,521.0,243.0,760.0,350.0,300.0,580.0,445.0,687.0,203.0,635.0,270.0,128.0,381.0,460.0,248.0
+Köln,77,390,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,488.0,604.0,417.0,247.0,578.0,144.0,646.0,415.0,200.0,611.0,510.0,562.0,283.0,521.0,367.0,217.0,484.0,360.0,300.0
+Leipzig,403,362,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,564.0,108.0,497.0,436.0,450.0,322.0,266.0,410.0,461.0,349.0,375.0,585.0,364.0,471.0,568.0,444.0,485.0,410.0
+Lindau,203,712,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,727.0,363.0,194.0,683.0,879.0,301.0,733.0,364.0,310.0,932.0,480.0,908.0,216.0,417.0,126.0,888.0,309.0
+Magdeburg,356,293,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,505.0,522.0,342.0,269.0,360.0,291.0,563.0,449.0,316.0,611.0,311.0,573.0,599.0,537.0,366.0,460.0
+Mannheim,174,539,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,347.0,350.0,761.0,248.0,410.0,444.0,343.0,731.0,117.0,686.0,138.0,146.0,214.0,570.0,162.0
+München,372,672,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,668.0,731.0,162.0,655.0,180.0,106.0,771.0,413.0,773.0,210.0,522.0,124.0,825.0,294.0
+Münster,113,312,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,529.0,490.0,60.0,695.0,585.0,471.0,427.0,398.0,502.0,361.0,560.0,220.0,385.0
+Neubrandenburg,433,156,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,567.0,436.0,762.0,644.0,103.0,870.0,187.0,764.0,871.0,741.0,474.0,752.0
+Nürnberg,335,550,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,485.0,205.0,105.0,615.0,356.0,604.0,213.0,309.0,188.0,645.0,108.0
+Osnabrück,144,274,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,746.0,585.0,367.0,478.0,317.0,557.0,412.0,610.0,160.0,390.0
+Passau,472,625,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,128.0,814.0,562.0,803.0,400.0,618.0,310.0,860.0,323.0
+Regensburg,393,583,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,702.0,455.0,699.0,286.0,504.0,208.0,740.0,207.0
+Rostock,381,111,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,848.0,90.0,809.0,821.0,791.0,424.0,702.0
+Saarbrücken,67,561,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,822.0,210.0,103.0,303.0,633.0,309.0
+Schwerin,343,143,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,789.0,763.0,771.0
+Stuttgart,205,614,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,307.0,100.0,717.0,157.0
+Trier,48,508,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,418.0,515.0,351.0
+Ulm,256,647,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,770.0,180.0
+Wilhelmshaven,149,155,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,554.0
+Würzburg,269,512,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/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/08_minimalspanningtree/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
+572,381,3,700.0,1,310.0,7,130.0,2,500.0
+357,346,0,310.0,3,180.0,4,200.0,2,110.0,7,420.0,6,350.0
+437,253,0,500.0,1,110.0,7,90.0,6,170.0,4,460.0
+274,434,0,700.0,1,180.0,5,230.0,4,190.0
+262,253,1,200.0,2,460.0,3,190.0,5,100.0,6,80.0
+114,181,3,230.0,4,100.0,6,70.0
+303,115,1,350.0,2,170.0,4,80.0,5,70.0,7,380.0
+505,164,0,130.0,1,420.0,2,90.0,6,380.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/05_standardbsp1.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,2,10.0,3,2.0,4,18.0
+220,90,0,5.0,1,10.0,6,16.0,3,3.0
+130,170,1,2.0,2,3.0,4,12.0,5,14.0,6,30.0
+40,230,1,18.0,3,12.0,5,4.0
+130,280,3,14.0,4,4.0,6,26.0
+220,230,2,16.0,3,30.0,5,26.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/06_standardbsp2.csv

@@ -0,0 +1,25 @@
+# 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
+90,70,1,3.0,3,2.0,4,7.0
+220,70,0,3.0,2,1.0,4,8.0
+350,70,1,1.0,4,6.0,5,3.0
+90,150,0,2.0,4,6.0
+220,150,0,7.0,1,8.0,2,6.0,3,6.0,5,3.0,6,6.0,7,5.0
+350,150,2,3.0,4,3.0
+160,230,4,6.0,7,9.0
+280,230,4,5.0,6,9.0

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/08_minimalspanningtree/07_negativekantengewichte.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/10_weitereuebungen/13_2_scotlandyard.csv

@@ -0,0 +1,222 @@
+# Anzeigeoptionen:# Gewichte anzeigen 1, Gewichte nicht anzeigen 0
+showWeights,0
+# Größe der Knoten
+vertexSize,23
+# Knoteninfo anzeigen 1,Knoteninfo nicht anzeigen 0
+showInfoText,1
+# Knoten leer 0, Knotenname anzeigen 1, Wert des Knoten anzeigen 2
+vertexStyle,1
+# Kantenfarben: RGB-Hexcode (z.B. FF0000) oder invisible
+# Reihenfolge: normale Kanten, markierte Kanten, gelöschte Kanten
+edgeColor,0000FF,FF0000,A0A0A0
+# Bild im Hintergrund (bitte im "images"-Ordner ablegen) --> Dateiname angeben. Fall kein Bild bitte 0 schreiben!
+image,scotlandyard.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,48,7,8,57,45
+546,25,19,9
+760,31,10,11,3,21,22
+892,17,2,12
+1434,33,14,15
+1592,32,28,6
+1764,41,5,16,41
+123,123,0,17,18
+267,130,0,18,19
+655,123,1,10,20,33
+761,148,2,9,21
+841,125,2,22
+1002,117,3,22,23,13,51,88,66,45
+1147,86,12,24,14
+1309,76,4,13,15,25,27,28,40
+1457,127,4,14,27,28
+1744,179,6,28,29
+55,185,7,42,30
+176,206,7,8,31
+348,169,1,8,32
+503,235,9,32
+763,261,2,10,33,22,34,64
+888,189,2,11,12,21,36,66
+1091,196,12,36,37
+1177,224,13,37,38
+1301,123,14,38,26
+1323,202,25,39,27
+1383,172,14,15,26,40
+1595,217,5,14,15,16,41,40,54
+1810,204,16,41
+110,250,17,42,43
+291,295,18,43,32,44
+437,273,19,20,31,45
+677,299,9,21,46,47,45,62
+813,332,21,47,35,64
+863,339,34,36,48
+953,262,22,23,35,49
+1130,281,23,24,49,50
+1213,257,24,25,50,51
+1362,311,26,51,40,52
+1409,291,14,27,28,39,53,51,86
+1750,289,6,28,29,55,71
+30,317,17,30,56
+209,360,30,31,57
+341,386,31,57,58,59,45
+460,349,0,12,32,33,44,46,60,57,77,78,73
+550,326,33,45,61
+700,393,33,34,61,62
+902,397,35,49,65
+999,337,36,37,48
+1172,347,37,38,51,66,67
+1258,325,12,38,39,40,50,68,66,85
+1369,385,39,68,53
+1441,362,40,52,54,69
+1596,358,28,53,70,88
+1802,380,41,90
+83,394,42,57,72
+271,415,0,43,44,45,56,58,73,76,74
+311,465,44,57,74,75
+366,448,44,60,75
+491,461,45,59,75,61,77
+559,443,46,47,60,78
+711,521,33,47,78,63,79,64,99
+802,503,62,80,64
+898,485,21,34,62,63,65,81,66
+964,470,48,64,66,81
+1062,454,12,22,50,51,64,65,67,83,101,81,78,88,110
+1186,427,50,66,68,84
+1305,412,51,52,67,85
+1452,439,53,70,86
+1568,437,54,69,88,71
+1705,451,41,70,90,89
+85,469,56,73,91
+150,543,45,57,72,91,74,93
+236,517,57,58,73,93
+356,513,58,59,60,76
+425,568,57,75,94,95,77,93,123
+519,558,45,60,76,78,96
+593,540,45,61,62,66,77,97,92,110
+739,574,62,98,99
+869,596,63,81,99
+916,563,64,65,66,80,100,99,139
+1037,546,100,101
+1121,507,66,84
+1194,478,67,83,102
+1319,529,51,68,102,86,103,101,115
+1451,558,40,69,85,87,104
+1514,576,86,88,116
+1561,531,12,54,66,70,87,104,139,158
+1650,531,71,90,104
+1785,534,55,71,89,106,104
+39,601,72,73,92
+52,655,78,91,93
+168,635,73,74,76,92,94
+222,624,76,93,121
+488,662,76,96,108
+545,641,77,95,97,108
+627,611,78,96,98,109
+693,632,79,97,109,111
+824,664,62,79,80,81,100,112,111,110
+955,612,81,82,99,113
+1114,548,66,82,85,102,114,126
+1217,538,84,85,101
+1320,587,85,115
+1615,613,86,88,89,90,105,117,106
+1724,632,104,106
+1810,638,90,104,105,118,160
+381,740
+575,752,95,96,109,123
+660,669,97,98,108,110
+720,736,66,78,99,109,111,123,162,152
+751,716,98,99,110,124
+878,710,99,113,124
+972,683,100,112,114,125,131,130
+1106,636,101,113,126,125
+1321,716,85,103,126,127,116,117,141
+1472,768,87,115,117,128
+1583,740,104,115,116,118,134
+1764,833,106,117,135
+47,893,120,143
+115,897,119,121,144
+197,888,94,120,122,145,143
+428,879,121,123,136,148,164
+559,853,76,108,110,122,129,137,152
+791,773,111,112,130
+1038,731,113,114,139,126
+1191,767,101,114,115,125,133,132
+1326,805,115,128,141,133
+1457,820,116,127,134,142,141
+757,857,123,138,130
+822,810,113,124,129
+967,802,113,139
+1128,881,126,139,140,156
+1254,836,126,127,140,141
+1525,863,117,128,135,160,142,158
+1725,948,118,134,161
+349,957,122,146
+601,904,123,149,151
+748,909,129,152,153
+965,894,81,88,125,131,132,153,155,152,158
+1174,907,132,133,157,141
+1322,933,115,127,128,133,140,158,156,142,157
+1455,916,128,134,141,159,158
+72,1050,119,121,176,144,162
+131,1043,120,143,145
+223,1038,121,144,146,162
+293,1014,136,145,163
+377,1005,148,163
+453,997,122,147,149,164
+542,970,137,148,150
+589,1007,149,151,165,164
+649,965,137,150,152
+686,1016,110,123,138,139,151,153,166,165,183,179
+833,974,138,139,152,154,155
+882,1038,153,166,167
+991,1037,139,153,156,168,183
+1080,1048,132,141,155,157,169,184
+1222,988,140,141,156,170
+1405,1023,88,134,139,141,142,159,171,187,160,198,186,184
+1509,1041,142,158,160,172
+1638,1029,106,134,158,159,173,198
+1804,1032,135,174
+210,1086,110,143,145,176,190,175
+304,1086,146,147,177,178
+476,1114,122,148,150,178,179,190
+657,1069,150,152,180,182
+798,1095,152,154,182,167
+847,1131,154,166,183
+991,1110,155,183
+1065,1124,156,170,184
+1227,1190,157,169,185,197,171
+1365,1111,158,170,186
+1550,1166,159,187,199,173
+1707,1125,160,172,174
+1793,1188,161,173,199
+41,1178,162,188,189,176
+120,1156,143,162,175
+251,1147,163,188,190
+412,1164,163,164,190
+507,1182,152,164,180,192,189,183
+608,1156,165,179,181,192
+663,1171,180,182,194
+761,1121,165,166,181,195
+917,1192,152,155,167,168,179,195,184,196
+1039,1266,156,158,169,183,185,186
+1145,1240,170,184,197
+1319,1201,158,171,184,187,197
+1479,1201,158,172,186,198
+120,1282,175,177,189
+205,1329,175,179,188,190,191
+311,1241,162,164,177,178,189,191
+338,1350,189,190,193
+582,1249,179,180,193
+611,1289,191,192,194
+686,1286,181,193,196
+791,1219,182,183,196
+816,1293,183,194,195
+1224,1347,170,185,186,198
+1498,1345,158,160,187,197,199
+1594,1315,172,174,198

3_vorlagen_tauschordner/2_graphentester_jar/beispielgraphen/10_weitereuebungen/17_2_oberstufenplan.csv

@@ -0,0 +1,35 @@
+# 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,0
+# 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,infotext
+M,68,104
+m,103,66
+D,207,29
+d,265,30
+Inf,453,283
+E,358,52
+e,398,86
+Ch,299,406
+F,452,146
+f,458,203
+ch,243,405
+s,42,183
+bk,38,256
+b,112,362
+B,159,387
+p,381,380
+P,416,351
+mu,59,306

3_vorlagen_tauschordner/2_graphentester_jar/eigeneAlgorithmen/GraphAlgo_Coloring_Schueler.java

@@ -0,0 +1,57 @@
+package eigeneAlgorithmen;
+
+ 
+
+import java.util.List;
+import java.nio.file.*;
+
+import graph.*;
+import algorithmen.*;
+
+/**
+ * Dieser Algorithmus färbt einen Graphen, so dass keine benachbarten Knoten
+ * die gleiche Farbe haben und möglichst wenige Farben benutzt werden.
+ * Algorithmus: Beispieldatei, in der Schüler den Algorithmus selbst umsetzen können
+ *
+ * @version 1.0 from 10.12.2020
+ * @author Thomas Schaller
+ */
+
+public class GraphAlgo_Coloring_Schueler extends GraphAlgo {
+
+
+  
+  public  String getBezeichnung() {
+    return "Greedy-Coloring (toDo)";
+  }
+
+  // Ende Attribute
+  
+  // Anfang Methoden
+  public void fuehreAlgorithmusAus() {
+    getStartKnoten().setFarbe(3);
+     
+    // Hole alle Knoten vom Graph g
+    
+    // Schleife über alle Knoten
+
+      // Erzeuge Liste (Größe #Knoten +1) in der die Farben der adjazenten Knoten abgehakt werden. Die Farben
+      // sind von 1 bis n (# Knoten) kodiert und werden spaeter in Farben decodiert 
+
+      // Hole alle Nachbarknoten vom aktuellen Knoten
+            
+      // Gehe alle Nachbarn durch und markiere die Farben des Knoten in dem Array farbenliste[] als benutzt
+      
+      // suche die erste Position (>0) aus der Farbliste, die noch nicht benutzt wurden und faerbe den Knoten k mit dieser Farbe (setze den Farbwert des Knotens auf die Position im Array) 
+
+      // Unterbreche die Ausführung
+      step();
+    
+    // Ende der Schleife über alle Knoten   
+ 
+  }
+  
+  // Ende Methoden
+  
+}
+

3_vorlagen_tauschordner/2_graphentester_jar/eigeneAlgorithmen/package.bluej

@@ -0,0 +1,27 @@
+#BlueJ package file
+objectbench.height=93
+objectbench.width=451
+package.divider.horizontal=0.599476439790576
+package.divider.vertical=0.8
+package.editor.height=393
+package.editor.width=649
+package.editor.x=819
+package.editor.y=382
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=0
+package.numTargets=1
+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_Coloring_Schueler
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=210
+target1.x=10
+target1.y=90