Programm fertiggestellt

Langlaufsimulator/BinarySearchTree.ctxt

@@ -0,0 +1,39 @@
+#BlueJ class context
+comment0.target=BinarySearchTree
+comment0.text=\r\n\ <p>\r\n\ Materialien\ zu\ den\ zentralen\ NRW-Abiturpruefungen\ im\ Fach\ Informatik\ ab\ 2018\r\n\ </p>\r\n\ <p>\r\n\ Generische\ Klasse\ BinarySearchTree<ContentType>\r\n\ </p>\r\n\ <p>\r\n\ Mithilfe\ der\ generischen\ Klasse\ BinarySearchTree\ koennen\ beliebig\ viele\r\n\ Objekte\ in\ einem\ Binaerbaum\ (binaerer\ Suchbaum)\ entsprechend\ einer\r\n\ Ordnungsrelation\ verwaltet\ werden.\ <br\ />\r\n\ Ein\ Objekt\ der\ Klasse\ stellt\ entweder\ einen\ leeren\ binaeren\ Suchbaum\ dar\ oder\r\n\ verwaltet\ ein\ Inhaltsobjekt\ sowie\ einen\ linken\ und\ einen\ rechten\ Teilbaum,\r\n\ die\ ebenfalls\ Objekte\ der\ Klasse\ BinarySearchTree\ sind.<br\ />\r\n\ Die\ Klasse\ der\ Objekte,\ die\ in\ dem\ Suchbaum\ verwaltet\ werden\ sollen,\ muss\r\n\ das\ generische\ Interface\ ComparableContent\ implementieren.\ Dabei\ muss\ durch\r\n\ Ueberschreiben\ der\ drei\ Vergleichsmethoden\ isLess,\ isEqual,\ isGreater\ (s.\r\n\ Dokumentation\ des\ Interfaces)\ eine\ eindeutige\ Ordnungsrelation\ festgelegt\r\n\ sein.\ <br\ />\r\n\ Alle\ Objekte\ im\ linken\ Teilbaum\ sind\ kleiner\ als\ das\ Inhaltsobjekt\ des\r\n\ binaeren\ Suchbaums.\ Alle\ Objekte\ im\ rechten\ Teilbaum\ sind\ groesser\ als\ das\r\n\ Inhaltsobjekt\ des\ binaeren\ Suchbaums.\ Diese\ Bedingung\ gilt\ (rekursiv)\ auch\ in\r\n\ beiden\ Teilbaeumen.\ <br\ />\r\n\ Hinweis\:\ In\ dieser\ Version\ wird\ die\ Klasse\ BinaryTree\ nicht\ benutzt.\r\n\ </p>\r\n\r\n\ @author\ Qualitaets-\ und\ UnterstuetzungsAgentur\ -\ Landesinstitut\ fuer\ Schule\r\n\ @version\ Generisch_03\ 2017-11-28\r\n
+comment1.params=
+comment1.target=BinarySearchTree()
+comment1.text=\r\n\ Der\ Konstruktor\ erzeugt\ einen\ leeren\ Suchbaum.\r\n
+comment10.params=pContent
+comment10.target=ComparableContent\ search(ComparableContent)
+comment10.text=\r\n\ Falls\ ein\ bezueglich\ der\ verwendeten\ Vergleichsmethode\ isEqual\ mit\r\n\ pContent\ uebereinstimmendes\ Objekt\ im\ binaeren\ Suchbaum\ enthalten\ ist,\r\n\ liefert\ die\ Anfrage\ dieses,\ ansonsten\ wird\ null\ zurueckgegeben.\ <br\ />\r\n\ Falls\ der\ Parameter\ null\ ist,\ wird\ null\ zurueckgegeben.\r\n\r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ zu\ suchendes\ Objekt\ vom\ Typ\ ContentType\r\n\ @return\ das\ gefundene\ Objekt\ vom\ Typ\ ContentType,\ bei\ erfolgloser\ Suche\ null\r\n\r\n
+comment11.params=
+comment11.target=BinarySearchTree\ ancestorOfSmallRight()
+comment11.text=\r\n\ Die\ Methode\ liefert\ denjenigen\ Baum,\ dessen\ linker\ Nachfolger\ keinen\ linken\r\n\ Nachfolger\ mehr\ hat.\ Es\ ist\ also\ spaeter\ moeglich,\ in\ einem\ Baum\ im\r\n\ rechten\ Nachfolger\ den\ Vorgaenger\ des\ linkesten\ Nachfolgers\ zu\ finden.\r\n\r\n
+comment12.params=
+comment12.target=BinarySearchTree.BSTNode\ getNodeOfLeftSuccessor()
+comment13.params=
+comment13.target=BinarySearchTree.BSTNode\ getNodeOfRightSuccessor()
+comment2.params=
+comment2.target=boolean\ isEmpty()
+comment2.text=\r\n\ Diese\ Anfrage\ liefert\ den\ Wahrheitswert\ true,\ wenn\ der\ Suchbaum\ leer\ ist,\r\n\ sonst\ liefert\ sie\ den\ Wert\ false.\r\n\r\n\ @return\ true,\ wenn\ der\ binaere\ Suchbaum\ leer\ ist,\ sonst\ false\r\n\r\n
+comment3.params=pContent
+comment3.target=void\ insert(ComparableContent)
+comment3.text=\r\n\ Falls\ der\ Parameter\ null\ ist,\ geschieht\ nichts.<br\ />\r\n\ Falls\ ein\ bezueglich\ der\ verwendeten\ Vergleichsmethode\ isEqual\ mit\r\n\ pContent\ uebereinstimmendes\ Objekt\ im\ geordneten\ binaeren\ Suchbau\r\n\ enthalten\ ist,\ passiert\ nichts.\ <br\ />\r\n\ Achtung\:\ hier\ wird\ davon\ ausgegangen,\ dass\ isEqual\ genau\ dann\ true\r\n\ liefert,\ wenn\ isLess\ und\ isGreater\ false\ liefern.\ <br\ />\r\n\ Andernfalls\ (isLess\ oder\ isGreater)\ wird\ das\ Objekt\ pContent\ entsprechend\r\n\ der\ vorgegebenen\ Ordnungsrelation\ in\ den\ BinarySearchTree\ eingeordnet.\r\n\r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ einzufuegendes\ Objekt\ vom\ Typ\ ContentType\r\n\r\n
+comment4.params=
+comment4.target=BinarySearchTree\ getLeftTree()
+comment4.text=\r\n\ Diese\ Anfrage\ liefert\ den\ linken\ Teilbaum\ des\ binaeren\ Suchbaumes.\ <br\ />\r\n\ Wenn\ er\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\r\n\ @return\ den\ linken\ Teilbaum\ (Objekt\ vom\ Typ\ BinarySearchTree<ContentType>)\r\n\ \ \ \ \ \ \ \ \ bzw.\ null,\ wenn\ der\ Suchbaum\ leer\ ist\r\n\r\n
+comment5.params=
+comment5.target=ComparableContent\ getContent()
+comment5.text=\r\n\ Diese\ Anfrage\ liefert\ das\ Inhaltsobjekt\ des\ Suchbaumes.\ Wenn\ der\ Suchbaum\r\n\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\r\n\ @return\ das\ Inhaltsobjekt\ vom\ Typ\ ContentType\ bzw.\ null,\ wenn\ der\ aktuelle\r\n\ \ \ \ \ \ \ \ \ Suchbaum\ leer\ ist\r\n\r\n
+comment6.params=
+comment6.target=List\ getInOrder()
+comment7.params=tree\ inOrder
+comment7.target=void\ getPartTree(BinarySearchTree,\ List)
+comment8.params=
+comment8.target=BinarySearchTree\ getRightTree()
+comment8.text=\r\n\ Diese\ Anfrage\ liefert\ den\ rechten\ Teilbaum\ des\ binaeren\ Suchbaumes.\ <br\ />\r\n\ Wenn\ er\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\r\n\ @return\ den\ rechten\ Teilbaum\ (Objekt\ vom\ Typ\ BinarySearchTree<ContentType>)\r\n\ \ \ \ \ \ \ \ \ bzw.\ null,\ wenn\ der\ aktuelle\ Suchbaum\ leer\ ist\r\n\r\n
+comment9.params=pContent
+comment9.target=void\ remove(ComparableContent)
+comment9.text=\r\n\ Falls\ ein\ bezueglich\ der\ verwendeten\ Vergleichsmethode\ mit\r\n\ pContent\ uebereinstimmendes\ Objekt\ im\ binaeren\ Suchbaum\ enthalten\r\n\ ist,\ wird\ dieses\ entfernt.\ Falls\ der\ Parameter\ null\ ist,\ aendert\ sich\r\n\ nichts.\r\n\r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ zu\ entfernendes\ Objekt\ vom\ Typ\ ContentType\r\n\r\n
+numComments=14

