First Commit (Fobi)

+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.
+

+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/>. 
+
+ */
+

.gitignore

@@ -0,0 +1 @@
+*.class

GraphenTester.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphenTester
+comment0.text=\n\ Dies\ ist\ die\ Startklasse\ f\u00FCr\ die\ GUI\ des\ Graphentesters\n\ In\ BlueJ\ gibt\ es\ teilweise\ Probleme,\ dass\ die\ Men\u00FCs\ bei\ Mausklick\ nicht\n\ offen\ bleiben.\ Dann\ bitte\ das\ Programm\ \u00FCber\ die\ Main-Funktion\ starten.\n\ \n\ @author\ Dirk\ Zechnall,\ Thomas\ Schaller\n\ @version\ 12.02.2021\ (v6.6)\n
+comment1.params=primaryStage
+comment1.target=void\ start(javafx.stage.Stage)
+comment2.params=args
+comment2.target=void\ main(java.lang.String[])
+numComments=3

GraphenTester.java

@@ -0,0 +1,45 @@
+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 12.02.2021 (v6.6)
+ */
+
+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();
+        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.mBeenden(null));
+        
+    
+    } 
+       catch(Exception e)    {
+        System.out.println(e);
+        e.printStackTrace();
+    }
+    }
+    public static void main(String[] args) {
+      new Thread(() -> Application.launch(GraphenTester.class)).start();
+    }
+}

README.TXT

@@ -0,0 +1,15 @@
+PROJEKTBEZEICHNUNG: GraphenTester
+PROJEKTZWECK: Didaktisches Werkzeug um Graphenrepräsentation und -algorithmen kennen zu lernen
+VERSION oder DATUM: 09.12.2020
+
+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
+**********************************************************************************************
+

algorithmen/GraphAlgo.ctxt

@@ -0,0 +1,44 @@
+#BlueJ class context
+comment0.target=GraphAlgo
+comment0.text=\r\n\r\n\ description\r\n\r\n\ @version\ 1.0\ from\ 26.04.2019\r\n\ @author\ \r\n
+comment1.params=
+comment1.target=GraphAlgo()
+comment10.params=delay
+comment10.target=void\ setSpeed(int)
+comment11.params=
+comment11.target=void\ run()
+comment12.params=k
+comment12.target=void\ setStartKnoten(graph.Knoten)
+comment13.params=
+comment13.target=graph.Knoten\ getStartKnoten()
+comment14.params=
+comment14.target=void\ fuehreAlgorithmusAus()
+comment15.params=
+comment15.target=java.lang.String\ getBezeichnung()
+comment16.params=s
+comment16.target=void\ melde(java.lang.String)
+comment17.params=s
+comment17.target=void\ info(java.lang.String)
+comment18.params=
+comment18.target=void\ resetInfo()
+comment19.params=
+comment19.target=void\ infoIndentMore()
+comment2.params=graphPlotter\ hilfe
+comment2.target=void\ setGUIElemente(graph.GraphPlotter,\ graph.Hilfe)
+comment20.params=
+comment20.target=void\ infoIndentLess()
+comment3.params=g
+comment3.target=void\ setGraph(graph.Graph)
+comment4.params=
+comment4.target=void\ step()
+comment5.params=
+comment5.target=boolean\ getWaitforrepaint()
+comment6.params=waitforrepaintNeu
+comment6.target=void\ setWaitforrepaint(boolean)
+comment7.params=
+comment7.target=boolean\ getWaitforclick()
+comment8.params=waitforclickNeu
+comment8.target=void\ setWaitforclick(boolean)
+comment9.params=stepping
+comment9.target=void\ setStepping(boolean)
+numComments=21

algorithmen/GraphAlgo.java

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

algorithmen/GraphAlgo_BellmanFord.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_BellmanFord
+comment0.text=\n\ Dieser\ Algorithmus\ findet\ die\ k\u00FCrzesten\ Pfade\ in\ einem\ gewichteten\ Graphen.\n\ Algorithmus\:\ Bellman-Ford\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=k
+comment2.target=java.lang.String\ knoteninfo(graph.Knoten)
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

algorithmen/GraphAlgo_BellmanFord.java

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

algorithmen/GraphAlgo_Breitensuche.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_Breitensuche
+comment0.text=\n\ Dieser\ Algorithmus\ nummeriert\ alle\ Knoten\ des\ Graphen.\n\ Algorithmus\:\ Breitensuche\ mit\ ToDo-Liste\ (Schlange)\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+
+}
+

