Subtrees hinzugefügt

Quellcodes/alg_ds_graphentester/+libs/LICENSECommonsIO.txt

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

Quellcodes/alg_ds_graphentester/+libs/LICENSEJDom.txt

@@ -0,0 +1,56 @@
+/*-- 
+
+ $Id: LICENSE.txt,v 1.11 2004/02/06 09:32:57 jhunter Exp $
+
+ Copyright (C) 2000-2004 Jason Hunter & Brett McLaughlin.
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions, and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions, and the disclaimer that follows 
+    these conditions in the documentation and/or other materials 
+    provided with the distribution.
+
+ 3. The name "JDOM" must not be used to endorse or promote products
+    derived from this software without prior written permission.  For
+    written permission, please contact <request_AT_jdom_DOT_org>.
+ 
+ 4. Products derived from this software may not be called "JDOM", nor
+    may "JDOM" appear in their name, without prior written permission
+    from the JDOM Project Management <request_AT_jdom_DOT_org>.
+ 
+ In addition, we request (but do not require) that you include in the 
+ end-user documentation provided with the redistribution and/or in the 
+ software itself an acknowledgement equivalent to the following:
+     "This product includes software developed by the
+      JDOM Project (http://www.jdom.org/)."
+ Alternatively, the acknowledgment may be graphical using the logos 
+ available at http://www.jdom.org/images/logos.
+
+ THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED.  IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ SUCH DAMAGE.
+
+ This software consists of voluntary contributions made by many 
+ individuals on behalf of the JDOM Project and was originally 
+ created by Jason Hunter <jhunter_AT_jdom_DOT_org> and
+ Brett McLaughlin <brett_AT_jdom_DOT_org>.  For more information
+ on the JDOM Project, please see <http://www.jdom.org/>. 
+
+ */
+

Quellcodes/alg_ds_graphentester/.gitignore

@@ -0,0 +1,10 @@
+**/*.class
+**/*.ctxt
+**/*.sh
+repo.adoc
+repo_subtree.adoc
+*.~lock
+/alt
+/hide
+Gemfile
+Gemfile.lock

Quellcodes/alg_ds_graphentester/GraphenTester.java

@@ -0,0 +1,53 @@
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.layout.VBox;
+import javafx.scene.image.Image;
+import javafx.stage.Stage;
+import control.Controller;
+
+/**
+ * Dies ist die Startklasse für die GUI des Graphentesters
+ * In BlueJ gibt es teilweise Probleme, dass die Menüs bei Mausklick nicht
+ * offen bleiben. Dann bitte das Programm über die Main-Funktion starten.
+ * 
+ * @author Dirk Zechnall, Thomas Schaller
+ * @version 28.02.2023 (v7.0)
+ * 
+ */
+
+public class GraphenTester extends Application {
+
+    @Override
+    public void start(Stage primaryStage) {
+       try {
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("/view/graphenalgorithmen.fxml"));
+        Controller c = new Controller();
+        c.setStage(primaryStage);                             
+        loader.setController(c);
+        VBox root = (VBox) loader.load();
+        Scene scene = new Scene(root);
+        Image icon = new Image("/view/icon.png");
+        primaryStage.getIcons().add(icon);
+        primaryStage.setScene(scene);
+        primaryStage.show();
+        primaryStage.setOnCloseRequest(e ->
+                {
+                    c.saveAktConfig();
+                    
+                    c.mBeenden(null);
+                    System.exit(0);
+                });
+        
+    
+    } 
+       catch(Exception e)    {
+        System.out.println(e);
+        e.printStackTrace();
+    }
+    }
+    public static void main(String[] args) {
+      new Thread(() -> Application.launch(GraphenTester.class)).start();
+    }
+}

Quellcodes/alg_ds_graphentester/README.TXT

@@ -0,0 +1,15 @@
+PROJEKTBEZEICHNUNG: GraphenTester
+PROJEKTZWECK: Didaktisches Werkzeug um Graphenrepräsentation und -algorithmen kennen zu lernen
+VERSION oder DATUM: 24.06.2021
+
+INSTALLATIONSHINWEISE:
+im Ordner Hintergrund
+
+WIE IST DAS PROJEKT IN BLUEJ ZU STARTEN:
+Rechtsklick auf die Klasse Graphentester
+--> new 
+--> OK
+
+AUTOR(EN): Dirk Zechnall / Thomas Schaller
+**********************************************************************************************
+

Quellcodes/alg_ds_graphentester/algorithmen/GraphAlgo.java

@@ -0,0 +1,259 @@
+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;
+
+/**
+ *
+ * Abstrakte Oberklasse für alle zu simulierende Algorithmen
+ * Diese müssen die Methode getBezeichnung(): String und fuehreAlgorithmusAus() überschreiben.
+ *
+ * @version 6.7 (Dez. 2020)
+ * @author Thomas Schaller
+ */
+
+public abstract class GraphAlgo extends Thread {
+
+    // Anfang Attribute
+    private boolean stepping;           // Einzelschrittmodus
+    private boolean waitforrepaint;     // wird gerade gezeichnet (=> nicht nochmal zeichnen beauftragen)
+    private boolean waitforclick;       // wird auf Klick für nächsten Step gewartet
+    protected boolean inArbeit; 
+    protected GraphPlotter gp;        
+    private Knoten startKnoten;
+    private int speed =100;
+    private Hilfe hilfe;
+    protected Graph g;
+    private List<String> aktuellerZustand;
+    // Ende Attribute
+
+    // Anfang Methoden
+    /**
+     * Erzeugt neues Algorithmus-Objekt
+     */
+    public GraphAlgo() {
+        stepping = true;    
+        waitforrepaint = false;
+        waitforclick = false;
+        aktuellerZustand = null;
+        setDaemon(true);
+    }
+
+    /**
+     * Setzt die Referenz auf die GraphAnzeige und das Hilfefenster
+     * @param graphPlotter
+     * @param hilfe
+     */
+    public void setGUIElemente(GraphPlotter graphPlotter, Hilfe hilfe) {
+        gp = graphPlotter;
+        g = gp.getGraph();
+        this.hilfe = hilfe;
+        if (hilfe != null) hilfe.setGraphPlotter(gp);
+    }
+
+    /**
+     * Setzt Referenz auf den Graphen
+     * @param g Graph auf den der Algorithmus angewendet wird
+     */
+    public void setGraph(Graph g) {
+        this.g = g;
+        gp = null;
+        hilfe = null;
+    }
+
+    /**
+     * Gibt Referenz auf den Graphen zurück
+     * @return g Graph, auf den der Algorithmus angewendet wird
+     */
+    public Graph getGraph() {
+        return g;
+    }
+
+    /**
+     * Muss vom Algorithmus aufgerufen werden, um einen Haltepunkt zu setzen
+     */
+    public void step() {
+        if(gp == null) return;
+        try{
+            //System.out.println("Step");
+            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();
+        }
+    }
+
+    /**
+     * Wird gerade auf einen Buttonklick für den nächsten Step gewartet?
+     * @return true/false
+     */
+    public boolean getWaitforclick() {
+        return waitforclick;
+    }
+
+    /**
+     * Setzt, ob gewartet wird. Damit kann übermittelt werden, dass der Button gedrückt wurde
+     * @param wairforclickNeu Soll weiter gewartet werden?
+     */
+    public void setWaitforclick(boolean waitforclickNeu) {
+        waitforclick = waitforclickNeu;
+    }
+
+    /**
+     * Setzt, ob im Einzelschrittmodus ausgeführt werden soll
+     * @param stepping true/false
+     */
+    public void setStepping(boolean stepping) {
+        this.stepping = stepping;
+    }
+
+    /**
+     * Setzt die Wartezeit im automatischen Modus
+     * @param delay Wartezeit
+     */
+    public void setSpeed(int delay) {
+        this.speed = delay;
+    }
+
+    /**
+     * Ausführung des Algorithmus
+     */
+    public void run()
+    {
+        if(!inArbeit && gp != null)
+        {
+            // System.out.println("Algorithmus gestartet");
+            inArbeit = true;
+            try{
+                if (hilfe != null) hilfe.setReviewAllowed(false);
+                fuehreAlgorithmusAus();
+                gp.updateImage();
+                // System.out.println("Algorithmus beendet");
+            } catch( ThreadDeath e){
+                // System.out.println("Algorithmus vorzeitig beendet."+e); 
+            }
+            if (hilfe != null) hilfe.setReviewAllowed(true);
+            inArbeit = false;
+            return;
+        }
+        else
+        {
+            return;
+        }
+    }
+    // Ende Methoden
+
+    /**
+     * Setzen des Startknotens
+     * @param k Startknoten
+     */
+    public void setStartKnoten(Knoten k) {
+        startKnoten = k;
+    }
+
+    /**
+     * Abfragen des Startknotens für den Algorithmus
+     * @return gesetzter Startknoten oder Knoten Nr. 0
+     */
+    public Knoten getStartKnoten() {
+        if (startKnoten != null) {
+            return startKnoten;
+        } else {
+            return g.getKnoten(0);
+        } // end of if-else
+    }
+
+    /**
+     * Methode für den eigentlichen Algorithmus
+     */
+    public abstract void fuehreAlgorithmusAus();
+
+    /**
+     * Name des Algorithmus für die Dropdown-Auswahl
+     */
+    public abstract String getBezeichnung();
+
+    /**
+     * Öffnet ein Anzeigefenster mit einer Meldung. Die 
+     * Meldung wird ggf. auch im Hilfefenster angezeigt.
+     * Ist für die Verwendung im Algorithmus gedacht.
+     * @param s Meldung
+     */
+    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();
+            });
+    }
+
+    /**
+     * Text in das Hilfefenster einfügen
+     * Ist für die Verwendung im Algorithmus gedacht.
+     * @param s Hilfetext
+     */
+    public void info(String s) {
+        if(hilfe != null) hilfe.append(s+"\n");
+    }
+
+    /**
+     * Löscht das Hilfefenster
+     */
+    public void resetInfo() {
+        if(hilfe != null) hilfe.loescheAlles();
+    }
+
+    /**
+     * Rückt im Hilfefenster eine Ebene tiefer ein.
+     * Ist für die Verwendung im Algorithmus gedacht.
+     */
+    public void infoIndentMore() {
+        if(hilfe != null) hilfe.indentMore();
+
+    }
+
+    /**
+     * Rückt im Hilfefenster eine Ebene aus.
+     * Ist für die Verwendung im Algorithmus gedacht.
+     */
+    public void infoIndentLess() {
+        if(hilfe != null) hilfe.indentLess();
+
+    }
+
+    /**
+     * Initialisiert den Graphen
+     */
+    public void init() {
+        gp.getGraphOptions().knotenKurztext = new String[]{"Wert"};
+        gp.getGraphOptions().knotenLangtext = new String[]{"Infotext","Wert","Markiert","Besucht"};
+        if(g.isGewichtet()) {
+            gp.getGraphOptions().kanteKurztext = new String[]{"Gewicht"};
+            gp.getGraphOptions().kanteLangtext = new String[]{"Gewicht","Markiert","Gelöscht"};
+        } else {
+            gp.getGraphOptions().kanteKurztext = new String[]{};
+            gp.getGraphOptions().kanteLangtext = new String[]{"Markiert","Gelöscht"};
+        }
+    }
+
+}