Langlaufsimulator/BinarySearchTree.java

@@ -29,232 +29,246 @@
  */
 public class BinarySearchTree<ContentType extends ComparableContent<ContentType>> {
 
-	/* --------- Anfang der privaten inneren Klasse -------------- */
+    /* --------- Anfang der privaten inneren Klasse -------------- */
 
-	/**
+    /**
-	 * Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
+     * Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
-	 * null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
+     * null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
-	 * nicht-null-Teilbaeume hat.
+     * nicht-null-Teilbaeume hat.
-	 */
+     */
-	private class BSTNode<CT extends ComparableContent<CT>> {
+    private class BSTNode<CT extends ComparableContent<CT>> {
 
-		private CT content;
+        private CT content;
-		private BinarySearchTree<CT> left, right;
+        private BinarySearchTree<CT> left, right;
 
-		public BSTNode(CT pContent) {
+        public BSTNode(CT pContent) {
-			// Der Knoten hat einen linken und rechten Teilbaum, die
+            // Der Knoten hat einen linken und rechten Teilbaum, die
-			// beide von null verschieden sind. Also hat ein Blatt immer zwei
+            // beide von null verschieden sind. Also hat ein Blatt immer zwei
-			// leere Teilbaeume unter sich.
+            // leere Teilbaeume unter sich.
-			this.content = pContent;
+            this.content = pContent;
-			left = new BinarySearchTree<CT>();
+            left = new BinarySearchTree<CT>();
-			right = new BinarySearchTree<CT>();
+            right = new BinarySearchTree<CT>();
-		}
+        }
 
-	}
+    }
 
-	/* ----------- Ende der privaten inneren Klasse -------------- */
+    /* ----------- Ende der privaten inneren Klasse -------------- */
 
-	private BSTNode<ContentType> node;
+    private BSTNode<ContentType> node;
 
-	/**
+    /**
-	 * Der Konstruktor erzeugt einen leeren Suchbaum.
+     * Der Konstruktor erzeugt einen leeren Suchbaum.
-	 */
+     */
-	public BinarySearchTree() {
+    public BinarySearchTree() {
-		this.node = null;
+        this.node = null;
-	}
+    }
 
-	/**
+    /**
-	 * Diese Anfrage liefert den Wahrheitswert true, wenn der Suchbaum leer ist,
+     * Diese Anfrage liefert den Wahrheitswert true, wenn der Suchbaum leer ist,
-	 * sonst liefert sie den Wert false.
+     * sonst liefert sie den Wert false.
-	 *
+     *
-	 * @return true, wenn der binaere Suchbaum leer ist, sonst false
+     * @return true, wenn der binaere Suchbaum leer ist, sonst false
-	 *
+     *
-	 */
+     */
-	public boolean isEmpty() {
+    public boolean isEmpty() {
-		return this.node == null;
+        return this.node == null;
-	}
+    }
 
-	/**
+    /**
-	 * Falls der Parameter null ist, geschieht nichts.<br />
+     * Falls der Parameter null ist, geschieht nichts.<br />
-	 * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
+     * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
-	 * pContent uebereinstimmendes Objekt im geordneten binaeren Suchbau
+     * pContent uebereinstimmendes Objekt im geordneten binaeren Suchbau
-	 * enthalten ist, passiert nichts. <br />
+     * enthalten ist, passiert nichts. <br />
-	 * Achtung: hier wird davon ausgegangen, dass isEqual genau dann true
+     * Achtung: hier wird davon ausgegangen, dass isEqual genau dann true
-	 * liefert, wenn isLess und isGreater false liefern. <br />
+     * liefert, wenn isLess und isGreater false liefern. <br />
-	 * Andernfalls (isLess oder isGreater) wird das Objekt pContent entsprechend
+     * Andernfalls (isLess oder isGreater) wird das Objekt pContent entsprechend
-	 * der vorgegebenen Ordnungsrelation in den BinarySearchTree eingeordnet.
+     * der vorgegebenen Ordnungsrelation in den BinarySearchTree eingeordnet.
-	 *
+     *
-	 * @param pContent
+     * @param pContent
-	 *            einzufuegendes Objekt vom Typ ContentType
+     *            einzufuegendes Objekt vom Typ ContentType
-	 *
+     *
-	 */
+     */
-	public void insert(ContentType pContent) {
+    public void insert(ContentType pContent) {
-		if (pContent != null) {
+        if (pContent != null) {
-			if (isEmpty()) {
+            if (isEmpty()) {
-				this.node = new BSTNode<ContentType>(pContent);
+                this.node = new BSTNode<ContentType>(pContent);
-			} else if (pContent.isLess(this.node.content)) {
+            } else if (pContent.isLess(this.node.content)) {
-				this.node.left.insert(pContent);
+                this.node.left.insert(pContent);
-			} else if(pContent.isGreater(this.node.content)) {
+            } else if(pContent.isGreater(this.node.content)) {
-				this.node.right.insert(pContent);
+                this.node.right.insert(pContent);
-			}
+            }
-		}
+        }
-	}
+    }
 
-	/**
+    /**
-	 * Diese Anfrage liefert den linken Teilbaum des binaeren Suchbaumes. <br />
+     * Diese Anfrage liefert den linken Teilbaum des binaeren Suchbaumes. <br />
-	 * Wenn er leer ist, wird null zurueckgegeben.
+     * Wenn er leer ist, wird null zurueckgegeben.
-	 *
+     *
-	 * @return den linken Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
+     * @return den linken Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
-	 *         bzw. null, wenn der Suchbaum leer ist
+     *         bzw. null, wenn der Suchbaum leer ist
-	 *
+     *
-	 */
+     */
-	public BinarySearchTree<ContentType> getLeftTree() {
+    public BinarySearchTree<ContentType> getLeftTree() {
-		if (this.isEmpty()) {
+        if (this.isEmpty()) {
-			return null;
+            return null;
-		} else {
+        } else {
-			return this.node.left;
+            return this.node.left;
-		}
+        }
-	}
+    }
 
-	/**
+    /**
-	 * Diese Anfrage liefert das Inhaltsobjekt des Suchbaumes. Wenn der Suchbaum
+     * Diese Anfrage liefert das Inhaltsobjekt des Suchbaumes. Wenn der Suchbaum
-	 * leer ist, wird null zurueckgegeben.
+     * leer ist, wird null zurueckgegeben.
-	 *
+     *
-	 * @return das Inhaltsobjekt vom Typ ContentType bzw. null, wenn der aktuelle
+     * @return das Inhaltsobjekt vom Typ ContentType bzw. null, wenn der aktuelle
-	 *         Suchbaum leer ist
+     *         Suchbaum leer ist
-	 *
+     *
-	 */
+     */
-	public ContentType getContent() {
+    public ContentType getContent() {
-		if (this.isEmpty()) {
+        if (this.isEmpty()) {
-			return null;
+            return null;
-		} else {
+        } else {
-			return this.node.content;
+            return this.node.content;
-		}
+        }
-	}
+    }
 
-	/**
+    public List<ContentType> getInOrder() {
-	 * Diese Anfrage liefert den rechten Teilbaum des binaeren Suchbaumes. <br />
+        List<ContentType> inOrder = new List<>();
-	 * Wenn er leer ist, wird null zurueckgegeben.
+        getPartTree(this, inOrder);
-	 *
+        return inOrder;
-	 * @return den rechten Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
+    }
-	 *         bzw. null, wenn der aktuelle Suchbaum leer ist
+    
-	 *
+    private void getPartTree(BinarySearchTree<ContentType> tree, List<ContentType> inOrder) {
-	 */
+        if (tree != null && tree.getContent() != null) {
-	public BinarySearchTree<ContentType> getRightTree() {
+            getPartTree(tree.getLeftTree(), inOrder);
-		if (this.isEmpty()) {
+            inOrder.append(tree.getContent());
-			return null;
+            getPartTree(tree.getRightTree(), inOrder);
-		} else {
+        }
-			return this.node.right;
+    }
-		}
-	}
 
