Tim/Langlauf
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

works

Browse Source
This commit is contained in:
Asecave
2020-12-05 12:23:51 +01:00
parent 341f1fad94
commit d2cd58e2c3
4 changed files with 254 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
LangLauf/Athlete.java
View File

@@ -46,4 +46,9 @@ public class Athlete implements ComparableContent<Athlete> {
public boolean isLess(Athlete athlete) { public boolean isLess(Athlete athlete) {
return getFinalTime() < athlete.getFinalTime(); return getFinalTime() < athlete.getFinalTime();
} }
@Override
public String toString() {
return name;
}
} }

440
LangLauf/BinarySearchTree.java
View File

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

27
LangLauf/Competition.java
View File

@@ -1,20 +1,20 @@
public class Competition { public class Competition {
private List<Athlete> runners; private List<Athlete> runners;
private BinarySearchTree<Athlete> leaderboard; private BinarySearchTree<Athlete> leaderboard;
private RaceSimulator sim; private RaceSimulator sim;
public Competition() { public Competition() {
runners = new List<>(); runners = new List<>();
leaderboard = new BinarySearchTree<>(); leaderboard = new BinarySearchTree<>();
sim = new RaceSimulator(); sim = new RaceSimulator();
} }
public void newRunner(String name) { public void newRunner(String name) {
runners.append(new Athlete(name)); runners.append(new Athlete(name));
} }
public void simulate() { public void simulate() {
runners.toFirst(); runners.toFirst();
while (runners.hasAccess()) { while (runners.hasAccess()) {
@@ -22,13 +22,24 @@ public class Competition {
leaderboard.insert(runners.getContent()); leaderboard.insert(runners.getContent());
runners.next(); runners.next();
} }
leaderboard.printInOrder();
} }
public Athlete[] top3() { public Athlete[] top3() {
Athlete[] top = new Athlete[3]; Athlete[] top = new Athlete[3];
//TODO 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();
return top; return top;
} }
} }

5
LangLauf/TestCompetition.java
View File

@@ -18,6 +18,11 @@ public class TestCompetition {
competition.newRunner("a"); competition.newRunner("a");
competition.simulate(); competition.simulate();
Athlete[] top = competition.top3();
for (int i = 0; i < top.length; i++) {
System.out.println(top[i] + ": " + top[i].getFinalTime());
}
} }
} }