algorithmen/GraphAlgo_ColoringBacktracking.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_ColoringBacktracking
+comment0.text=\n\ Dieser\ Algorithmus\ f\u00E4rbt\ einen\ Graphen,\ so\ dass\ keine\ benachbarten\ Knoten\n\ die\ gleiche\ Farbe\ haben\ und\ m\u00F6glichst\ wenige\ Farben\ benutzt\ werden.\n\ Algorithmus\:\ Backtracking\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=benutzteFarben
+comment3.target=void\ bestimmeColoring(int)
+numComments=4

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
+}

algorithmen/GraphAlgo_ColoringGreedy.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_ColoringGreedy
+comment0.text=\n\ Dieser\ Algorithmus\ f\u00E4rbt\ einen\ Graphen,\ so\ dass\ keine\ benachbarten\ Knoten\n\ die\ gleiche\ Farbe\ haben\ und\ m\u00F6glichst\ wenige\ Farben\ benutzt\ werden.\n\ Algorithmus\:\ N\u00E4herungsl\u00F6sung\ mit\ Greedy-Algorithmus\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+  
+}
+

algorithmen/GraphAlgo_ColoringGreedyRandom.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_ColoringGreedyRandom
+comment0.text=\n\ Dieser\ Algorithmus\ f\u00E4rbt\ einen\ Graphen,\ so\ dass\ keine\ benachbarten\ Knoten\n\ die\ gleiche\ Farbe\ haben\ und\ m\u00F6glichst\ wenige\ Farben\ benutzt\ werden.\n\ Algorithmus\:\ N\u00E4herungsl\u00F6sung\ mit\ Greedy-Algorithmus\ (Knotenreihenfolge\ zuf\u00E4llig)\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+  
+}
+

algorithmen/GraphAlgo_Dijkstra.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_Dijkstra
+comment0.text=\n\ Dieser\ Algorithmus\ findet\ die\ k\u00FCrzesten\ Pfade\ in\ einem\ gewichteten\ Graphen.\n\ Algorithmus\:\ Dijkstra\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

algorithmen/GraphAlgo_Dijkstra.java

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

algorithmen/GraphAlgo_DominatingSetBacktracking.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetBacktracking
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Backtracking\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=knoten
+comment3.target=void\ bestimmeDominierendeMenge(int)
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGenetisch.ctxt

@@ -0,0 +1,18 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGenetisch
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Genetischer\ Algorithmus\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=
+comment3.target=int[]\ erzeugeZufaelligeTeilmenge()
+comment4.params=tm1\ tm2
+comment4.target=int[]\ kreuze(int[],\ int[])
+comment5.params=tm
+comment5.target=int[]\ mutiere(int[])
+comment6.params=tm
+comment6.target=void\ showTeilmenge(int[])
+comment7.params=tm
+comment7.target=double\ getBewertung(int[])
+numComments=8

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyA.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyA
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyB.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyB
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ wenigsten\ Nachbarn\ \n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ wenigsten\ Nachbarn\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyC.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyC
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyD.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyD
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ Nimm\ den\ Knoten\ mit\ den\ meisten\ \ Nachbarn\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyE.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyE
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyF.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyF
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyG.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyG
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ einem\ beliebigen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyH.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyH
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ m\u00F6glichst\ vielen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ m\u00F6glichst\ vielen\ schon\ ausgew\u00E4hlten\ Knoten\ die\ Entfernung\ 3\ hat\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_DominatingSetGreedyI.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=GraphAlgo_DominatingSetGreedyI
+comment0.text=\n\ Dieser\ Algorithmus\ bestimmt\ die\ kleinste\ dominierende\ Menge\ in\ einem\ Graphen\n\ und\ bestimmt\ den\ Zeitbedarf.\n\ Algorithmus\:\ Greedy\ mit\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ den\ ausgew\u00E4hlten\ Knoten\ eine\ m\u00F6glichst\ gro\u00DFe\ Entfernung\ hat\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=graph.Knoten\ bestimmeBesten()
+comment2.text=\ Bestimmt\ besten\ Knoten\ nach\ Strategie\:\n\ \ ein\ nicht\ abgedeckten\ Knoten,\ der\ von\ den\ ausgew\u00E4hlten\ Knoten\ eine\ m\u00F6glichst\ gro\u00DFe\ Entfernung\ hat\n
+comment3.params=
+comment3.target=void\ fuehreAlgorithmusAus()
+numComments=4

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
+}

