commit 8bce97f6532edbdd412a390d2bce9e8081604add
Author: Jonas Neugebauer <jonas@neugebauer.cc>
Date:   Sun Jan 10 23:51:46 2021 +0100

    Initial commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9fe8940
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,26 @@
+# ---> Java
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+Dokumente*
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
diff --git a/Edge.java b/Edge.java
new file mode 100755
index 0000000..1d33776
--- /dev/null
+++ b/Edge.java
@@ -0,0 +1,75 @@
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Edge
+ * </p>
+ * <p>
+ * Die Klasse Edge stellt eine einzelne, ungerichtete Kante eines Graphen dar. 
+ * Beim Erstellen werden die beiden durch sie zu verbindenden Knotenobjekte und eine 
+ * Gewichtung als double uebergeben. Beide Knotenobjekte koennen abgefragt werden. 
+ * Des Weiteren koennen die Gewichtung und eine Markierung gesetzt und abgefragt werden.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Edge{
+  private Vertex[] vertices;
+  private double weight;
+  private boolean mark;
+  
+  /**
+  * Ein neues Objekt vom Typ Edge wird erstellt. Die von diesem Objekt 
+  * repraesentierte Kante verbindet die Knoten pVertex und pAnotherVertex mit der 
+  * Gewichtung pWeight. Ihre Markierung hat den Wert false.
+  */
+  public Edge(Vertex pVertex, Vertex pAnotherVertex, double pWeight){
+    vertices = new Vertex[2];
+    vertices[0] = pVertex;
+    vertices[1] = pAnotherVertex;
+    weight = pWeight;
+    mark = false;
+  }
+  
+  /**
+  * Die Anfrage gibt die beiden Knoten, die durch die Kante verbunden werden, als neues Feld vom Typ Vertex zurueck. Das Feld hat 
+  * genau zwei Eintraege mit den Indexwerten 0 und 1.
+  */
+  public Vertex[] getVertices(){
+    Vertex[] result = new Vertex[2];
+    result[0] = vertices[0]; 
+    result[1] = vertices[1];
+    return result;
+  }
+  
+  /**
+  * Der Auftrag setzt das Gewicht der Kante auf pWeight.
+  */
+  public void setWeight(double pWeight){
+    weight = pWeight;
+  } 
+  
+  /**
+  * Die Anfrage liefert das Gewicht der Kante als double.
+  */
+  public double getWeight(){
+    return weight;
+  } 
+  
+  /**
+  * Der Auftrag setzt die Markierung der Kante auf den Wert pMark.
+  */
+  public void setMark(boolean pMark){
+    mark = pMark;
+  }
+  
+  /**
+  * Die Anfrage liefert true, wenn die Markierung der Kante den Wert true hat, ansonsten false.
+  */
+  public boolean isMarked(){
+    return mark;
+  }
+  
+}
diff --git a/Graph.java b/Graph.java
new file mode 100755
index 0000000..43a8109
--- /dev/null
+++ b/Graph.java
@@ -0,0 +1,312 @@
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Graph
+ * </p>
+ * <p>
+ * Die Klasse Graph stellt einen ungerichteten, kantengewichteten Graphen dar. Es koennen 
+ * Knoten- und Kantenobjekte hinzugefuegt und entfernt, flache Kopien der Knoten- und Kantenlisten 
+ * des Graphen angefragt und Markierungen von Knoten und Kanten gesetzt und ueberprueft werden.
+ * Des Weiteren kann eine Liste der Nachbarn eines bestimmten Knoten, eine Liste der inzidenten 
+ * Kanten eines bestimmten Knoten und die Kante von einem bestimmten Knoten zu einem 
+ * anderen bestimmten Knoten angefragt werden. Abgesehen davon kann abgefragt werden, welches 
+ * Knotenobjekt zu einer bestimmten ID gehoert und ob der Graph leer ist.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Graph{
+  private List<Vertex> vertices;
+  private List<Edge> edges;
+
+  /**
+   * Ein Objekt vom Typ Graph wird erstellt. Der von diesem Objekt 
+   * repraesentierte Graph ist leer.
+   */
+  public Graph(){
+    //Leere Listen fuer Knoten und Kanten erstellen.
+    vertices = new List<Vertex>();
+    edges = new List<Edge>();
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste aller Knotenobjekte vom Typ List<Vertex>.
+   */
+  public List<Vertex> getVertices(){
+    //Eine neue Liste mit allen Vertex-Objekten erstellen.
+    List<Vertex> result = new List<Vertex>();
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      result.append(vertices.getContent());
+      vertices.next();
+    }
+    //Aktuelles Element zum Anfang bewegen.
+    result.toFirst();
+
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste aller Kantenobjekte vom Typ List<Edge>.
+   */
+  public List<Edge> getEdges(){
+    //Eine neue Liste mit allen Edge-Objekten erstellen.
+    List<Edge> result = new List<Edge>();
+    edges.toFirst();
+    while (edges.hasAccess()){
+      result.append(edges.getContent());
+      edges.next();
+    }
+    //Aktuelles Element zum Anfang bewegen.
+    result.toFirst();
+
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert das Knotenobjekt mit pID als ID. Ist ein solchen Knotenobjekt nicht im Graphen enthalten,
+   * wird null zurueckgeliefert.
+   */
+  public Vertex getVertex(String pID){
+    //Vertex-Objekt mit pID als ID suchen.
+    Vertex result = null;
+    vertices.toFirst();
+    while (vertices.hasAccess() && result == null){
+      if (vertices.getContent().getID().equals(pID)){
+        result = vertices.getContent();
+      }
+      vertices.next();
+    }
+
+    //Objekt zurueckliefern.
+    return result;
+  }
+
+  /**
+   * Der Auftrag fuegt den Knoten pVertex in den Graphen ein, sofern es noch keinen
+   * Knoten mit demselben ID-Eintrag wie pVertex im Graphen gibt und pVertex eine ID ungleich null hat. 
+   * Ansonsten passiert nichts.
+   */
+  public void addVertex(Vertex pVertex){
+    //Pruefen, ob der Vertex existiert und eine ID hat.
+    if (pVertex != null && pVertex.getID() != null) {
+      //Pruefen, ob nicht schon ein Vertex mit gleicher ID enthalten ist.
+      boolean freeID = true;
+      vertices.toFirst();
+      while (vertices.hasAccess() && freeID){
+        if (vertices.getContent().getID().equals(pVertex.getID())){
+          freeID = false;
+        }
+        vertices.next();
+      }
+
+      //Wenn die ID noch frei ist, den Vertex einfuegen, sonst nichts tun.
+      if (freeID) {
+        vertices.append(pVertex);      
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag fuegt die Kante pEdge in den Graphen ein, sofern beide durch die Kante verbundenen Knoten
+   * im Graphen enthalten sind, nicht identisch sind und noch keine Kante zwischen den Knoten existiert. Ansonsten passiert nichts.
+   */
+  public void addEdge(Edge pEdge){ 
+    //Pruefen, ob pEdge exisitert.
+    if (pEdge != null){  
+      Vertex[] vertexPair = pEdge.getVertices();
+      
+      //Einfuegekriterien pruefen.
+      if (vertexPair[0] != null && vertexPair[1] != null && 
+      this.getVertex(vertexPair[0].getID()) == vertexPair[0] && 
+      this.getVertex(vertexPair[1].getID()) == vertexPair[1] &&
+      this.getEdge(vertexPair[0], vertexPair[1]) == null && 
+      vertexPair[0] != vertexPair[1]){
+        //Kante einfuegen.
+        edges.append(pEdge); 
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag entfernt den Knoten pVertex aus dem Graphen und loescht alle Kanten, die mit ihm inzident sind.
+   * Ist der Knoten pVertex nicht im Graphen enthalten, passiert nichts.
+   */
+  public void removeVertex(Vertex pVertex){
+    //Inzidente Kanten entfernen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      Vertex[] akt = edges.getContent().getVertices();
+      if (akt[0] == pVertex || akt[1] == pVertex){
+        edges.remove();
+      } else {
+        edges.next();
+      }
+    }
+
+    //Knoten entfernen
+    vertices.toFirst();
+    while (vertices.hasAccess() && vertices.getContent()!= pVertex){
+      vertices.next();
+    }
+    if (vertices.hasAccess()){
+      vertices.remove();
+    }
+  }
+
+  /**
+   * Der Auftrag entfernt die Kante pEdge aus dem Graphen. Ist die Kante pEdge nicht 
+   * im Graphen enthalten, passiert nichts.
+   */
+  public void removeEdge(Edge pEdge){
+    //Kante aus Kantenliste des Graphen entfernen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      if (edges.getContent() == pEdge){
+        edges.remove();
+      } else {
+        edges.next();
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag setzt die Markierungen aller Knoten des Graphen auf pMark.
+   */
+  public void setAllVertexMarks(boolean pMark){
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      vertices.getContent().setMark(pMark);
+      vertices.next();
+    }
+  }
+
+  /**
+   * Der Auftrag setzt die Markierungen aller Kanten des Graphen auf pMark.
+   */
+  public void setAllEdgeMarks(boolean pMark){
+    edges.toFirst();
+    while (edges.hasAccess()){
+      edges.getContent().setMark(pMark);
+      edges.next();
+    }
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn alle Knoten des Graphen mit true markiert sind, ansonsten false.
+   */
+  public boolean allVerticesMarked(){
+    boolean result = true;
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      if (!vertices.getContent().isMarked()){
+        result = false;
+      }
+      vertices.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn alle Kanten des Graphen mit true markiert sind, ansonsten false.
+   */
+  public boolean allEdgesMarked(){
+    boolean result = true;
+    edges.toFirst();
+    while (edges.hasAccess()){
+      if (!edges.getContent().isMarked()){
+        result = false;
+      }
+      edges.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert alle Nachbarn des Knotens pVertex als neue Liste vom Typ List<Vertex>. Hat der Knoten
+   * pVertex keine Nachbarn in diesem Graphen oder ist gar nicht in diesem Graphen enthalten, so 
+   * wird eine leere Liste zurueckgeliefert.
+   */
+  public List<Vertex> getNeighbours(Vertex pVertex){
+    List<Vertex> result = new List<Vertex>();
+    
+    //Alle Kanten durchlaufen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      
+      //Wenn ein Knoten der Kante pVertex ist, den anderen als Nachbarn in die Ergebnisliste einfuegen.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if (vertexPair[0] == pVertex) {
+        result.append(vertexPair[1]);
+      } else { 
+        if (vertexPair[1] == pVertex){
+          result.append(vertexPair[0]);
+        }
+      }
+      edges.next();
+    }    
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste alle inzidenten Kanten zum Knoten pVertex. Hat der Knoten
+   * pVertex keine inzidenten Kanten in diesem Graphen oder ist gar nicht in diesem Graphen enthalten, so 
+   * wird eine leere Liste zurueckgeliefert.
+   */
+  public List<Edge> getEdges(Vertex pVertex){
+    List<Edge> result = new List<Edge>();
+    
+    //Alle Kanten durchlaufen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      
+      //Wenn ein Knoten der Kante pVertex ist, dann Kante als inzidente Kante in die Ergebnisliste einfuegen.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if (vertexPair[0] == pVertex) {
+        result.append(edges.getContent());
+      } else{ 
+        if (vertexPair[1] == pVertex){
+          result.append(edges.getContent());
+        }
+      }
+      edges.next();
+    }    
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert die Kante, welche die Knoten pVertex und pAnotherVertex verbindet, 
+   * als Objekt vom Typ Edge. Ist der Knoten pVertex oder der Knoten pAnotherVertex nicht 
+   * im Graphen enthalten oder gibt es keine Kante, die beide Knoten verbindet, so wird null 
+   * zurueckgeliefert.
+   */
+  public Edge getEdge(Vertex pVertex, Vertex pAnotherVertex){
+    Edge result = null;
+    
+    //Kanten durchsuchen, solange keine passende gefunden wurde.
+    edges.toFirst();
+    while (edges.hasAccess() && result == null){
+      
+      //Pruefen, ob die Kante pVertex und pAnotherVertex verbindet.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if ((vertexPair[0] == pVertex && vertexPair[1] == pAnotherVertex) ||
+      (vertexPair[0] == pAnotherVertex && vertexPair[1] == pVertex)) {
+        //Kante als Ergebnis merken.
+        result = edges.getContent();
+      } 
+      edges.next();
+    }    
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn der Graph keine Knoten enthaelt, ansonsten false.
+   */
+  public boolean isEmpty(){
+    return vertices.isEmpty();
+  } 
+
+}
diff --git a/List.java b/List.java
new file mode 100755
index 0000000..8c82b92
--- /dev/null
+++ b/List.java
@@ -0,0 +1,345 @@
+ /**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse List<ContentType>
+ * </p>
+ * <p>
+ * Objekt der generischen Klasse List verwalten beliebig viele linear
+ * angeordnete Objekte vom Typ ContentType. Auf hoechstens ein Listenobjekt,
+ * aktuellesObjekt genannt, kann jeweils zugegriffen werden.<br />
+ * Wenn eine Liste leer ist, vollstaendig durchlaufen wurde oder das aktuelle
+ * Objekt am Ende der Liste geloescht wurde, gibt es kein aktuelles Objekt.<br />
+ * Das erste oder das letzte Objekt einer Liste koennen durch einen Auftrag zum
+ * aktuellen Objekt gemacht werden. Ausserdem kann das dem aktuellen Objekt
+ * folgende Listenobjekt zum neuen aktuellen Objekt werden. <br />
+ * Das aktuelle Objekt kann gelesen, veraendert oder geloescht werden. Ausserdem
+ * kann vor dem aktuellen Objekt ein Listenobjekt eingefuegt werden.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_06 2015-10-25
+ */
+public class List<ContentType> {
+
+  /* --------- Anfang der privaten inneren Klasse -------------- */
+
+  private class ListNode {
+
+    private ContentType contentObject;
+    private ListNode next;
+
+    /**
+     * Ein neues Objekt wird erschaffen. Der Verweis ist leer.
+     * 
+     * @param pContent das Inhaltsobjekt vom Typ ContentType
+     */
+    private ListNode(ContentType pContent) {
+      contentObject = pContent;
+      next = null;
+    }
+
+    /**
+     * Der Inhalt des Knotens wird zurueckgeliefert.
+     * 
+     * @return das Inhaltsobjekt des Knotens
+     */
+    public ContentType getContentObject() {
+      return contentObject;
+    }
+
+    /**
+     * Der Inhalt dieses Kontens wird gesetzt.
+     * 
+     * @param pContent das Inhaltsobjekt vom Typ ContentType
+     */
+    public void setContentObject(ContentType pContent) {
+      contentObject = pContent;
+    }
+
+    /**
+     * Der Nachfolgeknoten wird zurueckgeliefert.
+     * 
+     * @return das Objekt, auf das der aktuelle Verweis zeigt
+     */
+    public ListNode getNextNode() {
+      return this.next;
+    }
+
+    /**
+     * Der Verweis wird auf das Objekt, das als Parameter uebergeben
+     * wird, gesetzt.
+     * 
+     * @param pNext der Nachfolger des Knotens
+     */
+    public void setNextNode(ListNode pNext) {
+      this.next = pNext;
+    }
+
+  }
+
+  /* ----------- Ende der privaten inneren Klasse -------------- */
+
+  // erstes Element der Liste
+  ListNode first;
+
+  // letztes Element der Liste
+  ListNode last;
+
+  // aktuelles Element der Liste
+  ListNode current;
+
+  /**
+   * Eine leere Liste wird erzeugt.
+   */
+  public List() {
+    first = null;
+    last = null;
+    current = null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthaelt,
+   * sonst liefert sie den Wert false.
+   * 
+   * @return true, wenn die Liste leer ist, sonst false
+   */
+  public boolean isEmpty() {
+    // Die Liste ist leer, wenn es kein erstes Element gibt.
+    return first == null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt,
+   * sonst liefert sie den Wert false.
+   * 
+   * @return true, falls Zugriff moeglich, sonst false
+   */
+  public boolean hasAccess() {
+    // Es gibt keinen Zugriff, wenn current auf kein Element verweist.
+    return current != null; 
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses
+   * nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in
+   * der Liste folgende Objekt zum aktuellen Objekt, andernfalls gibt es nach
+   * Ausfuehrung des Auftrags kein aktuelles Objekt, d.h. hasAccess() liefert
+   * den Wert false.
+   */
+  public void next() {
+    if (this.hasAccess()) {
+      current = current.getNextNode();
+    }
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles
+   * Objekt. Ist die Liste leer, geschieht nichts.
+   */
+  public void toFirst() {
+    if (!isEmpty()) {
+      current = first;
+    }
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, wird das letzte Objekt der Liste
+   * aktuelles Objekt. Ist die Liste leer, geschieht nichts.
+   */
+  public void toLast() {
+    if (!isEmpty()) {
+      current = last;
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
+   * aktuelle Objekt zurueckgegeben, andernfalls (hasAccess() == false) gibt
+   * die Anfrage den Wert null zurueck.
+   * 
+   * @return das aktuelle Objekt (vom Typ ContentType) oder null, wenn es
+   *         kein aktuelles Objekt gibt
+   */
+  public ContentType getContent() {
+    if (this.hasAccess()) {
+      return current.getContentObject();
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pContent
+   * ungleich null ist, wird das aktuelle Objekt durch pContent ersetzt. Sonst
+   * geschieht nichts.
+   * 
+   * @param pContent
+   *            das zu schreibende Objekt vom Typ ContentType
+   */
+  public void setContent(ContentType pContent) {
+    // Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt.
+    if (pContent != null && this.hasAccess()) { 
+      current.setContentObject(pContent);
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein neues
+   * Objekt vor dem aktuellen Objekt in die Liste eingefuegt. Das aktuelle
+   * Objekt bleibt unveraendert. <br />
+   * Wenn die Liste leer ist, wird pContent in die Liste eingefuegt und es
+   * gibt weiterhin kein aktuelles Objekt (hasAccess() == false). <br />
+   * Falls es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste
+   * nicht leer ist oder pContent gleich null ist, geschieht nichts.
+   * 
+   * @param pContent
+   *            das einzufuegende Objekt vom Typ ContentType
+   */
+  public void insert(ContentType pContent) {
+    if (pContent != null) { // Nichts tun, wenn es keinen Inhalt gibt.
+      if (this.hasAccess()) { // Fall: Es gibt ein aktuelles Element.
+
+        // Neuen Knoten erstellen.
+        ListNode newNode = new ListNode(pContent); 
+
+        if (current != first) { // Fall: Nicht an erster Stelle einfuegen.
+          ListNode previous = this.getPrevious(current);
+          newNode.setNextNode(previous.getNextNode());
+          previous.setNextNode(newNode);
+        } else { // Fall: An erster Stelle einfuegen.
+          newNode.setNextNode(first);
+          first = newNode;
+        }
+
+      } else { //Fall: Es gibt kein aktuelles Element.
+
+        if (this.isEmpty()) { // Fall: In leere Liste einfuegen.
+
+          // Neuen Knoten erstellen.
+          ListNode newNode = new ListNode(pContent); 
+
+          first = newNode;
+          last = newNode;
+        }
+
+      }
+    }
+  }
+
+  /**
+   * Falls pContent gleich null ist, geschieht nichts.<br />
+   * Ansonsten wird ein neues Objekt pContent am Ende der Liste eingefuegt.
+   * Das aktuelle Objekt bleibt unveraendert. <br />
+   * Wenn die Liste leer ist, wird das Objekt pContent in die Liste eingefuegt
+   * und es gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
+   * 
+   * @param pContent
+   *            das anzuhaengende Objekt vom Typ ContentType
+   */
+  public void append(ContentType pContent) {
+    if (pContent != null) { // Nichts tun, wenn es keine Inhalt gibt.
+
+      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
+        this.insert(pContent);
+      } else { // Fall: An nicht-leere Liste anfuegen.
+
+        // Neuen Knoten erstellen.
+        ListNode newNode = new ListNode(pContent); 
+
+        last.setNextNode(newNode);
+        last = newNode; // Letzten Knoten aktualisieren.
+      }
+
+    }
+  }
+
+  /**
+   * Falls es sich bei der Liste und pList um dasselbe Objekt handelt,
+   * pList null oder eine leere Liste ist, geschieht nichts.<br />
+   * Ansonsten wird die Liste pList an die aktuelle Liste angehaengt.
+   * Anschliessend wird pList eine leere Liste. Das aktuelle Objekt bleibt
+   * unveraendert. Insbesondere bleibt hasAccess identisch.
+   * 
+   * @param pList
+   *            die am Ende anzuhaengende Liste vom Typ List<ContentType>
+   */
+  public void concat(List<ContentType> pList) {
+    if (pList != this && pList != null && !pList.isEmpty()) { // Nichts tun,
+    // wenn pList und this identisch, pList leer oder nicht existent.
+
+      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
+        this.first = pList.first;
+        this.last = pList.last;
+      } else { // Fall: An nicht-leere Liste anfuegen.
+        this.last.setNextNode(pList.first);
+        this.last = pList.last;
+      }
+
+      // Liste pList loeschen.
+      pList.first = null;
+      pList.last = null;
+      pList.current = null;
+    }
+  }
+
+  /**
+   * Wenn die Liste leer ist oder es kein aktuelles Objekt gibt (hasAccess()
+   * == false), geschieht nichts.<br />
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
+   * aktuelle Objekt geloescht und das Objekt hinter dem geloeschten Objekt
+   * wird zum aktuellen Objekt. <br />
+   * Wird das Objekt, das am Ende der Liste steht, geloescht, gibt es kein
+   * aktuelles Objekt mehr.
+   */
+  public void remove() {
+    // Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist.
+    if (this.hasAccess() && !this.isEmpty()) { 
+
+      if (current == first) {
+        first = first.getNextNode();
+      } else {
+        ListNode previous = this.getPrevious(current);
+        if (current == last) {
+          last = previous;
+        }
+        previous.setNextNode(current.getNextNode());
+      }
+
+      ListNode temp = current.getNextNode();
+      current.setContentObject(null);
+      current.setNextNode(null);
+      current = temp;
+
+      //Beim loeschen des letzten Elements last auf null setzen. 
+      if (this.isEmpty()) {
+        last = null;
+      }
+    }
+  }
+
+  /**
+   * Liefert den Vorgaengerknoten des Knotens pNode. Ist die Liste leer, pNode
+   * == null, pNode nicht in der Liste oder pNode der erste Knoten der Liste,
+   * wird null zurueckgegeben.
+   *
+   * @param pNode
+   *         der Knoten, dessen Vorgaenger zurueckgegeben werden soll
+   * @return der Vorgaenger des Knotens pNode oder null, falls die Liste leer ist,
+   *         pNode == null ist, pNode nicht in der Liste ist oder pNode der erste Knoten
+   *         der Liste ist
+   */
+  private ListNode getPrevious(ListNode pNode) {
+    if (pNode != null && pNode != first && !this.isEmpty()) {
+      ListNode temp = first;
+      while (temp != null && temp.getNextNode() != pNode) {
+        temp = temp.getNextNode();
+      }
+      return temp;
+    } else {
+      return null;
+    }
+  }
+  
+}
diff --git a/Tiefensuche.java b/Tiefensuche.java
new file mode 100644
index 0000000..b549a71
--- /dev/null
+++ b/Tiefensuche.java
@@ -0,0 +1,84 @@
+
+/**
+ * Implementierung der Tiefensuche auf einem ungereichteten,
+ * gewichteten Graphen.
+ */
+public class Tiefensuche {
+
+    private Graph g;
+
+    public Tiefensuche() {
+        g = new Graph();
+
+        // Aufbau des Graphen
+        // Erstellen der Knoten (Vertices)
+        g.addVertex(new Vertex("Köln"));
+        g.addVertex(new Vertex("Düsseldorf"));
+        g.addVertex(new Vertex("Dortmund"));
+
+        Vertex bi = new Vertex("Bielefeld");
+        g.addVertex(bi);
+        Vertex hnv = new Vertex("Hannover");
+        g.addVertex(hnv);
+        Vertex bo = new Vertex("Bochum");
+        g.addVertex(bo);
+
+        // Erstellen der Kanten (Edges)
+        g.addEdge(new Edge(
+            g.getVertex("Köln"),
+            g.getVertex("Dortmund"),
+            96.0
+        ));
+        g.addEdge(new Edge(
+            g.getVertex("Düsseldorf"),
+            g.getVertex("Dortmund"),
+            70.0
+        ));
+        g.addEdge(new Edge(g.getVertex("Dortmund"), bo, 22.0));
+        g.addEdge(new Edge(bi, hnv, 113.0));
+        Edge bi_do = new Edge(bi, g.getVertex("Dortmund"), 112.0);
+        g.addEdge(bi_do);
+        Edge bi_dus = new Edge(bi, g.getVertex("Düsseldorf"), 178.0);
+        g.addEdge(bi_dus);
+        Edge bo_dus = new Edge(bo, g.getVertex("Düsseldorf"), 52.0);
+    }
+
+    /**
+     * Suche nach einem Vertex mit der angegebenen ID mittels der Tiefensuche.
+     * @param pVertexID
+     * @return
+     */
+    public boolean findVertex( String pVertexID ) {
+        g.setAllVertexMarks(false); // Markierungen zurücksetzen
+        return findVertex(pVertexID, g.getVertices().getContent());
+    }
+
+    /**
+     * Hilfsmethode für die rekursive Tiefensuche.
+     * Sucht nach einem Vertex mit der angegebenen ID mittels der Tiefensuche,
+     * ausgehend vom angegebenen Startknoten.
+     * @param pVertexID
+     * @return
+     */
+    private boolean findVertex( String  pVertexID, Vertex pCurrent ) {
+        if( pCurrent.getID().equals(pVertexID) ) {
+            return true;
+        } else {
+            pCurrent.setMark(true);
+
+            List<Vertex> neighbours = g.getNeighbours(pCurrent);
+            neighbours.toFirst();
+            while( neighbours.hasAccess() ) {
+                Vertex v = neighbours.getContent();
+                if( !v.isMarked() ) {
+                    if( findVertex(pVertexID, v) ) {
+                        return true;
+                    }
+                }
+                neighbours.next();
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/TiefensucheTest.java b/TiefensucheTest.java
new file mode 100644
index 0000000..37c4067
--- /dev/null
+++ b/TiefensucheTest.java
@@ -0,0 +1,25 @@
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TiefensucheTest {
+
+    @Before
+    public void setUp() {
+
+    }
+
+    @Test
+    public void testFindVertex() {
+        Tiefensuche ts = new Tiefensuche();
+
+        assertTrue("Der Knoten Köln ist im Graphen vorhanden.", ts.findVertex("Köln"));
+        assertTrue("Der Knoten Bielefeld ist im Graphen vorhanden.", ts.findVertex("Bielefeld"));
+        assertTrue("Der Knoten Bochum ist im Graphen vorhanden.", ts.findVertex("Bochum"));
+
+        assertFalse("Der Knoten Tokio ist nicht im Graphen vorhanden.", ts.findVertex("Tokio"));
+        assertFalse("Der Knoten London ist nicht im Graphen vorhanden.", ts.findVertex("London"));
+    }
+
+}
diff --git a/Vertex.java b/Vertex.java
new file mode 100755
index 0000000..403a08e
--- /dev/null
+++ b/Vertex.java
@@ -0,0 +1,51 @@
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Vertex
+ * </p>
+ * <p>
+ * Die Klasse Vertex stellt einen einzelnen Knoten eines Graphen dar. Jedes Objekt 
+ * dieser Klasse verfuegt ueber eine im Graphen eindeutige ID als String und kann diese 
+ * ID zurueckliefern. Darueber hinaus kann eine Markierung gesetzt und abgefragt werden.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Vertex{
+  //Einmalige ID des Knotens und Markierung
+  private String id;
+  private boolean mark;
+  
+  /**
+  * Ein neues Objekt vom Typ Vertex wird erstellt. Seine Markierung hat den Wert false.
+  */
+  public Vertex(String pID){
+    id = pID;
+    mark = false;
+  }
+  
+  /**
+  * Die Anfrage liefert die ID des Knotens als String.
+  */
+  public String getID(){
+    return new String(id);
+  }
+  
+  /**
+  * Der Auftrag setzt die Markierung des Knotens auf den Wert pMark.
+  */
+  public void setMark(boolean pMark){
+    mark = pMark;
+  }
+  
+  /**
+  * Die Anfrage liefert true, wenn die Markierung des Knotens den Wert true hat, ansonsten false.
+  */
+  public boolean isMarked(){
+    return mark;
+  }
+  
+}
diff --git a/package.bluej b/package.bluej
new file mode 100644
index 0000000..677f390
--- /dev/null
+++ b/package.bluej
@@ -0,0 +1,59 @@
+#BlueJ package file
+dependency1.from=BinarySearchTree
+dependency1.to=ComparableContent
+dependency1.type=UsesDependency
+dependency2.from=Racingsimulator
+dependency2.to=Athlete
+dependency2.type=UsesDependency
+editor.fx.0.height=738
+editor.fx.0.width=816
+editor.fx.0.x=466
+editor.fx.0.y=146
+objectbench.height=100
+objectbench.width=1256
+package.divider.horizontal=0.6
+package.divider.vertical=0.881243063263041
+package.editor.height=787
+package.editor.width=1145
+package.editor.x=0
+package.editor.y=0
+package.frame.height=1000
+package.frame.width=1296
+package.numDependencies=2
+package.numTargets=4
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=Racingsimulator
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=130
+target1.x=450
+target1.y=472
+target2.height=50
+target2.name=ComparableContent
+target2.showInterface=false
+target2.type=InterfaceTarget
+target2.width=250
+target2.x=160
+target2.y=270
+target3.height=50
+target3.name=Athlete
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=90
+target3.x=280
+target3.y=550
+target4.height=50
+target4.name=BinarySearchTree
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=230
+target4.x=370
+target4.y=90