-	/**
+    /**
-	 * Falls ein bezueglich der verwendeten Vergleichsmethode mit
+     * Diese Anfrage liefert den rechten Teilbaum des binaeren Suchbaumes. <br />
-	 * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten
+     * Wenn er leer ist, wird null zurueckgegeben.
-	 * ist, wird dieses entfernt. Falls der Parameter null ist, aendert sich
+     *
-	 * nichts.
+     * @return den rechten Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
-	 *
+     *         bzw. null, wenn der aktuelle Suchbaum leer ist
-	 * @param pContent
+     *
-	 *            zu entfernendes Objekt vom Typ ContentType
+     */
-	 *
+    public BinarySearchTree<ContentType> getRightTree() {
-	 */
+        if (this.isEmpty()) {
-	public void remove(ContentType pContent) {
+            return null;
-		if (isEmpty() || pContent == null ) {
+        } else {
-			// Abbrechen, da kein Element zum entfernen vorhanden ist.
+            return this.node.right;
-		  return;
+        }
-		}
+    }
 
-		if (pContent.isLess(node.content)) {
+    /**
-			// Element ist im linken Teilbaum zu loeschen.
+     * Falls ein bezueglich der verwendeten Vergleichsmethode mit
-			node.left.remove(pContent);
+     * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten
-		} else if (pContent.isGreater(node.content)) {
+     * ist, wird dieses entfernt. Falls der Parameter null ist, aendert sich
-			// Element ist im rechten Teilbaum zu loeschen.
+     * nichts.
-			node.right.remove(pContent);
+     *
-		} else {
+     * @param pContent
-			// Element ist gefunden.
+     *            zu entfernendes Objekt vom Typ ContentType
-			if (node.left.isEmpty()) {
+     *
-				if (node.right.isEmpty()) {
+     */
-					// Es gibt keinen Nachfolger.
+    public void remove(ContentType pContent) {
-					node = null;
+        if (isEmpty() || pContent == null ) {
-				} else {
+            // Abbrechen, da kein Element zum entfernen vorhanden ist.
-					// Es gibt nur rechts einen Nachfolger.
+            return;
-					node = getNodeOfRightSuccessor();
+        }
-				}
-			} else if (node.right.isEmpty()) {
-				// Es gibt nur links einen Nachfolger.
-				node = getNodeOfLeftSuccessor();
-			} else {
-				// Es gibt links und rechts einen Nachfolger.
-				if (getNodeOfRightSuccessor().left.isEmpty()) {
-					// Der rechte Nachfolger hat keinen linken Nachfolger.
-					node.content = getNodeOfRightSuccessor().content;
-					node.right = getNodeOfRightSuccessor().right;
-				} else {
-					BinarySearchTree<ContentType> previous = node.right
-							.ancestorOfSmallRight();
-					BinarySearchTree<ContentType> smallest = previous.node.left;
-					this.node.content = smallest.node.content;
-					previous.remove(smallest.node.content);
-				}
-			}
-		}
-	}
 