Quellcodes/alg_ds_graphentester/algorithmen/GraphAlgo_BellmanFord.java

@@ -0,0 +1,87 @@
+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()+")";
+        }
+    }
+
+    public void init() {
+        for(Knoten k : g.getAlleKnoten()) {
+            k.setWert(Double.POSITIVE_INFINITY);
+        }
+        info("Setze alle Entfernungen auf unendlich");
+    }
+
+    // Anfang Methoden
+    public void fuehreAlgorithmusAus() {
+        if (g.getAnzahlKnoten()==0) {
+            return;
+        } 
+
+        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
+}

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+  
+}
+

Quellcodes/alg_ds_graphentester/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
+  
+}
+

Quellcodes/alg_ds_graphentester/algorithmen/GraphAlgo_Dijkstra.java

@@ -0,0 +1,91 @@
+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)";
+    }
+
+    public void init() {
+        super.init();
+        for(Knoten k : g.getAlleKnoten()) {
+            k.setWert(Double.POSITIVE_INFINITY);
+        }
+        info("Setze alle Entfernungen auf unendlich");
+    }
+    // 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.getDoubleWert() > k.getDoubleWert()+ka.getGewicht()){
+                        if(n.isBesucht()) {
+                            List<Kante> eingehend = g.getEingehendeKanten(n, ka2 -> !ka2.isGeloescht() && ka2.isMarkiert());
+                            Kante alterWeg = eingehend.get(0);
+                            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
+
+}
+

Quellcodes/alg_ds_graphentester/algorithmen/GraphAlgo_DijkstraMitVorgaenger.java

@@ -0,0 +1,109 @@
+package algorithmen;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.nio.file.*;
+import java.util.Arrays;
+
+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_DijkstraMitVorgaenger extends GraphAlgo {
+
+    // Anfang Attribute
+    public  String getBezeichnung() {
+        return "Kürzester Pfad (Dijkstra mit Vorgänger)";
+    }
+
+
+    public void init() {
+        List<Knoten> alle = g.getAlleKnoten();
+        for(Knoten k : alle) {
+            k.set("Vorgänger","-");
+            k.set("Entfernung",Double.POSITIVE_INFINITY);
+            k.setSortierkriterium("Entfernung");
+        }
+       gp.getGraphOptions().knotenKurztext = new String[]{"Entfernung","Vorgänger"};
+       gp.getGraphOptions().knotenLangtext = new String[]{"Infotext","Entfernung","Vorgänger","Markiert","Besucht"};
+    }
+    
+    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().set("Entfernung", 0);
+        toDo.add(getStartKnoten());
+
+        while(toDo.size()>0) {
+            info("Sortiere toDo-Liste nach der Entfernung");
+            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.getString("Entfernung"));
+            info("Für jeden Nachbarknoten");
+            infoIndentMore();
+            for(Knoten n : g.getNachbarknoten(k)) {
+                if(!n.isMarkiert()){
+                    if(!n.getInfotext().isEmpty()) {
+                      info("- "+n.getInfotext()+" ist noch nicht markiert");   
+                    } else {
+                      info("- Knoten Nr. "+g.getNummer(n)+" ist noch nicht markiert");   
+                    }
+                    Kante ka = g.getKante(k, n);
+                    if(!n.isBesucht() || n.getDouble("Entfernung") > k.getDouble("Entfernung") + 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.set("Entfernung", k.getInt("Entfernung")+ka.getGewicht());
+                        if(k.getInfotext().equals("")) {
+                          n.set("Vorgänger",g.getNummer(k));
+                        } else {
+                          n.set("Vorgänger",k.getInfotext());
+                        }
+                        if(!toDo.contains(n)) toDo.add(n);
+                        ka.setMarkiert(true);
+                        n.setBesucht(true);
+                        info("  setze Entfernung "+n.getString("Entfernung")+" 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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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();
+        }    
+
+    }
+
+}

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+  
+}
+

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+}

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/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
+
+}
+

Quellcodes/alg_ds_graphentester/algorithmen/GraphAlgo_toplogischeSortierung.java

@@ -0,0 +1,73 @@
+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 mit dem geringsten Wert: "+g.getKnoteninfo(k,false)+" und markiere ihn.");
+
+          if(k.getIntWert() != 0) {
+              melde("Fehler: Wert ist nicht 0 - Zyklus vorhanden - Keine topologische Sortierung möglich");
+              knoten.clear();
+              return;
+          } else {
+             reihenfolge += " "+g.getKnoteninfo(k, false);
+             info("Füge ihn der Liste hinzu: "+reihenfolge);
+             knoten.remove(k);
+             info("Reduziere den Wert aller Nachbarn von "+g.getKnoteninfo(k,false)+" um 1");
+             infoIndentMore();
+             for(Knoten k2 : g.getNachbarknoten(k)) {
+               k2.setWert(k2.getIntWert()-1);
+               info("Setze "+g.getKnoteninfo(k2, false)+" auf "+k2.getIntWert());
+             }
+             infoIndentLess();
+          }
+          step();
+        }
+        melde("Topologische Sortierung: "+reihenfolge);
+        
+    } // end
+
+    // Ende Methoden
+
+}
+

Quellcodes/alg_ds_graphentester/algorithmen/package.bluej

