Graphenteorie vor dem Umbau

GraphenTeorie/Graph.java

@@ -1,6 +1,9 @@
 package GraphenTeorie;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
 
 public class Graph {
 
@@ -8,28 +11,35 @@ public class Graph {
     private ArrayList<Kante> kantenArrayList;
 
     ArrayList<ArrayList<Object>> adjazenzmatrix;
-    ArrayList<ArrayList<Object>> adjazenzliste;
+    ArrayList<ArrayList<Knoten>> adjazenzliste;
 
 
     public Graph () {
         this.knotenArrayList = new ArrayList<>();
         this.kantenArrayList = new ArrayList<>();
 
-        this.adjazenzmatrix = createAdjazenzmatrix();
+        this.adjazenzmatrix = this.createAdjazenzmatrix();
-        this.adjazenzliste = createAdjazenzliste();
+        this.adjazenzliste = this.createAdjazenzliste();
     }
 
 
     public static void main(String[] args) {
         Graph meinGraph = new Graph();
-        meinGraph.addKnoten();
+        Knoten k1 = meinGraph.addKnoten();
-        meinGraph.addKnoten();
+        Knoten k2 = meinGraph.addKnoten();
-        meinGraph.addKnoten();
+        Knoten k3 = meinGraph.addKnoten();
-//        meinGraph.addKnoten();
+        meinGraph.addKante(k1, k2);
-//        meinGraph.addKnoten();
+        //meinGraph.addKante(k2, k1);
-//        meinGraph.addKnoten();
+        //meinGraph.addKante(k2, k3);
+        meinGraph.addKante(k3, k1);
+        //meinGraph.addKante(k1, k3);
 
         System.out.println(meinGraph.createAdjazenzmatrix());
+        System.out.println(meinGraph.createAdjazenzliste());
+
+        System.out.println(meinGraph.isSchwachZusammenhaengend());
+        System.out.println(meinGraph.isVollstaendig());
+        System.out.println(meinGraph.isZyklus());
     }
 
 
@@ -85,36 +95,59 @@ public class Graph {
     }
 
 
+    public void entmarkiereAlle() {
+        for (Knoten i: this.knotenArrayList) {
+            i.setMarkierung(false);
+        }
+    }
+
+
     public ArrayList<ArrayList<Object>> createAdjazenzmatrix() {
         ArrayList<ArrayList<Object>> matrix = new ArrayList<>();
-        matrix.add(new ArrayList<Object>());
+        // Erstellt leere Matrix nur mit "Beschriftung"
+        matrix.add(new ArrayList<Object>());  // Erstellt oberste Zeile
         for (int i = 0; i < this.knotenArrayList.size(); i++) {
-            matrix.get(0).add(knotenArrayList.get(i));
+            matrix.getFirst().add(knotenArrayList.get(i));  // Füge Zeile Objekt hinzu
-            matrix.add(new ArrayList<Object>());
+            matrix.add(new ArrayList<Object>());  // Erstellt neue Spalte
-            matrix.get(i+1).add(knotenArrayList.get(i));
+            matrix.get(i+1).add(knotenArrayList.get(i));  // Füge Spalte Objekt hinzu
         }
 
+        // Füllt alles mit 0 auf.
         for (ArrayList<Object> i: matrix) {
-            for (int j = 0; j < matrix.getFirst().size(); j++) {
+            if (i.size() != matrix.getFirst().size()) {
-                i.add(0);
+                for (int j = 0; j < matrix.getFirst().size(); j++) {
+                    i.add(0);
+                }
             }
         }
 
+        // Setzt die Werte ein
         for (Kante i: kantenArrayList) {
             int von = matrix.getFirst().indexOf(i.getStartKnoten());
             int nach = matrix.getFirst().indexOf(i.getEndKnoten());
 
             ArrayList<Object> neu = matrix.get(von+1);
-            neu.set(nach, i.getGewichtung());
+            neu.set(nach+1, i.getGewichtung());
             matrix.set(von+1, neu);
         }
 
+        this.adjazenzmatrix = matrix;
         return matrix;
     }
 
 
-    public ArrayList<ArrayList<Object>> createAdjazenzliste() {
+    public ArrayList<ArrayList<Knoten>> createAdjazenzliste() {
-        return null;
+        ArrayList<ArrayList<Knoten>> liste = new ArrayList<>();
+        for (int i = 0; i < this.knotenArrayList.size(); i++) {
+            liste.add(new ArrayList<Knoten>());
+            liste.get(i).add(knotenArrayList.get(i));
+            for (Kante j: knotenArrayList.get(i).getAusgehendeKanten()) {
+                liste.get(i).add(j.getEndKnoten());
+            }
+        }
+
+        this.adjazenzliste = liste;
+        return liste;
     }
 
 
@@ -128,59 +161,155 @@ public class Graph {
     }
 
 
-    public boolean isZusammenhaengend() {
+    // Man könnte über ungerichtete Kanten von jedem Knoten zum jedem kommen.
+    // Realisiert mit Stack DFS
+    public boolean isSchwachZusammenhaengend() {
+        this.entmarkiereAlle();
+        Stack<Knoten> stack = new Stack<>();
+        this.knotenArrayList.getFirst().setMarkierung(true);
+        stack.add(this.knotenArrayList.getFirst());
+
+        while (!stack.empty()) {
+            for (Knoten i : stack.pop().getAllNachbarKnoten()) {
+                if (!i.getMarkierung()) {
+                    i.setMarkierung(true);
+                    stack.add(i);
+                }
+            }
+        }
+
+        for (Knoten i: this.knotenArrayList) {
+            if (!i.getMarkierung()) {
+                return false;
+            }
+        }
+
         return true;
     }
 
 
+    // Man kann über die Pfeile zu jedem Punkt kommen
+    public boolean isStarkZusammenhaengend() {
+        return true;
+    }
+
+
+    // Jeder Konten ist direkt mit jedem anderen verknüpft
     public boolean isVollstaendig() {
+        this.createAdjazenzliste();
+        for (ArrayList<Knoten> i : this.adjazenzliste) {
+            for (Knoten j : this.knotenArrayList) {
+                if (!i.contains(j)) {
+                    return false;
+                }
+            }
+        }
         return true;
     }
 
 
     // Graph is 2 colorble or no odd length cycles
+    // Der Graph lässt sich in 2 Mengen zerlegen die untereinander keine Verbindungen haben
     public boolean isBipartit() {
         return true;
     }
 
 
+    // Bipartit + jeder Knoten von M1 ist mit jedem aus M2 zusammen
     public boolean isVollstaendigBipartit() {
         return true;
     }
 
 
+    // Man kann im Graphen in die Runde laufen
+    // Realisiert mit BFS abgewandelt
     public boolean isZyklus() {
-        return true;
+        this.entmarkiereAlle();
+        Queue<Knoten> queue = new LinkedList<>();
+
+        Knoten neuerStartKonten = this.knotenArrayList.getFirst();
+
+        boolean notDone = true;
+        while (notDone) {
+
+            neuerStartKonten.setMarkierung(true);
+            queue.add(neuerStartKonten);
+
+            while (!queue.isEmpty()) {
+                for (Kante i : queue.remove().getAusgehendeKanten()) {
+                    if (!i.getEndKnoten().getMarkierung()) {
+                        queue.add(i.getEndKnoten());
+                        i.getEndKnoten().setMarkierung(true);
+                    } else {
+                        for (Kante j: i.getEndKnoten().getAusgehendeKanten()) {
+                            if (j.getEndKnoten().getMarkierung()) {  // FIXME Problem, wenn es aus der whileschleife ausbricht und sich einen neuen Konoten anschaut
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+
+            notDone = false;
+            for (Knoten i : knotenArrayList) {
+                if (!i.getMarkierung()) {
+                    notDone = true;
+                    neuerStartKonten = i;
+                    break;
+                }
+            }
+        }
+        return false;
     }
 
 
+    // Jeder Knoten hat den gleichen Grad
     public boolean isRegulaer() {
         return true;
     }
 
 
+    // Man kann den Graphen ohne Kreuzung mahlen
     public boolean isPlanar() {
         return true;
     }
 
 
+    // Maximum aller maximalen Distanzen zwischen Knoten
     public int durchmesser() {
         return 1;
     }
 
 
+    // Minimum aller maximalen Distanzen zwischen Knoten
     public int radius() {
         return 1;
     }
 
 
+    // Alle Knoten mit maximaler Exzentrizität
     public ArrayList<Knoten> rand() {
-        return null;
+        ArrayList<Knoten> liste = new ArrayList<>();
+        int d1 = this.durchmesser();
+        for (Knoten i: this.knotenArrayList) {
+            if (i.exzentrizitaet() == d1) {
+                liste.add(i);
+            }
+        }
+        return liste;
     }
 
 
+    // Alle Knoten mit minimaler Exzentrizität
     public ArrayList<Knoten> zentrum() {
-        return null;
+        ArrayList<Knoten> liste = new ArrayList<>();
+        int r1 = this.radius();
+        for (Knoten i: this.knotenArrayList) {
+            if (i.exzentrizitaet() == r1) {
+                liste.add(i);
+            }
+        }
+        return liste;
     }
 
 

GraphenTeorie/Kante.java

@@ -62,6 +62,7 @@ public class Kante {
     }
 
 
+    // Wenn man die Kante löscht, teilt sich der Graph
     public boolean isBruecke() {
         return true;
     }

GraphenTeorie/Knoten.java

@@ -6,6 +6,7 @@ import java.util.ArrayList;
 public class Knoten {
 
     private String beschriftung;
+    private boolean markiert;
 
     private ArrayList<Kante> eingehendeKanten;
     private ArrayList<Kante> ausgehendeKanten;
@@ -21,6 +22,7 @@ public class Knoten {
 
     public Knoten(String beschriftung) {
         this.beschriftung = beschriftung;
+        this.markiert = false;
 
         this.eingehendeKanten = new ArrayList<>();
         this.ausgehendeKanten = new ArrayList<>();
@@ -58,6 +60,16 @@ public class Knoten {
     }
 
 
+    public void setMarkierung(boolean markiert) {
+        this.markiert = markiert;
+    }
+
+
+    public boolean getMarkierung() {
+        return this.markiert;
+    }
+
+
     public ArrayList<Knoten> getAllNachbarKnoten() {
         ArrayList<Knoten> nachbarnListe = new ArrayList<>();
         for (Kante i: this.anliegendeKanten) {
@@ -72,17 +84,23 @@ public class Knoten {
     }
 
 
+    // Wenn man den Knoten löscht, teilt sich der Graph
     public boolean isArtikulation() {
         return true;
     }
 
 
+    // Implementierung mit Dijkstra
     public int distanzTo(Knoten k1) {
+        ArrayList<Knoten> baum = new ArrayList<>();
+        baum.add(this);
+
         return 1;
     }
 
 
-    public int extrenzitaet() {
+    // Maximaler Abstand zu irgendeinem Knoten
+    public int exzentrizitaet() {
         return 1;
     }
 }

GraphenTeorie/Website/index.html

@@ -1,14 +1,14 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang="de">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Graphenteorie</title>
+    <title>Graphentheorie</title>
     <link rel="stylesheet" href="index.css">
 </head>
 
 <body>
-    <h1>Graphenteorie Visualisierung</h1>
+    <h1>Graphentheorie Visualisierung</h1>
 
     <svg id="svgFeld">
         <rect width="100%" height="100%" fill="blue" />

Semester2/Vorlesung4.java

@@ -0,0 +1,292 @@
+package Semester2;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class Vorlesung4 extends JFrame {
+
+    public Vorlesung4(String title) {
+        super(title);
+    }
+
+    public static void main(String[] args) {
+
+        // Erstelle Fenster
+        JFrame window = new Vorlesung4("Demo");
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setVisible(true);
+        window.setSize(700, 500);
+        window.setLocationRelativeTo(null);
+
+        // Erstelle 2 Tabs
+        JTabbedPane tabs = new JTabbedPane();
+        window.add(tabs, BorderLayout.CENTER);
+        JPanel tab1 = new JPanel();
+        tabs.addTab("Verbindungssuche", tab1);
+        tab1.setLayout(new BoxLayout(tab1, BoxLayout.Y_AXIS));
+        JPanel tab2 = new JPanel();
+        tabs.addTab("Erweiterte Suche", tab2);
+
+        // Erstelle Sprachlinks
+        JPanel sprachPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+        JLabel deutschLink = new JLabel("deutsch");
+        JLabel englishLink = new JLabel("english");
+        JLabel francaisLink = new JLabel("francais");
+        JLabel italianoLink = new JLabel("italiano");
+
+        sprachPanel.add(deutschLink);
+        sprachPanel.add(new JLabel("|"));
+        sprachPanel.add(englishLink);
+        sprachPanel.add(new JLabel("|"));
+        sprachPanel.add(francaisLink);
+        sprachPanel.add(new JLabel("|"));
+        sprachPanel.add(italianoLink);
+
+        window.add(sprachPanel, BorderLayout.NORTH);
+
+        // Anpassung der Überschriften
+        Font headerFont = new Font("Arial", Font.BOLD, 14);
+        Dimension headerSize = new Dimension(700, 30);
+
+        // Erstelle erste Überschrift
+        JPanel zeilePanel1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+        zeilePanel1.setBackground(Color.BLUE);
+        zeilePanel1.setPreferredSize(headerSize);
+        JLabel ueberschrift1 = new JLabel("Start&Ziel");
+        ueberschrift1.setForeground(Color.WHITE);
+        ueberschrift1.setFont(headerFont);
+        zeilePanel1.add(ueberschrift1);
+        tab1.add(zeilePanel1);
+
+        // Erste Felder in Grid zum Auswählen der Bahnhöfe
+        JPanel tabellePanel1 = new JPanel(new GridLayout(2, 4, 10, 10));
+        tabellePanel1.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+        JLabel labelVon = new JLabel("Von: ");
+        tabellePanel1.add(labelVon);
+
+        JLabel labelBahnhof1 = new JLabel("Bahnhof/Haltestelle");
+        tabellePanel1.add(labelBahnhof1);
+
+        JTextField textField1 = new JTextField(10);
+        tabellePanel1.add(textField1);
+
+        JLabel labelInfo7 = new JLabel("Info");
+        tabellePanel1.add(labelInfo7);
+
+        JLabel labelNach = new JLabel("Nach: ");
+        tabellePanel1.add(labelNach);
+
+        JLabel labelBahnhof2 = new JLabel("Bahnhof/Haltestelle");
+        tabellePanel1.add(labelBahnhof2);
+
+        JTextField textField2 = new JTextField(10);
+        tabellePanel1.add(textField2);
+
+        JButton button = new JButton("Über");
+        tabellePanel1.add(button);
+
+        tab1.add(tabellePanel1);
+
+        // Erstelle 2. Überschrift
+        JPanel zeilePanel2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+        zeilePanel2.setBackground(Color.BLUE);
+        zeilePanel2.setPreferredSize(headerSize);
+        JLabel ueberschrift2 = new JLabel("Reisedatum & Zeit");
+        ueberschrift2.setForeground(Color.WHITE);
+        ueberschrift2.setFont(headerFont);
+        zeilePanel2.add(ueberschrift2);
+        tab1.add(zeilePanel2);
+
+        // Erstelle Übergrid um links/rechts zu teilen
+        JPanel tabellePanel2 = new JPanel(new GridLayout(1, 2, 10, 10));
+        tabellePanel2.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        // Linke Seite
+        JPanel tabellePanelLinks = new JPanel(new GridLayout(2, 3, 10, 10));
+        tabellePanel2.add(tabellePanelLinks);
+
+        JLabel labelHinfahrt = new JLabel("Hinfahrt: ");
+        tabellePanelLinks.add(labelHinfahrt);
+
+        JLabel labelDatum = new JLabel("Datum: ");
+        tabellePanelLinks.add(labelDatum);
+
+        // Beispiel für Datum Picker - Anpassung erforderlich
+        JTextField datePicker1 = new JTextField("Datum Picker hier");
+        tabellePanelLinks.add(datePicker1);
+
+        JLabel labelInfo2 = new JLabel("");  // Leeres Feld
+        tabellePanelLinks.add(labelInfo2);
+
+        JLabel labelUhrzeit = new JLabel("Uhrzeit: ");
+        tabellePanelLinks.add(labelUhrzeit);
+
+        // Beispiel für Uhrzeit Picker - Anpassung erforderlich
+        JTextField timePicker1 = new JTextField("Uhrzeit Picker hier");
+        tabellePanelLinks.add(timePicker1);
+
+        // Rechte Seite
+        JPanel tabellePanelRechts = new JPanel(new GridLayout(2, 3, 10, 10));
+        tabellePanel2.add(tabellePanelRechts);
+
+        JLabel labelRueckfahrt = new JLabel("Rückfahrt: ");
+        tabellePanelRechts.add(labelRueckfahrt);
+
+        JLabel labelDatum1 = new JLabel("Datum: ");
+        tabellePanelRechts.add(labelDatum1);
+
+        // Beispiel für Datum Picker - Anpassung erforderlich
+        JTextField datePicker2 = new JTextField("Datum Picker hier");
+        tabellePanelRechts.add(datePicker2);
+
+        JLabel labelInfo5 = new JLabel("");  // Leeres Feld
+        tabellePanelRechts.add(labelInfo5);
+
+        JLabel labelUhrzeit1 = new JLabel("Uhrzeit: ");
+        tabellePanelRechts.add(labelUhrzeit1);
+
+        // Beispiel für Uhrzeit Picker - Anpassung erforderlich
+        JTextField timePicker2 = new JTextField("Uhrzeit Picker hier");
+        tabellePanelRechts.add(timePicker2);
+
+        tab1.add(tabellePanel2);
+
+        // Erstelle 3. Überschrift
+        JPanel zeilePanel3 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+        zeilePanel3.setBackground(Color.BLUE);
+        zeilePanel3.setPreferredSize(headerSize);
+        JLabel ueberschrift3 = new JLabel("Angaben zur Preisberechnung");
+        ueberschrift3.setForeground(Color.WHITE);
+        ueberschrift3.setFont(headerFont);
+        zeilePanel3.add(ueberschrift3);
+        tab1.add(zeilePanel3);
+
+        // Beispiel für zusätzliche Komponenten zur Preisberechnung
+        JPanel tabellePanel3 = new JPanel(new GridLayout(2, 4, 10, 10));
+        tabellePanel3.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        // Erste Zeile
+        JLabel labelReisende = new JLabel("Reisende: ");
+        tabellePanel3.add(labelReisende);
+
+        JComboBox<String> pickerErwachsenKind = new JComboBox<>(new String[]{"Erwachsener", "Kind"});
+        tabellePanel3.add(pickerErwachsenKind);
+
+        JComboBox<String> pickerErmaessigung = new JComboBox<>(new String[]{"Keine", "BahnCard 25", "BahnCard 50"});
+        tabellePanel3.add(pickerErmaessigung);
+
+        JComboBox<String> pickerKlasse = new JComboBox<>(new String[]{"1. Klasse", "2. Klasse"});
+        tabellePanel3.add(pickerKlasse);
+
+        // Zweite Zeile
+        JButton buttonPersonHinzufuegen = new JButton("Person hinzufügen");
+        tabellePanel3.add(buttonPersonHinzufuegen);
+
+        JLabel labelInfo = new JLabel("Info");
+        tabellePanel3.add(labelInfo);
+
+        JButton buttonAuslandspreise = new JButton("Auslandspreise");
+        tabellePanel3.add(buttonAuslandspreise);
+
+        JLabel labelInfo3 = new JLabel("Info");
+        tabellePanel3.add(labelInfo3);
+
+        tab1.add(tabellePanel3);
+
+        // Erstelle 4. Überschrift
+        JPanel zeilePanel4 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+        zeilePanel4.setBackground(Color.BLUE);
+        zeilePanel4.setPreferredSize(headerSize);
+        JLabel ueberschrift4 = new JLabel("Angaben zur Verbindung");
+        ueberschrift4.setForeground(Color.WHITE);
+        ueberschrift4.setFont(headerFont);
+        zeilePanel4.add(ueberschrift4);
+        tab1.add(zeilePanel4);
+
+        // 2x4 Grid für Angaben zur Verbindung
+        JPanel tabellePanel4 = new JPanel(new GridLayout(2, 4, 10, 10));
+        tabellePanel4.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        // Zeile 1
+        JLabel labelVerkehrsmittel = new JLabel("Verkehrsmittel: ");
+        tabellePanel4.add(labelVerkehrsmittel);
+
+        JComboBox<String> pickerVerkehrsmittel = new JComboBox<>(new String[]{"Standardsuche", "Option 1", "Option 2"});
+        tabellePanel4.add(pickerVerkehrsmittel);
+
+        JButton buttonErweitert = new JButton("Erweitert");
+        tabellePanel4.add(buttonErweitert);
+
+        JLabel labelInfo8 = new JLabel("Info");
+        tabellePanel4.add(labelInfo8);
+
+        // Zeile 2
+        JLabel labelLeer = new JLabel("");  // Leeres Feld
+        tabellePanel4.add(labelLeer);
+
+        JCheckBox checkBoxSchnellsteVerbindung = new JCheckBox("Schnellste Verbindung");
+        tabellePanel4.add(checkBoxSchnellsteVerbindung);
+
+        JLabel labelInfo9 = new JLabel("Info");
+        tabellePanel4.add(labelInfo9);
+
+        JCheckBox checkBoxFahrradmitnahme = new JCheckBox("Fahrradmitnahme");
+        tabellePanel4.add(checkBoxFahrradmitnahme);
+
+        tab1.add(tabellePanel4);
+
+        // Trennlinie
+        JSeparator separator = new JSeparator();
+        tab1.add(separator);
+
+        // Footer mit 3 Buttons
+        JPanel footerPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 10, 10));
+        JButton buttonVerbindungSuchen = new JButton("Verbindung suchen");
+        JButton buttonNeueAnfrage = new JButton("Neue Anfrage");
+        JButton buttonMeinAnfrageprofil = new JButton("Mein Anfrageprofil");
+
+        footerPanel.add(buttonVerbindungSuchen);
+        footerPanel.add(buttonNeueAnfrage);
+        footerPanel.add(buttonMeinAnfrageprofil);
+
+        tab1.add(footerPanel);
+
+
+
+
+
+
+        buttonVerbindungSuchen.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                // Hier werden die Eingaben aus den Textfeldern und Kombinationsfeldern gelesen
+                String von = textField1.getText();
+                String nach = textField2.getText();
+                String hinfahrtDatum = datePicker1.getText();
+                String hinfahrtZeit = timePicker1.getText();
+                String rueckfahrtDatum = datePicker2.getText();
+                String rueckfahrtZeit = timePicker2.getText();
+                String reisende = pickerErwachsenKind.getSelectedItem().toString();
+                String ermaessigung = pickerErmaessigung.getSelectedItem().toString();
+                String klasse = pickerKlasse.getSelectedItem().toString();
+                String verkehrsmittel = pickerVerkehrsmittel.getSelectedItem().toString();
+                boolean schnellsteVerbindung = checkBoxSchnellsteVerbindung.isSelected();
+                boolean fahrradmitnahme = checkBoxFahrradmitnahme.isSelected();
+
+                JOptionPane.showMessageDialog(window,
+                        "Von: " + von + "\n" +
+                        "Nach: " + nach + "\n" +
+                        "Hinfahrt - Datum: " + hinfahrtDatum + ", Uhrzeit: " + hinfahrtZeit + "\n" +
+                        "Rückfahrt - Datum: " + rueckfahrtDatum + ", Uhrzeit: " + rueckfahrtZeit + "\n" +
+                        "Reisende: " + reisende  + "\n" +
+                        "Ermäßigung: " + ermaessigung+ "\n" +
+                        "Klasse: " + klasse+ "\n" +
+                        "Verkehrsmittel: " + verkehrsmittel+ "\n" +
+                        "Schnellste Verbindung: " + schnellsteVerbindung+ "\n" +
+                        "Fahrradmitnahme: " + fahrradmitnahme);
+            }
+        });
+    }
+}