algorithmen/GraphAlgo_EulerkreisExistenz.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_EulerkreisExistenz
+comment0.text=\n\ Dieser\ Algorithmus\ testet,\ ob\ ein\ Eulerkreis\ existiert.\n\ Algorithmus\:\ Zun\u00E4chst\ wird\ auf\ geraden\ Grad\ der\ Knoten\ getestet,\ danach\ \n\ mit\ Tiefensuche\ der\ Zusammenhang\ des\ Graphen\ \u00FCberpr\u00FCft.\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+
+}
+

algorithmen/GraphAlgo_MST_Kruskal.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_MST_Kruskal
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ minimal\ Spanning\ Tree\n\ Algorithmus\:\ Kruskal\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+
+}
+

algorithmen/GraphAlgo_MST_Prim.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_MST_Prim
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ minimal\ Spanning\ Tree\n\ Algorithmus\:\ Prim\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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

algorithmen/GraphAlgo_Moore.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_Moore
+comment0.text=\n\ Dieser\ Algorithmus\ findet\ die\ k\u00FCrzesten\ Pfade\ in\ einem\ ungewichteten\ Graphen.\n\ Algorithmus\:\ Algorithmus\ A\ von\ Moore\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+
+}
+

algorithmen/GraphAlgo_TSPBacktracking.ctxt

@@ -0,0 +1,12 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TSPBacktracking
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ m\u00F6glichst\ kurzen\ Hamilton-Kreis\ (Traveling\n\ Salesman\ Problem).\n\ Algorithmus\:\ Backtracking\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=akt
+comment3.target=void\ probiere(graph.Knoten)
+comment4.params=
+comment4.target=java.lang.String\ getInfo()
+numComments=5

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
+  
+}
+

algorithmen/GraphAlgo_TSPGenetisch.ctxt

@@ -0,0 +1,22 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TSPGenetisch
+comment0.text=\n\n\ description\n\n\ @version\ 1.0\ from\ 26.04.2019\n\ @author\ \n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=
+comment3.target=int[]\ erzeugeZufaelligeRundreise()
+comment4.params=rr1\ rr2
+comment4.target=int[]\ kreuze(int[],\ int[])
+comment5.params=rr
+comment5.target=int[]\ mutiere(int[])
+comment6.params=rr
+comment6.target=int[]\ mutiere2(int[])
+comment7.params=rundreise
+comment7.target=void\ showRundreise(int[])
+comment8.params=rundreise
+comment8.target=double\ getLaenge(int[])
+comment9.params=
+comment9.target=java.lang.String\ getInfo()
+numComments=10

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
+}

algorithmen/GraphAlgo_TSPGreedy.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TSPGreedy
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ m\u00F6glichst\ kurzen\ Hamilton-Kreis\ (Traveling\n\ Salesman\ Problem).\n\ Algorithmus\:\ Greedy\n\ Strategie\:\ Verl\u00E4ngere\ den\ Weg\ immer\ mit\ der\ k\u00FCrzesten\ Kante,\ die\ vom\ aktuellen\ Ende\ der\ Route\ ausgeht.\n\ vlg.\ Minimal\ Spanning\ Tree\ (Prim)\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=
+comment3.target=java.lang.String\ getInfo()
+numComments=4

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
+
+}
+

algorithmen/GraphAlgo_TSPGreedy2.ctxt

@@ -0,0 +1,14 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TSPGreedy2
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ m\u00F6glichst\ kurzen\ Hamilton-Kreis\ (Traveling\n\ Salesman\ Problem).\n\ Algorithmus\:\ Greedy\n\ Strategie\:\ Sortiere\ Kanten\ der\ L\u00E4nge\ nach.\ F\u00FCge\ sie\ der\ Reihe\ nach\ der\ Route\ hinzu,\ wenn\ nicht\ schon\ ein\n\ Weg\ zwischen\ den\ beiden\ Knoten\ vorhanden\ ist\ und\ die\ Knoten\ nicht\ schon\ Grad\ zwei\ erreicht\ haben.\n\ vgl.\ Minimal\ Spanning\ Tree\ (Kruskal)\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=k
+comment3.target=boolean\ istRoutenende(graph.Knoten)
+comment4.params=k
+comment4.target=int\ bestimmeGrad(graph.Knoten)
+comment5.params=
+comment5.target=java.lang.String\ getInfo()
+numComments=6

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
+}

algorithmen/GraphAlgo_TSPGreedyOpt.ctxt