@@ -0,0 +1,268 @@
+#BlueJ package file
+dependency1.from=GraphAlgo_DominatingSetGreedyF
+dependency1.to=GraphAlgo
+dependency1.type=UsesDependency
+dependency2.from=GraphAlgo_DominatingSetGreedyF
+dependency2.to=GraphAlgo_Moore
+dependency2.type=UsesDependency
+dependency3.from=GraphAlgo_DominatingSetGreedyG
+dependency3.to=GraphAlgo
+dependency3.type=UsesDependency
+dependency4.from=GraphAlgo_DominatingSetGreedyG
+dependency4.to=GraphAlgo_Moore
+dependency4.type=UsesDependency
+dependency5.from=GraphAlgo_DominatingSetGreedyE
+dependency5.to=GraphAlgo
+dependency5.type=UsesDependency
+dependency6.from=GraphAlgo_DominatingSetGreedyE
+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=66
+objectbench.width=1428
+package.divider.horizontal=0.6003172085646312
+package.divider.vertical=0.9027962716378163
+package.editor.height=671
+package.editor.width=1292
+package.editor.x=100
+package.editor.y=118
+package.frame.height=852
+package.frame.width=1452
+package.numDependencies=8
+package.numTargets=32
+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=290
+target1.x=740
+target1.y=590
+target10.height=50
+target10.name=GraphAlgo_DominatingSetGreedyF
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=280
+target10.x=430
+target10.y=420
+target11.height=50
+target11.name=GraphAlgo_DominatingSetGreedyG
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=290
+target11.x=430
+target11.y=470
+target12.height=50
+target12.name=GraphAlgo_TSPGreedy
+target12.showInterface=false
+target12.type=ClassTarget
+target12.width=230
+target12.x=740
+target12.y=160
+target13.height=50
+target13.name=GraphAlgo_DominatingSetGreedyD
+target13.showInterface=false
+target13.type=ClassTarget
+target13.width=290
+target13.x=430
+target13.y=320
+target14.height=50
+target14.name=GraphAlgo_TSPGenetisch
+target14.showInterface=false
+target14.type=ClassTarget
+target14.width=230
+target14.x=740
+target14.y=340
+target15.height=50
+target15.name=GraphAlgo_DominatingSetGreedyE
+target15.showInterface=false
+target15.type=ClassTarget
+target15.width=280
+target15.x=430
+target15.y=370
+target16.height=50
+target16.name=GraphAlgo_DominatingSetGenetisch
+target16.showInterface=false
+target16.type=ClassTarget
+target16.width=300
+target16.x=430
+target16.y=640
+target17.height=50
+target17.name=GraphAlgo_ZyklusBacktracking
+target17.showInterface=false
+target17.type=ClassTarget
+target17.width=230
+target17.x=160
+target17.y=410
+target18.height=50
+target18.name=GraphAlgo_DominatingSetGreedyH
+target18.showInterface=false
+target18.type=ClassTarget
+target18.width=290
+target18.x=430
+target18.y=520
+target19.height=50
+target19.name=GraphAlgo_DominatingSetGreedyI
+target19.showInterface=false
+target19.type=ClassTarget
+target19.width=280
+target19.x=430
+target19.y=570
+target2.height=50
+target2.name=GraphAlgo_Tiefensuche
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=210
+target2.x=160
+target2.y=160
+target20.height=50
+target20.name=GraphAlgo_Moore
+target20.showInterface=false
+target20.type=ClassTarget
+target20.width=210
+target20.x=150
+target20.y=480
+target21.height=50
+target21.name=GraphAlgo_BellmanFord
+target21.showInterface=false
+target21.type=ClassTarget
+target21.width=210
+target21.x=150
+target21.y=660
+target22.height=50
+target22.name=GraphAlgo_Breitensuche
+target22.showInterface=false
+target22.type=ClassTarget
+target22.width=210
+target22.x=160
+target22.y=280
+target23.height=50
+target23.name=GraphAlgo_toplogischeSortierung
+target23.showInterface=false
+target23.type=ClassTarget
+target23.width=250
+target23.x=160
+target23.y=350
+target24.height=50
+target24.name=GraphAlgo_DominatingSetBacktracking
+target24.showInterface=false
+target24.type=ClassTarget
+target24.width=320
+target24.x=430
+target24.y=100
+target25.height=50
+target25.name=GraphAlgo_ColoringGreedy
+target25.showInterface=false
+target25.type=ClassTarget
+target25.width=240
+target25.x=740
+target25.y=530
+target26.height=50
+target26.name=GraphAlgo_DijkstraMitVorgaenger
+target26.showInterface=false
+target26.type=ClassTarget
+target26.width=250
+target26.x=150
+target26.y=600
+target27.height=50
+target27.name=GraphAlgo_EulerkreisExistenz
+target27.showInterface=false
+target27.type=ClassTarget
+target27.width=220
+target27.x=160
+target27.y=100
+target28.height=50
+target28.name=GraphAlgo_TiefensucheRek
+target28.showInterface=false
+target28.type=ClassTarget
+target28.width=210
+target28.x=160
+target28.y=220
+target29.height=50
+target29.name=GraphAlgo_TSPGreedy2
+target29.showInterface=false
+target29.type=ClassTarget
+target29.width=230
+target29.x=740
+target29.y=220
+target3.height=50
+target3.name=GraphAlgo_TSPBacktracking
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=240
+target3.x=740
+target3.y=100
+target30.height=50
+target30.name=GraphAlgo_ColoringBacktracking
+target30.showInterface=false
+target30.type=ClassTarget
+target30.width=270
+target30.x=740
+target30.y=470
+target31.height=50
+target31.name=GraphAlgo_Dijkstra
+target31.showInterface=false
+target31.type=ClassTarget
+target31.width=210
+target31.x=150
+target31.y=540
+target32.height=50
+target32.name=GraphAlgo_TSPGreedyOpt
+target32.showInterface=false
+target32.type=ClassTarget
+target32.width=230
+target32.x=740
+target32.y=280
+target4.height=50
+target4.name=GraphAlgo_MST_Prim
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=230
+target4.x=1030
+target4.y=100
+target5.height=50
+target5.name=GraphAlgo_DominatingSetGreedyB
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=290
+target5.x=430
+target5.y=220
+target6.height=50
+target6.name=GraphAlgo
+target6.showInterface=false
+target6.type=AbstractTarget
+target6.width=100
+target6.x=450
+target6.y=10
+target7.height=50
+target7.name=GraphAlgo_DominatingSetGreedyC
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=290
+target7.x=430
+target7.y=270
+target8.height=50
+target8.name=GraphAlgo_MST_Kruskal
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=230
+target8.x=1030
+target8.y=160
+target9.height=50
+target9.name=GraphAlgo_DominatingSetGreedyA
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=290
+target9.x=430
+target9.y=170

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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,1
+# 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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/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

Quellcodes/alg_ds_graphentester/config.csv

@@ -0,0 +1,3 @@
+false,false
+180.0,174.0,1328.0,762.0
+

Quellcodes/alg_ds_graphentester/control/Controller.java