-	/**
+        if (pContent.isLess(node.content)) {
-	 * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
+            // Element ist im linken Teilbaum zu loeschen.
-	 * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten ist,
+            node.left.remove(pContent);
-	 * liefert die Anfrage dieses, ansonsten wird null zurueckgegeben. <br />
+        } else if (pContent.isGreater(node.content)) {
-	 * Falls der Parameter null ist, wird null zurueckgegeben.
+            // Element ist im rechten Teilbaum zu loeschen.
-	 *
+            node.right.remove(pContent);
-	 * @param pContent
+        } else {
-	 *            zu suchendes Objekt vom Typ ContentType
+            // Element ist gefunden.
-	 * @return das gefundene Objekt vom Typ ContentType, bei erfolgloser Suche null
+            if (node.left.isEmpty()) {
-	 *
+                if (node.right.isEmpty()) {
-	 */
+                    // Es gibt keinen Nachfolger.
-	public ContentType search(ContentType pContent) {
+                    node = null;
-		if (this.isEmpty() || pContent == null) {
+                } else {
-			// Abbrechen, da es kein Element zu suchen gibt.
+                    // Es gibt nur rechts einen Nachfolger.
-			return null;
+                    node = getNodeOfRightSuccessor();
-		} else {
+                }
-			ContentType content = this.getContent();
+            } else if (node.right.isEmpty()) {
-			if (pContent.isLess(content)) {
+                // Es gibt nur links einen Nachfolger.
-				// Element wird im linken Teilbaum gesucht.
+                node = getNodeOfLeftSuccessor();
-				return this.getLeftTree().search(pContent);
+            } else {
-			} else if (pContent.isGreater(content)) {
+                // Es gibt links und rechts einen Nachfolger.
-				// Element wird im rechten Teilbaum gesucht.
+                if (getNodeOfRightSuccessor().left.isEmpty()) {
-				return this.getRightTree().search(pContent);
+                    // Der rechte Nachfolger hat keinen linken Nachfolger.
-			} else if (pContent.isEqual(content)) {
+                    node.content = getNodeOfRightSuccessor().content;
-				// Element wurde gefunden.
+                    node.right = getNodeOfRightSuccessor().right;
-			  return content;
+                } else {
-			} else {
+                    BinarySearchTree<ContentType> previous = node.right
-			  // Dieser Fall sollte nicht auftreten.
+                        .ancestorOfSmallRight();
-				return null;
+                    BinarySearchTree<ContentType> smallest = previous.node.left;
-			}
+                    this.node.content = smallest.node.content;
-		}
+                    previous.remove(smallest.node.content);
-	}
+                }
+            }
+        }
+    }
 