@@ -0,0 +1,12 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TSPGreedyOpt
+comment0.text=\n\n\ Dieser\ Algorithmus\ sucht\ einen\ m\u00F6glichst\ kurzen\ Hamilton-Kreis\ (Traveling\n\ Salesman\ Problem).\n\ Algorithmus\:\ Greedy\ mit\ anschlie\u00DFender\ Optimierung\:\ \n\ Jeder\ Knoten\ wird\ der\ Reihe\ nach\ aus\ der\ Rundreise\ entfernt\ und\ dort\ wieder\ eingef\u00FCgt,\ wo\ die\ Rundreise\n\ sich\ am\ wenigsten\ verl\u00E4ngert.\ Diese\ Optimierung\ wird\ 5x\ wiederholt.\n\n\ @version\ 1.0\ from\ 11.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=
+comment3.target=double\ getLaenge()
+comment4.params=
+comment4.target=java.lang.String\ getInfo()
+numComments=5

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
+
+}
+

algorithmen/GraphAlgo_Tiefensuche.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_Tiefensuche
+comment0.text=\n\ Dieser\ Algorithmus\ nummeriert\ alle\ Knoten\ des\ Graphen.\n\ Algorithmus\:\ Tiefensuche\ mit\ ToDo-Liste\ (Stapel)\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

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
+
+}
+

algorithmen/GraphAlgo_TiefensucheRek.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_TiefensucheRek
+comment0.text=\n\ Dieser\ Algorithmus\ nummeriert\ alle\ Knoten\ des\ Graphen.\n\ Algorithmus\:\ Tiefensuche\ rekursiv\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=k\ nr
+comment3.target=int\ nummeriere(graph.Knoten,\ int)
+numComments=4

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
+
+}
+

algorithmen/GraphAlgo_ZyklusBacktracking.ctxt

@@ -0,0 +1,10 @@
+#BlueJ class context
+comment0.target=GraphAlgo_ZyklusBacktracking
+comment0.text=\n\ Dieser\ Algorithmus\ ist\ ein\ Beispiel\ f\u00FCr\ einen\ Backtracking-Algorithmus.\n\ Er\ sucht\ einen\ Zyklus\ im\ Graphen.\n\ Algorithmus\:\ Backtracking\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+comment3.params=k
+comment3.target=java.util.List\ backtracking(graph.Knoten)
+numComments=4

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
+
+}
+

algorithmen/GraphAlgo_toplogischeSortierung.ctxt

@@ -0,0 +1,8 @@
+#BlueJ class context
+comment0.target=GraphAlgo_toplogischeSortierung
+comment0.text=\n\ Dieser\ Algorithmus\ findet\ eine\ topologische\ Sortierung\ des\ Graphen.\n\n\ @version\ 1.0\ from\ 10.12.2020\n\ @author\ Thomas\ Schaller\n
+comment1.params=
+comment1.target=java.lang.String\ getBezeichnung()
+comment2.params=
+comment2.target=void\ fuehreAlgorithmusAus()
+numComments=3

algorithmen/GraphAlgo_toplogischeSortierung.java

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

algorithmen/package.bluej