@@ -0,0 +1,586 @@
+package control;
+
+import imp.*;
+import graph.*;
+import algorithmen.*;
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.FileWriter;
+
+import javafx.fxml.*;
+import javafx.scene.control.*;
+import javafx.scene.control.Alert.AlertType;
+import javafx.event.*;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.Node;
+import javafx.scene.text.*;
+import javafx.geometry.Pos;
+import javafx.stage.*;          // Dateiöffnen / Speichern-Dialog
+import java.io.File;
+import java.nio.file.*; 
+import javafx.stage.FileChooser.ExtensionFilter;
+import javafx.scene.image.Image;
+import javafx.geometry.Rectangle2D;
+
+import java.util.List;
+import java.util.ArrayList;
+import javafx.collections.ObservableList;
+/**
+ * Die Klasse Controller stellt den Controller des Hauptfensters / Menu dar.
+ *
+ * @author Thomas Schaller
+ * @version 03.03.2023 (v7.1)
+ * v7.0: Die aktuelle Bildschirmposition und der angezeigte Graph werden in config.csv abgelegt.
+ * v7.1: Verzeichnisauswahl für Laden/Speichern verbessert
+ */
+
+public class Controller {
+    private String version = "7.0 (Februar 2023)";
+    private String pfad;  // Pfad der aktuell angezeigten Datei
+
+    @FXML
+    private TabPane tpRekursionen;
+
+    @FXML
+    private CheckMenuItem mOptionKnotenwerte;
+
+    @FXML
+    private CheckMenuItem mOptionKnotenname;
+
+    @FXML
+    private CheckMenuItem mOptionKantengewichte;
+
+    @FXML
+    private CheckMenuItem mOptionKnoteninfo;
+
+    @FXML
+    private CheckMenuItem mOptionBild;
+
+    @FXML
+    private CheckMenuItem mHilfefenster;
+
+    @FXML
+    private MenuItem mmSpeichern;
+
+    @FXML
+    private Menu mmBearbeiten;
+
+    @FXML
+    private Menu mmExperimentieren;
+
+    @FXML
+    private Menu mmSimulieren;
+
+    @FXML
+    private Menu mmZuruecksetzen;
+
+    @FXML
+    private Menu mmAnsicht;
+
+    private FileChooser dateidialog;
+    private Graph graph;
+    private GraphOptions options;
+    private Stage stage;
+
+    public void initialize() {
+
+        dateidialog = new FileChooser();
+        dateidialog.setInitialDirectory(new File("beispielgraphen"));
+
+        oeffneHauptTab();
+        mNeuerGraph(null);
+
+        tpRekursionen.getSelectionModel().selectedItemProperty().
+        addListener((value, tabOld, tabNew) -> changeTab(tabOld, tabNew));
+
+        BufferedReader in =null;
+        try{
+            in = new BufferedReader(new FileReader("config.csv"));
+            String fullScreen = in.readLine();
+            String posSize = in.readLine();
+            String[] ps = posSize.split(",");
+            Rectangle2D ss = Screen.getPrimary().getBounds();
+            
+            stage.setX(Double.parseDouble(ps[0]));
+            stage.setY(Double.parseDouble(ps[1]));
+            stage.setWidth(Math.min(Double.parseDouble(ps[2]), ss.getWidth()-Double.parseDouble(ps[0])));
+            stage.setHeight(Math.min(Double.parseDouble(ps[3]), ss.getHeight()-Double.parseDouble(ps[1])));
+            String[] fs = fullScreen.split(",");
+            if(fs[0].equals("true")) stage.setFullScreen(true);
+            if(fs[1].equals("true")) stage.setMaximized(true);
+            pfad = in.readLine();
+            File f = new File(pfad);
+            f.getCanonicalPath();
+            if(!pfad.isBlank() && f.exists()){
+                graphLaden(pfad);
+                dateidialog.setInitialDirectory((f.getAbsoluteFile()).getParentFile());
+            } else {
+                pfad = "";
+            }
+        }
+        catch(Exception e) {
+            pfad = "";
+            dateidialog.setInitialDirectory(new File("beispielgraphen"));
+        }
+        finally{
+            try{if(in != null) in.close();} catch(IOException e) {}
+            showTitle();
+        }
+
+    }
+
+    public void saveAktConfig() {
+        PrintWriter pWriter = null;
+        String s = "config.csv";
+        try {
+            pWriter = new PrintWriter(new FileWriter(s));
+            pWriter.println(stage.isFullScreen()+","+stage.isMaximized());
+            stage.setFullScreen(false);
+            stage.setMaximized(false);
+            pWriter.println(stage.getX()+","+stage.getY()+","+stage.getWidth()+","+ stage.getHeight());
+            pWriter.println(pfad);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        } finally {
+            if (pWriter != null) {
+                pWriter.flush();
+                pWriter.close();
+            }
+        }
+    }
+
+    private void changeTab(Tab tabOld, Tab tabNew) {
+        if(tpRekursionen.getTabs().indexOf(tabNew)<tpRekursionen.getTabs().size()-2) {
+            tpRekursionen.getSelectionModel().select(tabOld);
+        } else {
+
+            if(tpRekursionen.getTabs().indexOf(tabNew)==tpRekursionen.getTabs().size()-2) {
+                tpRekursionen.getTabs().remove(tpRekursionen.getTabs().size()-1);
+            }
+            ((TabMitController) tabNew).update();
+            this.menuChangeAnsicht();
+        }
+    }
+
+    private void oeffneHauptTab() {
+        try {  // try-catch ist notwendig, um Fehler durch fehlende Dateien abzufangen.
+
+            HauptTabMitController newtab = new HauptTabMitController(graph, options);
+            newtab.setText("Graph");
+            tpRekursionen.getTabs().add(newtab);
+            FXMLLoader loader = new FXMLLoader(getClass().getResource("/view/haupttab.fxml"));
+            loader.setController(newtab);
+            newtab.setContent((Node) loader.load());
+            tpRekursionen.getSelectionModel().select(newtab);
+
+        } 
+        catch(Exception e)    {
+          //  System.out.println(e);
+        }   
+    }
+
+    public void setStage(Stage s){
+        stage = s;
+    }
+
+    @FXML
+    void mNeuerGraph(ActionEvent event) {
+        while(tpRekursionen.getTabs().size()>1) tpRekursionen.getTabs().remove(1);
+
+        TabMitController tc = (TabMitController) (tpRekursionen.getTabs().get(0));
+
+        graph = new Graph();
+        options = new GraphOptions(graph);
+        tc.setGraph(graph, options);
+        pfad = "";
+
+        showTitle();
+        menuChangeAnsicht();
+    } 
+
+    void schliesseTabs() {
+        while(tpRekursionen.getTabs().size()>1) {
+            TabMitController tc = (TabMitController) (tpRekursionen.getTabs().get(1));
+            if(tc instanceof SimulationTabMitController) {
+                ((SimulationTabMitController) tc).showHilfe(false);
+            }
+            tpRekursionen.getTabs().remove(1);
+        }
+    }
+
+    @FXML
+    void mBearbeiten(MouseEvent event) {
+
+        try {  // try-catch ist notwendig, um Fehler durch fehlende Dateien abzufangen.
+            schliesseTabs();
+            EditTabMitController newtab = new EditTabMitController(graph, options);
+            newtab.setText("Bearbeiten");
+            tpRekursionen.getTabs().add(newtab);
+            FXMLLoader loader = new FXMLLoader(getClass().getResource("/view/edittab.fxml"));
+            loader.setController(newtab);
+            newtab.setContent((Node) loader.load());
+            tpRekursionen.getSelectionModel().select(newtab);
+        } 
+        catch(Exception e)    {
+            //System.out.println(e);
+        }   
+    }
+
+    @FXML
+    void mSimuliere(MouseEvent event) {
+
+        try {  // try-catch ist notwendig, um Fehler durch fehlende Dateien abzufangen.
+            schliesseTabs();
+
+            SimulationTabMitController newtab = new SimulationTabMitController(graph, options);
+            newtab.setText("Algorithmen-Simulation");
+            tpRekursionen.getTabs().add(newtab);
+            FXMLLoader loader = new FXMLLoader(getClass().getResource("/view/simulationstab.fxml"));
+            loader.setController(newtab);
+            newtab.setContent((Node) loader.load());
+            tpRekursionen.getSelectionModel().select(newtab);
+        } 
+        catch(Exception e)    {
+         //   System.out.println(e);
+        }   
+    }    
+
+    @FXML
+    void mExperimentiereKanten(ActionEvent event) {
+        schliesseTabs();
+
+        GraphOptions neu = options.copy();
+        neu.bildAnzeigen = false;
+        neu.auswahl = 0;
+        neu.fokusArt  = 1;
+        neu.parent    = null;
+        // neu.markiert  = Auswahl.BELIEBIG;
+        // neu.geloescht = Auswahl.BELIEBIG;
+        // neu.besucht   = Auswahl.BELIEBIG;
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.tabOeffnen(neu);
+    }
+
+    @FXML
+    void mExperimentiereKnoten(ActionEvent event) {
+        schliesseTabs();
+
+        GraphOptions neu = options.copy();
+        neu.bildAnzeigen = false;
+        neu.auswahl = 0;
+        neu.fokusArt  = 0;
+        neu.parent    = null;
+        if(neu.farbenKanten[0].equals("invisible")) neu.farbenKanten[0]="808080";
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.tabOeffnen(neu);
+    }
+
+    @FXML
+    void mExperimentiereAuswahl(ActionEvent event) {
+        schliesseTabs();
+
+        GraphOptions neu = options.copy();
+        neu.bildAnzeigen = false;
+        neu.auswahl = 2;
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+
+        if(tc.viewer.getSelectedKnoten() != null) {
+            neu.fokusArt  = 0; // Knoten
+            neu.parent    = tc.viewer.getSelectedKnoten();
+            tc.tabOeffnen(neu);
+
+        } else {
+            if(tc.viewer.getSelectedKante() != null) {
+                neu.fokusArt = 1; //Kante
+                neu.parent = tc.viewer.getSelectedKante();
+                tc.tabOeffnen(neu);
+
+            }
+        }
+    }
+
+    @FXML
+    public void mBeenden(ActionEvent event) {
+        saveAktConfig();
+        schliesseTabs();
+        ((Stage)tpRekursionen.getScene().getWindow()).close();
+        System.exit(0);
+    }
+
+    void menuChangeAnsicht() {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        mOptionBild.setSelected(options.bildAnzeigen);
+        mOptionKantengewichte.setSelected(options.showEdgeWeights);
+        mOptionKnotenname.setSelected(options.showVertexText);
+        mOptionKnotenwerte.setSelected(options.showVertexValue);
+        mOptionKnoteninfo.setSelected(options.showVertexInfo);
+
+        mmSpeichern.setDisable(!tc.getText().equals("Bearbeiten"));
+        /*        mmBearbeiten.setDisabled(!tc.getText().equals("Graph"));
+        mmExperimentieren.setVisible(tc.getText().equals("Graph"));
+        mmSimulieren.setVisible(tc.getText().equals("Graph"));
+        mmZuruecksetzen.setVisible(!tc.getText().equals("Bearbeiten"));
+         */
+        mmAnsicht.setDisable(tc.getText().equals("Bearbeiten"));
+        if(tc.getText().equals("Algorithmen-Simulation")) {
+            mHilfefenster.setDisable(false);
+        } else 
+        {
+            mHilfefenster.setSelected(false);
+            mHilfefenster.setDisable(true);
+        }
+
+    } 
+
+    @FXML
+    void mChangeOptionBild(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        options.bildAnzeigen = mOptionBild.isSelected();
+        tc.update();
+    }
+
+    @FXML
+    void mChangeOptionKantengewichte(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        options.showEdgeWeights = mOptionKantengewichte.isSelected();
+        tc.update();
+    }
+
+    @FXML
+    void mChangeOptionKnoteninfo(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        options.showVertexInfo = mOptionKnoteninfo.isSelected();
+        tc.update();
+    }
+
+    @FXML
+    void mChangeOptionKnotenname(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        options.showVertexText = mOptionKnotenname.isSelected();
+        if(options.showVertexText) {
+            options.showVertexValue = false;
+            mOptionKnotenwerte.setSelected(false);
+        }
+        tc.update();
+    }
+
+    @FXML
+    void mChangeOptionKnotenwerte(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        GraphOptions options = tc.getGraphOptions();
+        options.showVertexValue = mOptionKnotenwerte.isSelected();
+        if(options.showVertexValue) {
+            options.showVertexText = false;
+            mOptionKnotenname.setSelected(false);
+        }
+        tc.update();
+    }
+
+    @FXML
+    void mChangeHilfefenster(ActionEvent event) {
+        TabMitController tc = (TabMitController) (tpRekursionen.getTabs().get(tpRekursionen.getTabs().size()-1));
+        if(tc instanceof SimulationTabMitController) {
+            ((SimulationTabMitController) tc).showHilfe(mHilfefenster.isSelected());
+        }
+    }
+
+    @FXML
+    void mOeffnen(ActionEvent event) {
+        dateidialog.getExtensionFilters().clear();
+        dateidialog.getExtensionFilters().add(new ExtensionFilter("Graph-Datei (*.csv)", "*.csv"));                                          
+
+        File file = dateidialog.showOpenDialog(null);
+        if (file != null) {
+            graphLaden(file.getAbsolutePath());
+            dateidialog.setInitialDirectory(file.getAbsoluteFile().getParentFile());
+        }
+    }
+
+    void graphLaden(String p) {
+
+        while(tpRekursionen.getTabs().size()>2) tpRekursionen.getTabs().remove(1);
+        TabMitController tc = (TabMitController) (tpRekursionen.getTabs().get(0));
+
+        File f = new File(p); 
+        if(f.exists() ){
+            pfad = p;
+
+            Table csvParser = new Table(pfad,"",',','"');
+
+            graph = new Graph();
+            graph.ladeGraph(csvParser);
+
+            options = new GraphOptions(graph);
+            options.ladeGraph(csvParser);
+
+            tc.setGraph(graph, options);
+
+            if(tpRekursionen.getTabs().size()>1){
+                tc = (TabMitController) (tpRekursionen.getTabs().get(1));
+                tc.setGraph(graph, options);
+            }
+        } 
+
+        menuChangeAnsicht();
+        showTitle();
+
+    }
+
+    public void showTitle() {
+
+        if(stage!=null) {
+            if(pfad == null || pfad.equals("")) {
+                stage.setTitle("GraphTester by Thomas Schaller - Version "+version);
+            } else {
+                String[] arr = pfad.split("[/\\\\]");
+                String dateiname = arr[arr.length-1];
+                stage.setTitle("GraphTester by Thomas Schaller - Version "+version+" - "+dateiname);
+            }
+        }
+
+    }
+
+    @FXML
+    void mSchliessen(ActionEvent event) {
+        mNeuerGraph(event);
+    }
+
+    @FXML
+    void mSpeichern(ActionEvent event) {
+        dateidialog.getExtensionFilters().clear();
+        dateidialog.getExtensionFilters().add(new ExtensionFilter("Graph-Datei (*.csv)", "*.csv"));
+        if(!pfad.isBlank())
+            dateidialog.setInitialFileName(new File(pfad).getName());
+        else 
+            dateidialog.setInitialFileName("");
+
+        File file = dateidialog.showSaveDialog(null);
+        if (file != null) {
+            try{
+                TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+                GraphOptions options = tc.getGraphOptions();
+                String text = options.getText();
+                text += "#\n# Graph:\n";
+                text +=graph.toCSVString(options.saveAsMatrix);
+                String dateiName = file.getAbsolutePath();
+                String name = dateiName.substring(dateiName.lastIndexOf("\\")+1);
+                if(name.contains(".")) dateiName = dateiName.substring(0, dateiName.lastIndexOf("."));
+                Files.write(Paths.get(file.getAbsolutePath()), text.getBytes());
+                pfad = file.getAbsolutePath();
+                dateidialog.setInitialDirectory(file.getAbsoluteFile().getParentFile());
+                showTitle();
+            } catch(Exception e) {
+
+            }
+        }
+
+    }
+
+    @FXML
+    void mBildExportieren(ActionEvent event) {
+        dateidialog.getExtensionFilters().clear();
+        dateidialog.getExtensionFilters().add(new ExtensionFilter("Bild des Graphen", "*.png","*.gif"));
+        File file = dateidialog.showSaveDialog(null);
+        if (file != null) {
+            try{
+                TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+                Picture p = tc.getViewer().updateImage();
+                String dateiName = file.getAbsolutePath();
+                p.save(dateiName);
+
+            } catch(Exception e) {
+
+            }
+        }
+    }       
+
+    @FXML
+    void mUeber(ActionEvent event) {
+        Alert alert = new Alert(AlertType.INFORMATION);
+        alert.setTitle("Graphtester");
+        alert.setHeaderText(null);
+        alert.setContentText("Mit diesem Programm können Sie Graphen modellieren, Graphenalgorithmen von Hand durchspielen oder implementierte Algorithmen schrittweise ausführen.\n\n"+
+            "Version: "+version+"\nThomas Schaller\nLandesfachgruppe Informatik (ZSL BW)\n"+
+            "Lizenz: CC BY-NC 4.0 (https://creativecommons.org/licenses/by-nc/4.0/deed.de)\n\n"+
+            "3rd Party:\n CommonsIO.jar, csv.jar, JDom.jar\n Lizenzinfo: siehe Ordner '+libs'" );
+        Image icon = new Image("view/icon.png");
+        Stage stage = (Stage) alert.getDialogPane().getScene().getWindow();
+        stage.getIcons().add(icon);
+        alert.showAndWait();
+    }
+
+    @FXML
+    void mResetAlles(ActionEvent event) {
+        graph.initialisiereAlleKanten();
+        graph.initialisiereAlleKnoten();
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+    }
+
+    @FXML
+    void mResetBesucht(ActionEvent event) {
+        for(Knoten k : graph.getAlleKnoten()) {
+            k.setBesucht(false);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+    }
+
+    @FXML
+    void mResetFarbe(ActionEvent event) {
+        for(Knoten k : graph.getAlleKnoten()) {
+            k.setFarbeAutomatisch(true);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+    }
+
+    @FXML
+    void mResetGeloescht(ActionEvent event) {
+        for(Kante k : graph.getAlleKanten()) {
+            k.setGeloescht(false);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+
+    }
+
+    @FXML
+    void mResetKantenmarkierung(ActionEvent event) {
+        for(Kante k : graph.getAlleKanten()) {
+            k.setMarkiert(false);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+
+    }
+
+    @FXML
+    void mResetMarkierung(ActionEvent event) {
+        for(Knoten k : graph.getAlleKnoten()) {
+            k.setMarkiert(false);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+
+    }
+
+    @FXML
+    void mResetWert(ActionEvent event) {
+        for(Knoten k : graph.getAlleKnoten()) {
+            k.setWert(0.0);
+        }
+        TabMitController tc = (TabMitController) (tpRekursionen.getSelectionModel().getSelectedItem());
+        tc.update();
+
+    }
+
+}

Quellcodes/alg_ds_graphentester/control/EditTabMitController.java

@@ -0,0 +1,274 @@
+package control;
+
+import imp.*;
+import graph.*;
+
+import javafx.fxml.*;
+import javafx.scene.control.*;
+import javafx.event.*;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.Node;
+import javafx.scene.text.*;
+import javafx.geometry.Pos;
+import javafx.stage.*;          // Dateiöffnen / Speichern-Dialog
+import java.io.File;  
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+import java.util.List;
+import javafx.collections.ObservableList;
+import java.util.Optional;
+
+/**
+ * Die Klasse EditTabMitController stellt einen Tab inclusive ihres Controllers
+ * zur Editierung eines Graphs dar.
+ *
+ * @author Thomas Schaller
+ * @version 03.03.2023 (v7.1)
+ * v7.1: Aktualisierung der Anzeige bei Wechsel gewichtet/ungewichtet angepasst
+ * v6.9: Context-Menü schließt, wenn an andere Stelle geklickt wird
+ */
+
+public class EditTabMitController extends TabMitController {
+
+    public EditTabMitController(Graph graph, GraphOptions options) {
+        this.graph = graph;
+        this.options = options;
+
+    }
+
+    @FXML
+    private CheckBox cbGerichtet;
+
+    @FXML
+    private CheckBox cbGewichtet;
+
+    @FXML
+    private RadioButton rLeer;
+
+    @FXML
+    private ToggleGroup tgKnoten;
+
+    @FXML
+    private RadioButton rNummer;
+
+    @FXML
+    private RadioButton rWert;
+
+    @FXML
+    private CheckBox cbInfotext;
+
+    @FXML
+    private Label lBildname;
+
+    @FXML
+    private RadioButton rbMatrix;
+
+    @FXML
+    private ToggleGroup tgMatrixListe;
+
+    @FXML
+    private RadioButton rbListe;
+
+    @FXML
+    private Slider sGroesse;
+
+    private FileChooser dateidialog;
+
+    public void initialize() {
+
+        dateidialog = new FileChooser();
+        dateidialog.setInitialDirectory(new File("images"));
+
+        options.showEdgeWeights = graph.isGewichtet();
+        options.bildAnzeigen = true;
+        options.showVertexInfo = true;
+
+        viewer.setGraph(graph,options);
+        viewer.setEditable();
+
+        cbGerichtet.setSelected(graph.isGerichtet());
+        cbGewichtet.setSelected(graph.isGewichtet());
+        cbInfotext.setSelected(options.showVertexInfo);
+
+        tgKnoten.selectToggle(rLeer);
+        if(options.showVertexValue) { tgKnoten.selectToggle(rWert); }
+        if(options.showVertexText) { tgKnoten.selectToggle(rNummer); }
+
+        cbGerichtet.selectedProperty().addListener((cb, oldValue, newValue) -> setGerichtet(newValue));
+        cbGewichtet.selectedProperty().addListener((cb, oldValue, newValue) -> setGewichtet(newValue));
+        cbInfotext.selectedProperty().addListener((cb, oldValue, newValue) -> setInfotext(newValue));
+        tgKnoten.selectedToggleProperty().addListener((tg, oldValue, newValue) -> setKnotenTyp(newValue));
+        if(options.saveAsMatrix) 
+            tgMatrixListe.selectToggle(rbMatrix);
+        else
+            tgMatrixListe.selectToggle(rbListe);
+
+        tgMatrixListe.selectedToggleProperty().addListener((tg, oldValue, newValue) -> options.saveAsMatrix = (newValue == rbMatrix));
+        lBildname.setText(options.bildDatei);
+        super.initialize();
+
+        // this.setOnSelectionChanged(e -> {if(!this.isSelected()) this.getTabPane().getTabs().remove(this);});
+        sGroesse.valueProperty().addListener((s,oldValue,newValue) -> sGroesseAendern(newValue));    
+
+    }
+
+    void sGroesseAendern(Number size) {
+        options.vertexSize = size.intValue();
+        update();
+    }
+
+    void setGerichtet(boolean gerichtet) {
+        graph.setGerichtet(gerichtet);
+        update();
+    }
+
+    void setGewichtet(boolean gewichtet) {
+        graph.setGewichtet(gewichtet);
+        options.showEdgeWeights = gewichtet;
+        if(graph.isGewichtet()) {
+            options.kanteKurztext = new String[]{"Gewicht"};
+            options.kanteLangtext = new String[]{"Gewicht","Markiert","Gelöscht"};
+        } else {
+            options.kanteKurztext = new String[]{};
+            options.kanteLangtext = new String[]{"Markiert","Gelöscht"};
+        }
+        update();
+    }
+
+    void setInfotext(boolean anzeigen) {
+        options.showVertexInfo = anzeigen;
+        update();
+    }    
+
+    void setKnotenTyp(Toggle t) {
+        if(t == rWert) { options.showVertexValue = true; options.showVertexText = false;}
+        if(t == rNummer) { options.showVertexValue = false; options.showVertexText = true;}
+        if(t == rLeer) { options.showVertexValue = false; options.showVertexText = false;}
+
+        update();
+    }
+
+    @FXML
+    void bBildLaden(ActionEvent event) {
+        String workingDir = System.getProperty("user.dir");
+        File file = dateidialog.showOpenDialog(null);
+        if (file != null) {
+            try{
+                Files.copy( file.toPath(), (new File(workingDir+"\\images\\"+file.getName())).toPath(), StandardCopyOption.REPLACE_EXISTING);
+                options.bildDatei = file.getName();
+                lBildname.setText(options.bildDatei);
+                update();
+            } catch( Exception e) {
+                System.out.println("Fehler beim Kopieren des Bildes");
+            }
+        }
+    }
+
+    @FXML
+    void bBildLoeschen(ActionEvent event) {
+        options.bildDatei = "";
+        lBildname.setText(options.bildDatei);
+        update();
+    }
+
+    @FXML
+    void bDistanzenBestimmen(ActionEvent event) {
+        for(Kante k: graph.getAlleKanten()) {
+            Knoten s = k.getStart();
+            Knoten z = k.getZiel();
+            k.setGewicht(Math.round(Math.sqrt((s.getX()-z.getX())*(s.getX()-z.getX())+
+                        (s.getY()-z.getY())*(s.getY()-z.getY()))));
+        }
+        update();
+    }
+
+    @FXML
+    void graphClicked(MouseEvent event) { // MousePressed-Event
+        viewer.mouseClicked(event);
+        viewer.mouseDown(event);
+        if((viewer.getSelectedKnoten() != null || viewer.getSelectedKante() != null) && event.isSecondaryButtonDown()) { // Contextmenu
+            ContextMenu contextMenu = new ContextMenu();
+            MenuItem item1 = new MenuItem("Löschen");
+            item1.setOnAction(e -> this.mLoesche());
+            MenuItem item2 = new MenuItem("Gewicht ändern...");
+            item2.setOnAction(e -> this.mWertAendern());
+            MenuItem item3 = new MenuItem("Infotext ändern...");
+            item3.setOnAction(e -> this.mInfotextAendern());
+
+            // Add MenuItem to ContextMenu
+            contextMenu.getItems().clear();
+            contextMenu.getItems().add(item1);
+
+            if(viewer.getSelectedKante()!=null && graph.isGewichtet())
+                contextMenu.getItems().add(item2);
+            if (viewer.getSelectedKnoten() != null)    
+                contextMenu.getItems().add( item3 );
+
+            getViewer().setContextMenu(contextMenu);
+            //contextMenu.show(viewer, event.getScreenX(), event.getScreenY());
+        }
+    }
+
+    public void mLoesche() {
+        viewer.setContextMenu(null);
+        if(viewer.getSelectedKnoten() != null) {
+            graph.entferneKnoten(viewer.getSelectedKnoten());
+            update();
+        }
+        if(viewer.getSelectedKante() != null) {
+            graph.entferneKante(viewer.getSelectedKante());
+            update();
+        }
+    }
+
+    public void mWertAendern() {
+        viewer.setContextMenu(null);
+
+        Knoten k = viewer.getSelectedKnoten();
+        Kante ka = viewer.getSelectedKante();
+        if(k != null || ka !=null) {
+            double v;
+            if(k != null) v = k.getDoubleWert(); 
+            else v = ka.getGewicht();
+            TextInputDialog dialog = new TextInputDialog(""+v);
+            dialog.setHeaderText(null);
+            dialog.setTitle("Wert ändern");
+            dialog.setContentText("Bitte geben Sie den neuen Wert ein:");
+
+            Optional<String> result = dialog.showAndWait();
+            if (result.isPresent()){
+                try{
+                    v = Double.parseDouble(result.get());
+                    if(k != null) k.setWert(v);          
+                    else ka.setGewicht(v);
+                    update();
+                } catch (Exception e) {
+                    System.out.println("Keine Zahl eingegeben");
+                }
+            }
+        }
+    }
+
+    public void mInfotextAendern() {
+        viewer.setContextMenu(null);
+
+        Knoten k = viewer.getSelectedKnoten();
+        if(k != null ) {
+            TextInputDialog dialog = new TextInputDialog(k.getInfotext());
+            dialog.setHeaderText(null);
+            dialog.setTitle("Infotext ändern");
+            dialog.setContentText("Bitte geben Sie den Infotext ein:");
+
+            Optional<String> result = dialog.showAndWait();
+            if (result.isPresent()){
+                String t = result.get();
+                t.replaceAll(",","");
+                k.setInfotext(t);          
+                update();
+            }
+        }
+    }
+
+}

Quellcodes/alg_ds_graphentester/control/HauptTabMitController.java

@@ -0,0 +1,56 @@
+package control;
+
+import imp.*;
+import graph.*;
+import algorithmen.*;
+
+import javafx.fxml.*;
+import javafx.scene.control.*;
+import javafx.event.*;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.text.*;
+import javafx.geometry.Pos;
+import javafx.scene.image.Image;
+import javafx.stage.*;          // Dateiöffnen / Speichern-Dialog
+import java.io.File;  
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+import javafx.collections.ObservableList;
+
+/**
+ * Die Klasse HauptTabMitController stellt einen Tab inclusive ihres Controllers
+ * für das Hauptfenster des Graphentesters dar. Einzelne Knoten oder Kanten können 
+ * selektiert werden.
+ *
+ * @author Thomas Schaller
+ * @version v6.7 (9.12.2020)
+ */
+
+public class HauptTabMitController extends TabMitController {
+
+ 
+
+    public HauptTabMitController(Graph graph, GraphOptions options) {
+        this.graph = graph;
+        this.options = options;
+        setClosable(false);
+    }
+
+    public void initialize() {
+  
+        super.initialize();
+
+        
+    }
+
+
+
+
+
+ 
+}

Quellcodes/alg_ds_graphentester/control/Hilfefenster.java

@@ -0,0 +1,176 @@
+package control;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.TextArea;
+import javafx.scene.control.TreeView;
+import javafx.scene.control.TreeItem;
+import javafx.scene.input.MouseEvent;
+import javafx.event.ActionEvent;
+import javafx.scene.input.Clipboard;
+import javafx.scene.input.ClipboardContent;
+import java.util.List;
+import java.util.ArrayList;
+import javafx.stage.*;  
+import java.util.ConcurrentModificationException;
+import javafx.application.Platform;
+
+import graph.*;
+
+/**
+ * Die Klasse Hilfefenster stellt ein Hilfefenster für die Simulation eines
+ * Algorithmus bereit.
+ *
+ * @author Thomas Schaller
+ * @version v6.7 (9.12.2020)
+ */
+
+public class Hilfefenster extends Stage implements Hilfe{
+
+    @FXML
+    private TreeView<String> tvAblauf;
+
+    private List<TreeItem<String>> stufen;
+    private List<List<String>> zustaende;
+    private TreeItem<String> last;
+    private GraphPlotter gp;
+    private List<String> aktuell;
+    private boolean reviewAllowed;
+
+    public void initialize() {
+        loescheAlles();
+        zustaende = new ArrayList<List<String>>();
+        aktuell = null;
+        reviewAllowed = false;
+        tvAblauf.getSelectionModel().selectedIndexProperty().addListener((obs,oldValue, newValue)->showState());
+    }
+
+    public void setGraphPlotter(GraphPlotter gp) {
+        this.gp = gp;
+    }
+
+    public void loescheAlles() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    stufen = new ArrayList<TreeItem<String>>();
+                    zustaende = new ArrayList<List<String>>();
+                    TreeItem<String> root =  new TreeItem<String>("Algorithmus");
+                    root.setExpanded(true);
+                    last = root;
+                    tvAblauf.setRoot(root);
+                    tvAblauf.setShowRoot(false);
+                    stufen.add(root);                    
+                }
+            });
+
+    }
+
+    public void append(String text) {
+        List<String> status = gp.getGraph().getStatus();
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    last = new TreeItem<String>(text);
+                    stufen.get(stufen.size()-1).getChildren().add(last);
+                    zustaende.add(status);
+                }
+            });
+
+    }
+
+    public void indentMore() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(stufen.size() == 1) { // Hauptknoten
+                        TreeItem parent = stufen.get(0);
+                        List<TreeItem> children = parent.getChildren();
+                        for(int i=children.size()-1; i >= 0; i--) {
+                            TreeItem t = children.get(i);
+                            if(t.isExpanded()) {
+                                t.setExpanded(false);
+                                break;
+                            }
+                        }
+                    }
+                    stufen.add(last);
+                    last.setExpanded(true);
+                    last.expandedProperty().addListener((b, o, n) -> showState());
+                }
+            });
+
+    }
+
+    public void indentLess() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(stufen.size() > 1) stufen.remove(stufen.size()-1);
+                }
+            });
+    }
+
+    public void setReviewAllowed(boolean a) {
+        this.reviewAllowed = a;
+        if(!reviewAllowed) tvAblauf.getSelectionModel().clearSelection();
+    }
+
+    public void showState() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(reviewAllowed && tvAblauf.getSelectionModel().getSelectedIndex()>=0) {
+                        TreeItem s = tvAblauf.getSelectionModel().getSelectedItem();
+                        if(!s.isExpanded()) { // suche das letzte Kind
+                            while(s.getChildren().size()>0){
+                                List<TreeItem> c = s.getChildren();
+                                s = c.get(c.size()-1);
+                            }
+                        }
+                        gp.getGraph().setStatus(zustaende.get(calculateIndex(tvAblauf.getRoot(), s ,0)-1));
+                        gp.updateImage();
+                    }
+                }
+            });
+
+    }
+
+    private int calculateIndex(TreeItem t, TreeItem search, int nr) {
+        if(t == search) return nr;
+        nr++;
+        List<TreeItem> children = t.getChildren();  
+        for(TreeItem c : children) {
+            int i = calculateIndex(c, search, nr);
+            if(i>0) return i;
+            nr = -i;
+        }
+        return -nr;
+    }
+
+    @FXML
+    void bCopyClicked(ActionEvent event) {
+        final Clipboard clipboard = Clipboard.getSystemClipboard();
+        final ClipboardContent content = new ClipboardContent();
+        String s = "";
+        for(Object c : tvAblauf.getRoot().getChildren()) {
+            if(c instanceof TreeItem) {
+                s += generateClipboardContent((TreeItem) c, "");
+            }
+        }
+
+        content.putString(s);
+
+        clipboard.setContent(content);
+    }
+
+    private String generateClipboardContent(TreeItem t, String tab) {
+        String s = tab+t.getValue();
+        for(Object c : t.getChildren()) {
+            if(c instanceof TreeItem) {
+                s += generateClipboardContent((TreeItem) c, tab+"  ");
+            }
+        }
+        return s;
+    }
+
+}