-	/* ----------- Weitere private Methoden -------------- */
+    /**
+     * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
+     * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten ist,
+     * liefert die Anfrage dieses, ansonsten wird null zurueckgegeben. <br />
+     * Falls der Parameter null ist, wird null zurueckgegeben.
+     *
+     * @param pContent
+     *            zu suchendes Objekt vom Typ ContentType
+     * @return das gefundene Objekt vom Typ ContentType, bei erfolgloser Suche null
+     *
+     */
+    public ContentType search(ContentType pContent) {
+        if (this.isEmpty() || pContent == null) {
+            // Abbrechen, da es kein Element zu suchen gibt.
+            return null;
+        } else {
+            ContentType content = this.getContent();
+            if (pContent.isLess(content)) {
+                // Element wird im linken Teilbaum gesucht.
+                return this.getLeftTree().search(pContent);
+            } else if (pContent.isGreater(content)) {
+                // Element wird im rechten Teilbaum gesucht.
+                return this.getRightTree().search(pContent);
+            } else if (pContent.isEqual(content)) {
+                // Element wurde gefunden.
+                return content;
+            } else {
+                // Dieser Fall sollte nicht auftreten.
+                return null;
+            }
+        }
+    }
 
-	/**
+    /* ----------- Weitere private Methoden -------------- */
-	 * Die Methode liefert denjenigen Baum, dessen linker Nachfolger keinen linken
-	 * Nachfolger mehr hat. Es ist also spaeter moeglich, in einem Baum im
-	 * rechten Nachfolger den Vorgaenger des linkesten Nachfolgers zu finden.
-	 *
-	 */
-	private BinarySearchTree<ContentType> ancestorOfSmallRight() {
-		if (getNodeOfLeftSuccessor().left.isEmpty()) {
-			return this;
-		} else {
-			return node.left.ancestorOfSmallRight();
-		}
-	}
 
