infowiki/zpg-graphentester
1
0
Fork 0
mirror of https://codeberg.org/qg-info-unterricht/zpg-graphentester.git synced 2026-03-24 20:48:26 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

First Commit (Fobi)

Browse source
This commit is contained in:
Frank Schiebel 2021-07-12 14:04:20 +02:00
commit 2bff291a51
336 changed files with 88781 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

44
algorithmen/GraphAlgo.ctxt Normal file
View file

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

172
algorithmen/GraphAlgo.java Normal file
View file

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

10
algorithmen/GraphAlgo_BellmanFord.ctxt Normal file
View file

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

83
algorithmen/GraphAlgo_BellmanFord.java Normal file
View file

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

8
algorithmen/GraphAlgo_Breitensuche.ctxt Normal file
View file

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

72
algorithmen/GraphAlgo_Breitensuche.java Normal file
View file

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

10
algorithmen/GraphAlgo_ColoringBacktracking.ctxt Normal file
View file

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

93
algorithmen/GraphAlgo_ColoringBacktracking.java Normal file
View file

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

8
algorithmen/GraphAlgo_ColoringGreedy.ctxt Normal file
View file

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

71
algorithmen/GraphAlgo_ColoringGreedy.java Normal file
View file

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

8
algorithmen/GraphAlgo_ColoringGreedyRandom.ctxt Normal file
View file

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

74
algorithmen/GraphAlgo_ColoringGreedyRandom.java Normal file
View file

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

8
algorithmen/GraphAlgo_Dijkstra.ctxt Normal file
View file

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

87
algorithmen/GraphAlgo_Dijkstra.java Normal file
View file

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

10
algorithmen/GraphAlgo_DominatingSetBacktracking.ctxt Normal file
View file

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

78
algorithmen/GraphAlgo_DominatingSetBacktracking.java Normal file
View file

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

18
algorithmen/GraphAlgo_DominatingSetGenetisch.ctxt Normal file
View file

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

149
algorithmen/GraphAlgo_DominatingSetGenetisch.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyA.ctxt Normal file
View file

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

78
algorithmen/GraphAlgo_DominatingSetGreedyA.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyB.ctxt Normal file
View file

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

77
algorithmen/GraphAlgo_DominatingSetGreedyB.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyC.ctxt Normal file
View file

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

79
algorithmen/GraphAlgo_DominatingSetGreedyC.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyD.ctxt Normal file
View file

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

79
algorithmen/GraphAlgo_DominatingSetGreedyD.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyE.ctxt Normal file
View file

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

98
algorithmen/GraphAlgo_DominatingSetGreedyE.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyF.ctxt Normal file
View file

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

98
algorithmen/GraphAlgo_DominatingSetGreedyF.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyG.ctxt Normal file
View file

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

98
algorithmen/GraphAlgo_DominatingSetGreedyG.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyH.ctxt Normal file
View file

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

101
algorithmen/GraphAlgo_DominatingSetGreedyH.java Normal file
View file

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

11
algorithmen/GraphAlgo_DominatingSetGreedyI.ctxt Normal file
View file

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

114
algorithmen/GraphAlgo_DominatingSetGreedyI.java Normal file
View file

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

8
algorithmen/GraphAlgo_EulerkreisExistenz.ctxt Normal file
View file

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

84
algorithmen/GraphAlgo_EulerkreisExistenz.java Normal file
View file

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

8
algorithmen/GraphAlgo_MST_Kruskal.ctxt Normal file
View file

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

85
algorithmen/GraphAlgo_MST_Kruskal.java Normal file
View file

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

8
algorithmen/GraphAlgo_MST_Prim.ctxt Normal file
View file

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

85
algorithmen/GraphAlgo_MST_Prim.java Normal file
View file

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

8
algorithmen/GraphAlgo_Moore.ctxt Normal file
View file

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

69
algorithmen/GraphAlgo_Moore.java Normal file
View file

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

12
algorithmen/GraphAlgo_TSPBacktracking.ctxt Normal file
View file

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

112
algorithmen/GraphAlgo_TSPBacktracking.java Normal file
View file

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

22
algorithmen/GraphAlgo_TSPGenetisch.ctxt Normal file
View file

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

182
algorithmen/GraphAlgo_TSPGenetisch.java Normal file
View file

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

10
algorithmen/GraphAlgo_TSPGreedy.ctxt Normal file
View file

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

81
algorithmen/GraphAlgo_TSPGreedy.java Normal file
View file

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

14
algorithmen/GraphAlgo_TSPGreedy2.ctxt Normal file
View file

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

172
algorithmen/GraphAlgo_TSPGreedy2.java Normal file
View file

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

12
algorithmen/GraphAlgo_TSPGreedyOpt.ctxt Normal file
View file

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

112
algorithmen/GraphAlgo_TSPGreedyOpt.java Normal file
View file

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

8
algorithmen/GraphAlgo_Tiefensuche.ctxt Normal file
View file

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

73
algorithmen/GraphAlgo_Tiefensuche.java Normal file
View file

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

10
algorithmen/GraphAlgo_TiefensucheRek.ctxt Normal file
View file

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

60
algorithmen/GraphAlgo_TiefensucheRek.java Normal file
View file

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

10
algorithmen/GraphAlgo_ZyklusBacktracking.ctxt Normal file
View file

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

80
algorithmen/GraphAlgo_ZyklusBacktracking.java Normal file
View file

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

8
algorithmen/GraphAlgo_toplogischeSortierung.ctxt Normal file
View file

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

71
algorithmen/GraphAlgo_toplogischeSortierung.java Normal file
View file

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

261
algorithmen/package.bluej Normal file
View file

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