Quellcodes/alg_ds_graphentester/control/MyClassLoader.java

@@ -0,0 +1,53 @@
+package control;
+
+import java.io.*;
+import java.net.*;
+import java.util.regex.Pattern;
+
+/**
+ * Hilfsklasse, um Algorithmen-Classen dynamisch nachladen zu können und 
+ * aktualisierte Class-Dateien während der Laufzeit erneut laden zu können.
+ * 
+ * @author Schaller (nach http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html)
+ * @version 16.02.2021
+ */
+public class MyClassLoader extends ClassLoader{
+
+    public MyClassLoader(ClassLoader parent) {
+        super(parent);
+    }
+
+    public Class loadClass(String name) throws ClassNotFoundException {
+        if(!name.contains("GraphAlgo_"))
+                return super.loadClass(name);
+
+        try {
+      
+                
+            URL myUrl = new URL("file:"+name.split(Pattern.quote("."))[0]+"/"+name.split(Pattern.quote("."))[1]+".class");
+            URLConnection connection = myUrl.openConnection();
+            InputStream input = connection.getInputStream();
+            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+            int data = input.read();
+
+            while(data != -1){
+                buffer.write(data);
+                data = input.read();
+            }
+
+            input.close();
+
+            byte[] classData = buffer.toByteArray();
+
+            return defineClass(name, classData, 0, classData.length);
+
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+}

Quellcodes/alg_ds_graphentester/control/SimulationTabMitController.java

@@ -0,0 +1,434 @@
+package control;
+
+import imp.*;
+import graph.*;
+import algorithmen.*;
+
+import javafx.fxml.*;
+import javafx.scene.control.*;
+import javafx.event.*;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.text.*;
+import javafx.geometry.Pos;
+import javafx.scene.image.Image;
+import javafx.stage.*;          // Dateiöffnen / Speichern-Dialog
+import javafx.application.Platform;
+import javafx.scene.input.Clipboard;
+import javafx.scene.input.ClipboardContent;
+import java.io.File;  
+import java.net.URI;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.nio.file.*;
+import java.util.Collections;
+import java.util.stream.Stream;
+import java.util.Iterator;
+import java.util.List;
+
+import java.util.ArrayList;
+import java.util.regex.Pattern;
+import java.lang.reflect.InvocationTargetException;
+
+import javafx.collections.ObservableList;
+
+/**
+ * Die Klasse SimulationTabMitController stellt einen Tab inclusive ihres Controllers
+ * zur Simulation eines Algorithmus dar. Der Algorithmus kann ausgewählt und schrittweise 
+ * durchgeführt werden.
+ *
+ * @author Thomas Schaller
+ * @version 03.03.2023 (v7.0)
+ * v7.1: Fehler bei Aktualisierung des Hilfefensters behoben, Splitpane statt HBox
+ * v7.0: Mechanismus geändert, so dass die init-Methode des Algorithmus beim Wechesel eines Algorithmus 
+ *       aufgerufen wird, um die für diesen Algorithmus passenden Anzeigeeinstellungen zu setzen.
+ * v6.9: Hilfefenster ist in Simulationsfenster integriert
+ */
+public class SimulationTabMitController extends TabMitController implements Hilfe {
+
+    @FXML
+    private ComboBox<String> cbAlgorithmen;
+
+    @FXML
+    private Slider sSpeed;
+
+    @FXML
+    private Button bStep;
+
+    @FXML
+    private Button bStart;
+
+    @FXML
+    private Button bBreak;
+
+    @FXML
+    private Button bReset;
+
+    private GraphAlgo aktAlgo = null;
+    private ArrayList<String> algoNamen;
+    private Hilfe hilfe;
+
+    public SimulationTabMitController(Graph graph, GraphOptions options) {
+        this.graph = graph;
+        this.options = options;
+
+    }
+
+    public void initialize() {
+        this.algoNamen = new ArrayList<String>();
+
+        File verzeichnis = new File("algorithmen");
+        if(verzeichnis != null && verzeichnis.isDirectory()) {
+            String[] entries = verzeichnis.list();
+            for (String name : entries) {
+                if (name.startsWith("GraphAlgo_") && name.endsWith(".class")){
+                    try{
+                        Class c = Class.forName("algorithmen."+name.split(Pattern.quote("."))[0]);
+                        GraphAlgo a = ((GraphAlgo)(c).getDeclaredConstructor().newInstance());       
+                        int i = 0;
+                        while(i < cbAlgorithmen.getItems().size() && cbAlgorithmen.getItems().get(i).compareTo(a.getBezeichnung())<0)
+                            i++;
+                        //System.out.println("Algorithmus: "+a.getBezeichnung()+" geladen.");     
+                        cbAlgorithmen.getItems().add(i, a.getBezeichnung());
+
+                        algoNamen.add(i, "algorithmen."+name.split(Pattern.quote("."))[0]);
+                    }
+                    catch(ExceptionInInitializerError  e)  {}
+                    catch(LinkageError e){}   
+                    catch(ClassNotFoundException e) {}
+                    catch(NoSuchMethodException e)   {}
+                    catch(InstantiationException e)   {}
+                    catch(IllegalAccessException e)   {}
+                    catch(InvocationTargetException e)   {}
+
+                }
+            } // end of for
+        }
+        verzeichnis = new File( "eigeneAlgorithmen" );
+        if(verzeichnis != null  && verzeichnis.isDirectory()) {
+            String[] entries = verzeichnis.list();
+            for (String name : entries) {
+                if (name.startsWith("GraphAlgo_") && name.endsWith(".class")){
+                    try{
+                        Class c = Class.forName("eigeneAlgorithmen."+name.split(Pattern.quote("."))[0]);
+                        GraphAlgo a = ((GraphAlgo)(c).getDeclaredConstructor().newInstance());       
+                        int i = 0;
+                        while(i < cbAlgorithmen.getItems().size() && cbAlgorithmen.getItems().get(i).compareTo(a.getBezeichnung())<0)
+                            i++;
+                        //System.out.println("Algorithmus: "+a.getBezeichnung()+" geladen.");     
+                        cbAlgorithmen.getItems().add(i, a.getBezeichnung());
+
+                        algoNamen.add(i, "eigeneAlgorithmen."+name.split(Pattern.quote("."))[0]);
+                    }
+                    catch(ExceptionInInitializerError  e)  {}
+                    catch(LinkageError e){}   
+                    catch(ClassNotFoundException e) {}
+                    catch(NoSuchMethodException e)   {}
+                    catch(InstantiationException e)   {}
+                    catch(IllegalAccessException e)   {}
+                    catch(InvocationTargetException e)   {}
+
+                }
+            } // end of for
+        }
+
+        cbAlgorithmen.getSelectionModel().selectedItemProperty().addListener((options, oldValue, newValue) -> {
+                changeAlgorithm();
+            }); 
+
+        viewer.setGraph(graph,options);
+        this.hilfe = null;
+        this.aktAlgo = null;
+        super.initialize();
+
+        sSpeed.valueProperty().addListener(e -> { if (aktAlgo != null) aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));});
+        bStart.managedProperty().bind(bStart.visibleProperty());
+        bBreak.managedProperty().bind(bBreak.visibleProperty());
+        bBreak.setVisible(false);
+
+        //------------- Hilfefunktion
+        loescheAlles();
+        zustaende = new ArrayList<List<String>>();
+        aktuell = null;
+        reviewAllowed = false;
+        tvAblauf.getSelectionModel().selectedIndexProperty().addListener((obs,oldValue, newValue)->showState());
+
+    }
+
+    public void showHilfe(boolean b) {
+        if(b) {
+            lAblauf.setVisible(true);
+            tvAblauf.setVisible(true);
+            bClipboard.setVisible(true);
+
+            hilfe = this;
+            if(aktAlgo != null ) {
+                aktAlgo.setGUIElemente(viewer,hilfe); 
+                if(aktAlgo.isAlive())
+                    hilfe.append("Unvollständiger Ablauf");
+            }
+        }
+        else {
+            lAblauf.setVisible(false);
+            tvAblauf.setVisible(false);
+            bClipboard.setVisible(false);
+            if(aktAlgo != null && aktAlgo.isAlive()) aktAlgo.setGUIElemente(viewer, null);
+            hilfe = null;
+            loescheAlles();
+            zustaende = new ArrayList<List<String>>();
+            aktuell = null;
+            reviewAllowed = false;          
+        }
+    }
+
+    public void setGraph(Graph graph, GraphOptions options) {
+        super.setGraph(graph,options);
+        mReset(null);
+    }
+
+    public void changeAlgorithm() {
+        if(aktAlgo != null && aktAlgo.isAlive()) aktAlgo.stop();  
+        graph.initialisiereAlleKnoten();
+        graph.initialisiereAlleKanten();
+
+        bStep.setDisable(false);
+        bStart.setDisable(false);
+        bStart.setVisible(true);
+        bBreak.setVisible(false);
+        if (hilfe != null) hilfe.loescheAlles();
+        this.aktAlgo = null;
+
+        if(cbAlgorithmen.getSelectionModel().getSelectedIndex() >= 0) {
+
+            try{
+                ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
+                MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
+                Class c = classLoader.loadClass(algoNamen.get(cbAlgorithmen.getSelectionModel().getSelectedIndex()));
+
+                aktAlgo = ((GraphAlgo)(c).getDeclaredConstructor().newInstance()); 
+                aktAlgo.setStartKnoten(viewer.getSelectedKnoten());
+                aktAlgo.setGUIElemente(viewer, hilfe);
+                aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
+                aktAlgo.init();
+            } catch( Exception e) {
+                System.out.println(e);
+            }
+        }
+
+        update();
+
+    }
+
+    @FXML
+    void mReset(ActionEvent event) {
+
+        changeAlgorithm();
+    }
+
+    @FXML 
+    void mStep(ActionEvent event) {
+        if (aktAlgo == null) return;
+        if (aktAlgo.getState() == Thread.State.NEW ) {
+            aktAlgo.setStartKnoten(viewer.getSelectedKnoten());
+            aktAlgo.start();
+        } else {
+            if(aktAlgo.isAlive()) {
+                aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
+                aktAlgo.setWaitforclick(false);
+            } else {
+                bStep.setDisable(true);
+                bStart.setDisable(true);
+                bBreak.setDisable(true);
+            } // end of if-else
+        } // end of if-else
+        try{
+            Thread.sleep(100);
+        } catch(Exception e) {}
+
+        if (!aktAlgo.isAlive()) {
+            bStep.setDisable(true);
+            bStart.setDisable(true);
+            bBreak.setDisable(true);
+        }
+    }
+
+    @FXML
+    void mStart(ActionEvent event) {
+        if (aktAlgo == null) return;
+        if (aktAlgo.getState() == Thread.State.NEW ) {
+            aktAlgo.setStartKnoten(viewer.getSelectedKnoten());
+            aktAlgo.setStepping(false);
+            aktAlgo.start();
+        } else {
+            if(aktAlgo.isAlive()) {
+                aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
+                aktAlgo.setStepping(false);
+                aktAlgo.setWaitforclick(false);
+            } 
+        } // end of if-else
+
+        bStep.setDisable(true);
+        bStart.setVisible(false);
+        bBreak.setVisible(true);
+        bBreak.setDisable(false);
+
+    }
+
+    public void mBreak(ActionEvent event) {
+        if(aktAlgo != null && aktAlgo.isAlive()) {
+            aktAlgo.setStepping(true);
+            bStart.setVisible(true);
+            bBreak.setVisible(false);
+            bStep.setDisable(false);
+        }
+    }
+
+    // --------- Hilfefenster --------------------------------------------
+    @FXML
+    private TreeView<String> tvAblauf;
+
+    @FXML
+    private Label lAblauf;
+
+    @FXML
+    private Button bClipboard;
+
+    private List<TreeItem<String>> stufen;
+    private List<List<String>> zustaende;
+    private TreeItem<String> last;
+    private GraphPlotter gp;
+    private List<String> aktuell;
+    private boolean reviewAllowed;
+
+    public void setGraphPlotter(GraphPlotter gp) {
+        this.gp = gp;
+    }
+
+    public void loescheAlles() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    stufen = new ArrayList<TreeItem<String>>();
+                    zustaende = new ArrayList<List<String>>();
+                    TreeItem<String> root =  new TreeItem<String>("Algorithmus");
+                    root.setExpanded(true);
+                    last = root;
+                    tvAblauf.setRoot(root);
+                    tvAblauf.setShowRoot(false);
+                    stufen.add(root);                    
+                }
+            });
+
+    }
+
+    public void append(String text) {
+        List<String> status = gp.getGraph().getStatus();
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    last = new TreeItem<String>(text);
+                    stufen.get(stufen.size()-1).getChildren().add(last);
+                    zustaende.add(status);
+                }
+            });
+
+    }
+
+    public void indentMore() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(stufen.size() == 1) { // Hauptknoten
+                        TreeItem parent = stufen.get(0);
+                        List<TreeItem> children = parent.getChildren();
+                        for(int i=children.size()-1; i >= 0; i--) {
+                            TreeItem t = children.get(i);
+                            if(t.isExpanded()) {
+                                t.setExpanded(false);
+                                break;
+                            }
+                        }
+                    }
+                    stufen.add(last);
+                    last.setExpanded(true);
+                    last.expandedProperty().addListener((b, o, n) -> showState());
+                }
+            });
+
+    }
+
+    public void indentLess() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(stufen.size() > 1) stufen.remove(stufen.size()-1);
+                }
+            });
+    }
+
+    public void setReviewAllowed(boolean a) {
+        this.reviewAllowed = a;
+        if(!reviewAllowed) tvAblauf.getSelectionModel().clearSelection();
+    }
+
+    public void showState() {
+        Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if(reviewAllowed && tvAblauf.getSelectionModel().getSelectedIndex()>=0) {
+                        TreeItem s = tvAblauf.getSelectionModel().getSelectedItem();
+                        if(!s.isExpanded()) { // suche das letzte Kind
+                            while(s.getChildren().size()>0){
+                                List<TreeItem> c = s.getChildren();
+                                s = c.get(c.size()-1);
+                            }
+                        }
+                        gp.getGraph().setStatus(zustaende.get(calculateIndex(tvAblauf.getRoot(), s ,0)-1));
+                        gp.updateImage();
+                    }
+                }
+            });
+
+    }
+
+    private int calculateIndex(TreeItem t, TreeItem search, int nr) {
+        if(t == search) return nr;
+        nr++;
+        List<TreeItem> children = t.getChildren();  
+        for(TreeItem c : children) {
+            int i = calculateIndex(c, search, nr);
+            if(i>0) return i;
+            nr = -i;
+        }
+        return -nr;
+    }
+
+    @FXML
+    void bCopyClicked(ActionEvent event) {
+        final Clipboard clipboard = Clipboard.getSystemClipboard();
+        final ClipboardContent content = new ClipboardContent();
+        String s = "";
+        for(Object c : tvAblauf.getRoot().getChildren()) {
+            if(c instanceof TreeItem) {
+                s += generateClipboardContent((TreeItem) c, "");
+            }
+        }
+
+        content.putString(s);
+
+        clipboard.setContent(content);
+    }
+
+    private String generateClipboardContent(TreeItem t, String tab) {
+        String s = tab+t.getValue();
+        for(Object c : t.getChildren()) {
+            if(c instanceof TreeItem) {
+                s += generateClipboardContent((TreeItem) c, tab+"  ");
+            }
+        }
+        return s;
+    }
+
+}