-	private BSTNode<ContentType> getNodeOfLeftSuccessor() {
+    /**
-		return node.left.node;
+     * Die Methode liefert denjenigen Baum, dessen linker Nachfolger keinen linken
-	}
+     * Nachfolger mehr hat. Es ist also spaeter moeglich, in einem Baum im
+     * rechten Nachfolger den Vorgaenger des linkesten Nachfolgers zu finden.
+     *
+     */
+    private BinarySearchTree<ContentType> ancestorOfSmallRight() {
+        if (getNodeOfLeftSuccessor().left.isEmpty()) {
+            return this;
+        } else {
+            return node.left.ancestorOfSmallRight();
+        }
+    }
 
-	private BSTNode<ContentType> getNodeOfRightSuccessor() {
+    private BSTNode<ContentType> getNodeOfLeftSuccessor() {
-		return node.right.node;
+        return node.left.node;
-	}
+    }
+
+    private BSTNode<ContentType> getNodeOfRightSuccessor() {
+        return node.right.node;
+    }
 
 }

Langlaufsimulator/Competition.ctxt

@@ -8,4 +8,6 @@ comment2.params=pName
 comment2.target=void\ newRunner(java.lang.String)
 comment3.params=
 comment3.target=void\ simulate()
-numComments=4
+comment4.params=
+comment4.target=Athlete[]\ top3()
+numComments=5