@@ -0,0 +1,261 @@
+#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=157
+objectbench.width=1892
+package.divider.horizontal=0.6003172085646312
+package.divider.vertical=0.8295218295218295
+package.editor.height=791
+package.editor.width=1765
+package.editor.x=0
+package.editor.y=0
+package.frame.height=1053
+package.frame.width=1920
+package.numDependencies=8
+package.numTargets=31
+package.showExtends=true
+package.showUses=true
+readme.height=60
+readme.name=@README
+readme.width=49
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=GraphAlgo_ColoringGreedyRandom
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=290
+target1.x=600
+target1.y=590
+target10.height=50
+target10.name=GraphAlgo_DominatingSetGreedyF
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=280
+target10.x=290
+target10.y=420
+target11.height=50
+target11.name=GraphAlgo_TSPGreedy
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=230
+target11.x=600
+target11.y=160
+target12.height=50
+target12.name=GraphAlgo_DominatingSetGreedyG
+target12.showInterface=false
+target12.type=ClassTarget
+target12.width=290
+target12.x=290
+target12.y=470
+target13.height=50
+target13.name=GraphAlgo_TSPGenetisch
+target13.showInterface=false
+target13.type=ClassTarget
+target13.width=230
+target13.x=600
+target13.y=340
+target14.height=50
+target14.name=GraphAlgo_DominatingSetGreedyD
+target14.showInterface=false
+target14.type=ClassTarget
+target14.width=290
+target14.x=290
+target14.y=320
+target15.height=50
+target15.name=GraphAlgo_DominatingSetGreedyE
+target15.showInterface=false
+target15.type=ClassTarget
+target15.width=280
+target15.x=290
+target15.y=370
+target16.height=50
+target16.name=GraphAlgo_DominatingSetGenetisch
+target16.showInterface=false
+target16.type=ClassTarget
+target16.width=300
+target16.x=290
+target16.y=640
+target17.height=50
+target17.name=GraphAlgo_ZyklusBacktracking
+target17.showInterface=false
+target17.type=ClassTarget
+target17.width=260
+target17.x=20
+target17.y=640
+target18.height=50
+target18.name=GraphAlgo_DominatingSetGreedyH
+target18.showInterface=false
+target18.type=ClassTarget
+target18.width=290
+target18.x=290
+target18.y=520
+target19.height=50
+target19.name=GraphAlgo_DominatingSetGreedyI
+target19.showInterface=false
+target19.type=ClassTarget
+target19.width=280
+target19.x=290
+target19.y=570
+target2.height=50
+target2.name=GraphAlgo_Tiefensuche
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=210
+target2.x=1230
+target2.y=150
+target20.height=50
+target20.name=GraphAlgo_Moore
+target20.showInterface=false
+target20.type=ClassTarget
+target20.width=210
+target20.x=20
+target20.y=440
+target21.height=50
+target21.name=GraphAlgo_BellmanFord
+target21.showInterface=false
+target21.type=ClassTarget
+target21.width=210
+target21.x=20
+target21.y=560
+target22.height=50
+target22.name=GraphAlgo_Breitensuche
+target22.showInterface=false
+target22.type=ClassTarget
+target22.width=210
+target22.x=1220
+target22.y=80
+target23.height=50
+target23.name=GraphAlgo_toplogischeSortierung
+target23.showInterface=false
+target23.type=ClassTarget
+target23.width=280
+target23.x=20
+target23.y=370
+target24.height=50
+target24.name=GraphAlgo_DominatingSetBacktracking
+target24.showInterface=false
+target24.type=ClassTarget
+target24.width=320
+target24.x=290
+target24.y=100
+target25.height=50
+target25.name=GraphAlgo_ColoringGreedy
+target25.showInterface=false
+target25.type=ClassTarget
+target25.width=240
+target25.x=600
+target25.y=530
+target26.height=50
+target26.name=GraphAlgo_EulerkreisExistenz
+target26.showInterface=false
+target26.type=ClassTarget
+target26.width=250
+target26.x=20
+target26.y=100
+target27.height=50
+target27.name=GraphAlgo_TiefensucheRek
+target27.showInterface=false
+target27.type=ClassTarget
+target27.width=230
+target27.x=750
+target27.y=20
+target28.height=50
+target28.name=GraphAlgo_TSPGreedy2
+target28.showInterface=false
+target28.type=ClassTarget
+target28.width=230
+target28.x=600
+target28.y=220
+target29.height=50
+target29.name=GraphAlgo_ColoringBacktracking
+target29.showInterface=false
+target29.type=ClassTarget
+target29.width=270
+target29.x=600
+target29.y=470
+target3.height=50
+target3.name=GraphAlgo_MST_Prim
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=230
+target3.x=890
+target3.y=100
+target30.height=50
+target30.name=GraphAlgo_Dijkstra
+target30.showInterface=false
+target30.type=ClassTarget
+target30.width=210
+target30.x=20
+target30.y=500
+target31.height=50
+target31.name=GraphAlgo_TSPGreedyOpt
+target31.showInterface=false
+target31.type=ClassTarget
+target31.width=230
+target31.x=600
+target31.y=280
+target4.height=50
+target4.name=GraphAlgo_TSPBacktracking
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=240
+target4.x=600
+target4.y=100
+target5.height=50
+target5.name=GraphAlgo_DominatingSetGreedyB
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=290
+target5.x=290
+target5.y=220
+target6.height=50
+target6.name=GraphAlgo_DominatingSetGreedyC
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=290
+target6.x=290
+target6.y=270
+target7.height=50
+target7.name=GraphAlgo
+target7.showInterface=false
+target7.type=AbstractTarget
+target7.width=100
+target7.x=310
+target7.y=10
+target8.height=50
+target8.name=GraphAlgo_MST_Kruskal
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=230
+target8.x=890
+target8.y=160
+target9.height=50
+target9.name=GraphAlgo_DominatingSetGreedyA
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=290
+target9.x=290
+target9.y=170

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

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

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

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

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

beispielgraphen/02_topologischesortierung/02_aufbausimulation2.csv

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

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

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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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,-

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,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-,-

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,-,-,-,-