Langlaufsimulator/Competition.java

@@ -8,12 +8,16 @@
 public class Competition {
 
     private List<Athlete> runners;
+    private Racesimulator sim;
+    private BinarySearchTree leaderboard;
 
     /**
      * Konstruktor für Objekte der Klasse Competition
      */
     public Competition() {
-        // ggf. Instanzvariable initialisieren
+        runners = new List<Athlete>();
+        sim = new Racesimulator();
+        leaderboard = new BinarySearchTree();
     }
 
     public void newRunner(String pName){
@@ -23,10 +27,40 @@ public class Competition {
     }
 
     public void simulate(){
-
+        runners.toFirst();
+        while(runners.hasAccess()){
+            Athlete athlete = runners.getContent();
+            sim.simulate(athlete);
+            leaderboard.insert(athlete);
+            runners.next();
+        }
     }
 
-    // public Athlete top3(){
+    public Athlete[] top3(){
-
+        Athlete[] top = new Athlete[3];
-    //  }
+        List<Athlete> inOrder = leaderboard.getInOrder();
+        inOrder.toFirst();
+        top[0] = inOrder.getContent();
+        inOrder.next();
+        if (!inOrder.hasAccess()){
+            return top;
+        }
+        top[1] = inOrder.getContent();
+        inOrder.next();
+        if (!inOrder.hasAccess()){
+            return top;
+        }
+        top[2] = inOrder.getContent();
+        inOrder.next();
+        System.out.println(top[0].getFinalTime());
+        System.out.println(top[1].getFinalTime());
+        System.out.println(top[2].getFinalTime());
+        return top;
+    }
 }
+
+
+
+
+
+

Langlaufsimulator/Racesimulator.ctxt

@@ -4,4 +4,6 @@ comment0.text=\r\n\ Beschreiben\ Sie\ hier\ die\ Klasse\ Racesimulator.\r\n\ \r\
 comment1.params=
 comment1.target=Racesimulator()
 comment1.text=\r\n\ Konstruktor\ f\u00FCr\ Objekte\ der\ Klasse\ Racesimulator\r\n
-numComments=2
+comment2.params=pAthlete
+comment2.target=Athlete\ simulate(Athlete)
+numComments=3

Langlaufsimulator/Racesimulator.java

@@ -1,5 +1,5 @@
 
-
+import java.util.Random;
 /**
  * Beschreiben Sie hier die Klasse Racesimulator.
  * 
@@ -8,8 +8,7 @@
  */
 public class Racesimulator {
 
-    // Attribute
+    private Random random = new Random();
-    // Implementieren sie hier die Attribute der Klasse
 
     /**
      * Konstruktor für Objekte der Klasse Racesimulator
@@ -18,8 +17,10 @@ public class Racesimulator {
         // ggf. Instanzvariable initialisieren
     }
 
-  //  public Athlete simulate(Athlete pAthlete){
+    public Athlete simulate(Athlete pAthlete){
-   //     Random
+        pAthlete.setStartTime(0);
-  //  }
+        pAthlete.setEndTime(random.nextDouble());
-    
+        return pAthlete;
+    }
+
 }

Langlaufsimulator/package.bluej

@@ -2,28 +2,40 @@
 dependency1.from=BinarySearchTree
 dependency1.to=ComparableContent
 dependency1.type=UsesDependency
-dependency2.from=Competition
+dependency2.from=BinarySearchTree
 dependency2.to=List
 dependency2.type=UsesDependency
-dependency3.from=Competition
+dependency3.from=Racesimulator
 dependency3.to=Athlete
 dependency3.type=UsesDependency
-editor.fx.0.height=738
+dependency4.from=Competition
-editor.fx.0.width=816
+dependency4.to=List
-editor.fx.0.x=232
+dependency4.type=UsesDependency
-editor.fx.0.y=82
+dependency5.from=Competition
-objectbench.height=138
+dependency5.to=Athlete
+dependency5.type=UsesDependency
+dependency6.from=Competition
+dependency6.to=Racesimulator
+dependency6.type=UsesDependency
+dependency7.from=Competition
+dependency7.to=BinarySearchTree
+dependency7.type=UsesDependency
+editor.fx.0.height=1416
+editor.fx.0.width=2576
+editor.fx.0.x=-8
+editor.fx.0.y=-8
+objectbench.height=204
 objectbench.width=1256
 package.divider.horizontal=0.6
-package.divider.vertical=0.8390677025527192
+package.divider.vertical=0.7655555555555555
-package.editor.height=749
+package.editor.height=682
-package.editor.width=1132
+package.editor.width=1145
-package.editor.x=0
+package.editor.x=773
-package.editor.y=0
+package.editor.y=30
 package.frame.height=1000
 package.frame.width=1296
-package.numDependencies=3
+package.numDependencies=7
-package.numTargets=7
+package.numTargets=6
 package.showExtends=true
 package.showUses=true
 project.charset=UTF-8
@@ -37,47 +49,40 @@ target1.name=Competition
 target1.showInterface=false
 target1.type=ClassTarget
 target1.width=100
-target1.x=540
+target1.x=100
-target1.y=320
+target1.y=490
 target2.height=50
-target2.name=List$ListNode
+target2.name=List
 target2.showInterface=false
-target2.type=SubTargetClassRole
+target2.type=ClassTarget
-target2.width=200
+target2.width=150
-target2.x=250
+target2.x=900
-target2.y=210
+target2.y=170
 target3.height=50
-target3.name=List
+target3.name=Racesimulator
 target3.showInterface=false
 target3.type=ClassTarget
-target3.width=150
+target3.width=110
-target3.x=60
+target3.x=290
-target3.y=210
+target3.y=390
 target4.height=50
-target4.name=Racesimulator
+target4.name=ComparableContent
 target4.showInterface=false
-target4.type=ClassTarget
+target4.type=InterfaceTarget
-target4.width=110
+target4.width=250
-target4.x=540
+target4.x=80
-target4.y=200
+target4.y=30
-target5.height=50
+target5.height=110
-target5.name=ComparableContent
+target5.name=Athlete
 target5.showInterface=false
-target5.type=InterfaceTarget
+target5.type=ClassTarget
 target5.width=250
-target5.x=760
+target5.x=610
-target5.y=110
+target5.y=260
-target6.height=110
+target6.height=50
-target6.name=Athlete
+target6.name=BinarySearchTree
 target6.showInterface=false
 target6.type=ClassTarget
-target6.width=250
+target6.width=230
-target6.x=760
+target6.x=740
-target6.y=340
+target6.y=80
-target7.height=50
-target7.name=BinarySearchTree
-target7.showInterface=false
-target7.type=ClassTarget
-target7.width=230
-target7.x=70
-target7.y=10