print hirarchical done
This commit is contained in:
Asecave
commit
88ebe634fd
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,34 @@
|
|||
#BlueJ class context
|
||||
comment0.target=BinaryTree
|
||||
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\ BinaryTree<ContentType>\r\n\ </p>\r\n\ <p>\r\n\ Mithilfe\ der\ generischen\ Klasse\ BinaryTree\ koennen\ beliebig\ viele\r\n\ Inhaltsobjekte\ vom\ Typ\ ContentType\ in\ einem\ Binaerbaum\ verwaltet\ werden.\ Ein\r\n\ Objekt\ der\ Klasse\ stellt\ entweder\ einen\ leeren\ Baum\ dar\ oder\ verwaltet\ ein\r\n\ Inhaltsobjekt\ sowie\ einen\ linken\ und\ einen\ rechten\ Teilbaum,\ die\ ebenfalls\r\n\ Objekte\ der\ generischen\ Klasse\ BinaryTree\ sind.\r\n\ </p>\r\n\ \r\n\ @author\ Qualitaets-\ und\ UnterstuetzungsAgentur\ -\ Landesinstitut\ fuer\ Schule\r\n\ @version\ Generisch_03\ 2014-03-01\r\n
|
||||
comment1.params=
|
||||
comment1.target=BinaryTree()
|
||||
comment1.text=\r\n\ Nach\ dem\ Aufruf\ des\ Konstruktors\ existiert\ ein\ leerer\ Binaerbaum.\r\n
|
||||
comment10.params=
|
||||
comment10.target=BinaryTree\ getRightTree()
|
||||
comment10.text=\r\n\ Diese\ Anfrage\ liefert\ den\ rechten\ Teilbaum\ des\ Binaerbaumes.\ Wenn\ der\r\n\ Binaerbaum\ (this)\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\ \r\n\ @return\ rechter\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\ oder\ null,\ wenn\r\n\ der\ aktuelle\ Binaerbaum\ (this)\ leer\ ist\r\n
|
||||
comment2.params=pContent
|
||||
comment2.target=BinaryTree(java.lang.Object)
|
||||
comment2.text=\r\n\ Wenn\ der\ Parameter\ pContent\ ungleich\ null\ ist,\ existiert\ nach\ dem\ Aufruf\r\n\ des\ Konstruktors\ der\ Binaerbaum\ und\ hat\ pContent\ als\ Inhaltsobjekt\ und\r\n\ zwei\ leere\ Teilbaeume.\ Falls\ der\ Parameter\ null\ ist,\ wird\ ein\ leerer\r\n\ Binaerbaum\ erzeugt.\r\n\ \r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ das\ Inhaltsobjekt\ des\ Wurzelknotens\ vom\ Typ\ ContentType\r\n
|
||||
comment3.params=pContent\ pLeftTree\ pRightTree
|
||||
comment3.target=BinaryTree(java.lang.Object,\ BinaryTree,\ BinaryTree)
|
||||
comment3.text=\r\n\ Wenn\ der\ Parameter\ pContent\ ungleich\ null\ ist,\ wird\ ein\ Binaerbaum\ mit\r\n\ pContent\ als\ Inhalt\ und\ den\ beiden\ Teilbaeume\ pLeftTree\ und\ pRightTree\r\n\ erzeugt.\ Sind\ pLeftTree\ oder\ pRightTree\ gleich\ null,\ wird\ der\r\n\ entsprechende\ Teilbaum\ als\ leerer\ Binaerbaum\ eingefuegt.\ So\ kann\ es\ also\r\n\ nie\ passieren,\ dass\ linke\ oder\ rechte\ Teilbaeume\ null\ sind.\ Wenn\ der\r\n\ Parameter\ pContent\ gleich\ null\ ist,\ wird\ ein\ leerer\ Binaerbaum\ erzeugt.\r\n\ \r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ das\ Inhaltsobjekt\ des\ Wurzelknotens\ vom\ Typ\ ContentType\r\n\ @param\ pLeftTree\r\n\ \ \ \ \ \ \ \ \ \ \ \ der\ linke\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\r\n\ @param\ pRightTree\r\n\ \ \ \ \ \ \ \ \ \ \ \ der\ rechte\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\r\n
|
||||
comment4.params=
|
||||
comment4.target=boolean\ isEmpty()
|
||||
comment4.text=\r\n\ Diese\ Anfrage\ liefert\ den\ Wahrheitswert\ true,\ wenn\ der\ Binaerbaum\ leer\r\n\ ist,\ sonst\ liefert\ sie\ den\ Wert\ false.\r\n\ \r\n\ @return\ true,\ wenn\ der\ Binaerbaum\ leer\ ist,\ sonst\ false\r\n
|
||||
comment5.params=pContent
|
||||
comment5.target=void\ setContent(java.lang.Object)
|
||||
comment5.text=\r\n\ Wenn\ pContent\ null\ ist,\ geschieht\ nichts.\ <br\ />\r\n\ Ansonsten\:\ Wenn\ der\ Binaerbaum\ leer\ ist,\ wird\ der\ Parameter\ pContent\ als\r\n\ Inhaltsobjekt\ sowie\ ein\ leerer\ linker\ und\ rechter\ Teilbaum\ eingefuegt.\r\n\ Ist\ der\ Binaerbaum\ nicht\ leer,\ wird\ das\ Inhaltsobjekt\ durch\ pContent\r\n\ ersetzt.\ Die\ Teilbaeume\ werden\ nicht\ geaendert.\r\n\ \r\n\ @param\ pContent\r\n\ \ \ \ \ \ \ \ \ \ \ \ neues\ Inhaltsobjekt\ vom\ Typ\ ContentType\r\n
|
||||
comment6.params=
|
||||
comment6.target=java.lang.Object\ getContent()
|
||||
comment6.text=\r\n\ Diese\ Anfrage\ liefert\ das\ Inhaltsobjekt\ des\ Binaerbaums.\ Wenn\ der\r\n\ Binaerbaum\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\ \r\n\ @return\ das\ Inhaltsobjekt\ der\ Wurzel\ vom\ Typ\ ContentType\ bzw.\ null,\ wenn\r\n\ \ \ \ \ \ \ \ \ der\ Binaerbaum\ leer\ ist\r\n
|
||||
comment7.params=pTree
|
||||
comment7.target=void\ setLeftTree(BinaryTree)
|
||||
comment7.text=\r\n\ Falls\ der\ Parameter\ null\ ist,\ geschieht\ nichts.\ Wenn\ der\ Binaerbaum\ leer\r\n\ ist,\ wird\ pTree\ nicht\ angehaengt.\ Andernfalls\ erhaelt\ der\ Binaerbaum\ den\r\n\ uebergebenen\ BinaryTree\ als\ linken\ Teilbaum.\r\n\ \r\n\ @param\ pTree\r\n\ \ \ \ \ \ \ \ \ \ \ \ neuer\ linker\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\r\n
|
||||
comment8.params=pTree
|
||||
comment8.target=void\ setRightTree(BinaryTree)
|
||||
comment8.text=\r\n\ Falls\ der\ Parameter\ null\ ist,\ geschieht\ nichts.\ Wenn\ der\ Binaerbaum\ leer\r\n\ ist,\ wird\ pTree\ nicht\ angehaengt.\ Andernfalls\ erhaelt\ der\ Binaerbaum\ den\r\n\ uebergebenen\ BinaryTree\ als\ rechten\ Teilbaum.\r\n\ \r\n\ @param\ pTree\r\n\ \ \ \ \ \ \ \ \ \ \ \ neuer\ linker\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\r\n
|
||||
comment9.params=
|
||||
comment9.target=BinaryTree\ getLeftTree()
|
||||
comment9.text=\r\n\ Diese\ Anfrage\ liefert\ den\ linken\ Teilbaum\ des\ Binaerbaumes.\ Wenn\ der\r\n\ Binaerbaum\ leer\ ist,\ wird\ null\ zurueckgegeben.\r\n\ \r\n\ @return\ linker\ Teilbaum\ vom\ Typ\ BinaryTree<ContentType>\ oder\ null,\ wenn\r\n\ der\ aktuelle\ Binaerbaum\ leer\ ist\r\n
|
||||
numComments=11
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
/**
|
||||
* <p>
|
||||
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
|
||||
* </p>
|
||||
* <p>
|
||||
* Generische Klasse BinaryTree<ContentType>
|
||||
* </p>
|
||||
* <p>
|
||||
* Mithilfe der generischen Klasse BinaryTree koennen beliebig viele
|
||||
* Inhaltsobjekte vom Typ ContentType in einem Binaerbaum verwaltet werden. Ein
|
||||
* Objekt der Klasse stellt entweder einen leeren Baum dar oder verwaltet ein
|
||||
* Inhaltsobjekt sowie einen linken und einen rechten Teilbaum, die ebenfalls
|
||||
* Objekte der generischen Klasse BinaryTree sind.
|
||||
* </p>
|
||||
*
|
||||
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
|
||||
* @version Generisch_03 2014-03-01
|
||||
*/
|
||||
public class BinaryTree<ContentType> {
|
||||
|
||||
/* --------- Anfang der privaten inneren Klasse -------------- */
|
||||
|
||||
/**
|
||||
* 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
|
||||
* nicht-null-Teilbaeume, ggf. leere Teilbaeume hat.
|
||||
*/
|
||||
private class BTNode<CT> {
|
||||
|
||||
private CT content;
|
||||
private BinaryTree<CT> left, right;
|
||||
|
||||
public BTNode(CT pContent) {
|
||||
// Der Knoten hat einen linken und einen rechten Teilbaum, die
|
||||
// beide von null verschieden sind. Also hat ein Blatt immer zwei
|
||||
// leere Teilbaeume unter sich.
|
||||
this.content = pContent;
|
||||
left = new BinaryTree<CT>();
|
||||
right = new BinaryTree<CT>();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ----------- Ende der privaten inneren Klasse -------------- */
|
||||
|
||||
private BTNode<ContentType> node;
|
||||
|
||||
/**
|
||||
* Nach dem Aufruf des Konstruktors existiert ein leerer Binaerbaum.
|
||||
*/
|
||||
public BinaryTree() {
|
||||
this.node = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, existiert nach dem Aufruf
|
||||
* des Konstruktors der Binaerbaum und hat pContent als Inhaltsobjekt und
|
||||
* zwei leere Teilbaeume. Falls der Parameter null ist, wird ein leerer
|
||||
* Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent
|
||||
* das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
*/
|
||||
public BinaryTree(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode<ContentType>(pContent);
|
||||
} else {
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn der Parameter pContent ungleich null ist, wird ein Binaerbaum mit
|
||||
* pContent als Inhalt und den beiden Teilbaeume pLeftTree und pRightTree
|
||||
* erzeugt. Sind pLeftTree oder pRightTree gleich null, wird der
|
||||
* entsprechende Teilbaum als leerer Binaerbaum eingefuegt. So kann es also
|
||||
* nie passieren, dass linke oder rechte Teilbaeume null sind. Wenn der
|
||||
* Parameter pContent gleich null ist, wird ein leerer Binaerbaum erzeugt.
|
||||
*
|
||||
* @param pContent
|
||||
* das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
|
||||
* @param pLeftTree
|
||||
* der linke Teilbaum vom Typ BinaryTree<ContentType>
|
||||
* @param pRightTree
|
||||
* der rechte Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public BinaryTree(ContentType pContent, BinaryTree<ContentType> pLeftTree, BinaryTree<ContentType> pRightTree) {
|
||||
if (pContent != null) {
|
||||
this.node = new BTNode<ContentType>(pContent);
|
||||
if (pLeftTree != null) {
|
||||
this.node.left = pLeftTree;
|
||||
} else {
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
}
|
||||
if (pRightTree != null) {
|
||||
this.node.right = pRightTree;
|
||||
} else {
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
} else {
|
||||
// Da der Inhalt null ist, wird ein leerer BinarySearchTree erzeugt.
|
||||
this.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den Wahrheitswert true, wenn der Binaerbaum leer
|
||||
* ist, sonst liefert sie den Wert false.
|
||||
*
|
||||
* @return true, wenn der Binaerbaum leer ist, sonst false
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return this.node == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wenn pContent null ist, geschieht nichts. <br />
|
||||
* Ansonsten: Wenn der Binaerbaum leer ist, wird der Parameter pContent als
|
||||
* Inhaltsobjekt sowie ein leerer linker und rechter Teilbaum eingefuegt.
|
||||
* Ist der Binaerbaum nicht leer, wird das Inhaltsobjekt durch pContent
|
||||
* ersetzt. Die Teilbaeume werden nicht geaendert.
|
||||
*
|
||||
* @param pContent
|
||||
* neues Inhaltsobjekt vom Typ ContentType
|
||||
*/
|
||||
public void setContent(ContentType pContent) {
|
||||
if (pContent != null) {
|
||||
if (this.isEmpty()) {
|
||||
node = new BTNode<ContentType>(pContent);
|
||||
this.node.left = new BinaryTree<ContentType>();
|
||||
this.node.right = new BinaryTree<ContentType>();
|
||||
}
|
||||
this.node.content = pContent;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert das Inhaltsobjekt des Binaerbaums. Wenn der
|
||||
* Binaerbaum leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return das Inhaltsobjekt der Wurzel vom Typ ContentType bzw. null, wenn
|
||||
* der Binaerbaum leer ist
|
||||
*/
|
||||
public ContentType getContent() {
|
||||
if (this.isEmpty()) {
|
||||
return null;
|
||||
} else {
|
||||
return this.node.content;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
|
||||
* ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als linken Teilbaum.
|
||||
*
|
||||
* @param pTree
|
||||
* neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setLeftTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.left = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
|
||||
* ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
|
||||
* uebergebenen BinaryTree als rechten Teilbaum.
|
||||
*
|
||||
* @param pTree
|
||||
* neuer linker Teilbaum vom Typ BinaryTree<ContentType>
|
||||
*/
|
||||
public void setRightTree(BinaryTree<ContentType> pTree) {
|
||||
if (!this.isEmpty() && pTree != null) {
|
||||
this.node.right = pTree;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den linken Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return linker Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
|
||||
* der aktuelle Binaerbaum leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getLeftTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.left;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Diese Anfrage liefert den rechten Teilbaum des Binaerbaumes. Wenn der
|
||||
* Binaerbaum (this) leer ist, wird null zurueckgegeben.
|
||||
*
|
||||
* @return rechter Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
|
||||
* der aktuelle Binaerbaum (this) leer ist
|
||||
*/
|
||||
public BinaryTree<ContentType> getRightTree() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.node.right;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
------------------------------------------------------------------------
|
||||
Dies ist die README-Datei des Projekts. Hier sollten Sie Ihr Projekt
|
||||
beschreiben.
|
||||
Erzählen Sie dem Leser (jemand, der nichts über dieses Projekt weiss),
|
||||
alles, was er/sie wissen muss. Üblicherweise sollte der Kommentar
|
||||
zumindest die folgenden Angaben umfassen:
|
||||
------------------------------------------------------------------------
|
||||
|
||||
PROJEKTBEZEICHNUNG:
|
||||
PROJEKTZWECK:
|
||||
VERSION oder DATUM:
|
||||
WIE IST DAS PROJEKT ZU STARTEN:
|
||||
AUTOR(EN):
|
||||
BENUTZERHINWEISE:
|
||||
Binary file not shown.
|
|
@ -0,0 +1,36 @@
|
|||
#BlueJ class context
|
||||
comment0.target=Traversierungen
|
||||
comment0.text=\r\n\ Implementierungen\ der\ drei\ Traversierungsarten\ auf\r\n\ Bin\u00E4rb\u00E4umen\ mit\ Zahl-Inhalten.\r\n
|
||||
comment1.params=
|
||||
comment1.target=Traversierungen()
|
||||
comment10.params=pRoot
|
||||
comment10.target=void\ inorder(BinaryTree)
|
||||
comment10.text=\r\n\ Rekursive\ Methode\ f\u00FCr\ die\ Inorder-Traversierung.\r\n\ @param\ pRoot\ Der\ Wurzelknoten\ des\ aktuellen\ Teilbaumes.\r\n
|
||||
comment11.params=
|
||||
comment11.target=int\ findMax()
|
||||
comment11.text=\r\n\ Findet\ das\ Maximum\ im\ Baum.\r\n
|
||||
comment12.params=pNum
|
||||
comment12.target=void\ add(int)
|
||||
comment12.text=\r\n\ Addiert\ pNum\ zu\ jedem\ Wert\ im\ Bin\u00E4rbaum.\r\n
|
||||
comment2.params=
|
||||
comment2.target=void\ preorder()
|
||||
comment2.text=\r\n\ Aufruf\ f\u00FCr\ die\ Preorder-Traversierung.\r\n\r\n\ @see\ \#preorder(BinaryTree)\r\n
|
||||
comment3.params=pRoot
|
||||
comment3.target=void\ preorder(BinaryTree)
|
||||
comment3.text=\r\n\ Rekursive\ Methode\ f\u00FCr\ die\ Preorder-Traversierung.\r\n\ @param\ pRoot\ Der\ Wurzelknoten\ des\ aktuellen\ Teilbaumes.\r\n
|
||||
comment4.params=
|
||||
comment4.target=void\ printHirarchical()
|
||||
comment5.params=pRoot\ xOff
|
||||
comment5.target=void\ printHirarchical(BinaryTree,\ int)
|
||||
comment6.params=off
|
||||
comment6.target=void\ printOffset(int)
|
||||
comment7.params=
|
||||
comment7.target=void\ postorder()
|
||||
comment7.text=\r\n\ Aufruf\ f\u00FCr\ die\ Postorder-Traversierung.\r\n\r\n\ @see\ \#postorder(BinaryTree)\r\n
|
||||
comment8.params=pRoot
|
||||
comment8.target=void\ postorder(BinaryTree)
|
||||
comment8.text=\r\n\ Rekursive\ Methode\ f\u00FCr\ die\ Postorder-Traversierung.\r\n\ @param\ pRoot\ Der\ Wurzelknoten\ des\ aktuellen\ Teilbaumes.\r\n
|
||||
comment9.params=
|
||||
comment9.target=void\ inorder()
|
||||
comment9.text=\r\n\ Aufruf\ f\u00FCr\ die\ Inorder-Traversierung.\r\n\r\n\ @see\ \#inorder(BinaryTree)\r\n
|
||||
numComments=13
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* Implementierungen der drei Traversierungsarten auf
|
||||
* Binärbäumen mit Zahl-Inhalten.
|
||||
*/
|
||||
public class Traversierungen {
|
||||
|
||||
private BinaryTree<Integer> root;
|
||||
|
||||
public Traversierungen() {
|
||||
// Erstellen eines Integer-Baumes mit
|
||||
// 15 Knoten
|
||||
// 0.5 Prozent der Knoten werden im linken Teilbaum generiert
|
||||
// wobei zufällig ca. 20 Prozent der Knoten doch rechts einsortiert werden
|
||||
root = Trees.generateIntegerTree(3, 0.5, 10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Aufruf für die Preorder-Traversierung.
|
||||
*
|
||||
* @see #preorder(BinaryTree)
|
||||
*/
|
||||
public void preorder() {
|
||||
preorder(root);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rekursive Methode für die Preorder-Traversierung.
|
||||
* @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
|
||||
*/
|
||||
public void preorder( BinaryTree<Integer> pRoot ) {
|
||||
// TODO: Ausgabe das Baumes auf der Kommandozeile in Preorder
|
||||
}
|
||||
|
||||
public void printHirarchical() {
|
||||
printHirarchical(root, 0);
|
||||
}
|
||||
|
||||
public void printHirarchical(BinaryTree<Integer> pRoot, int xOff) {
|
||||
if (pRoot.getContent() == null) {
|
||||
xOff--;
|
||||
return;
|
||||
}
|
||||
if (pRoot.getLeftTree() != null) {
|
||||
printOffset(xOff);
|
||||
System.out.println(pRoot.getContent());
|
||||
xOff++;
|
||||
printHirarchical(pRoot.getLeftTree(), xOff);
|
||||
}
|
||||
if (pRoot.getRightTree() != null) {
|
||||
printOffset(xOff);
|
||||
System.out.println(pRoot.getContent());
|
||||
xOff++;
|
||||
printHirarchical(pRoot.getRightTree(), xOff);
|
||||
}
|
||||
}
|
||||
|
||||
private void printOffset(int off) {
|
||||
for (int i = 0; i < off; i++) {
|
||||
if (i == off - 1) {
|
||||
System.out.print("|> ");
|
||||
} else {
|
||||
System.out.print("| ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Aufruf für die Postorder-Traversierung.
|
||||
*
|
||||
* @see #postorder(BinaryTree)
|
||||
*/
|
||||
public void postorder() {
|
||||
postorder(root);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rekursive Methode für die Postorder-Traversierung.
|
||||
* @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
|
||||
*/
|
||||
public void postorder( BinaryTree<Integer> pRoot ) {
|
||||
// TODO: Ausgabe das Baumes auf der Kommandozeile in Postorder
|
||||
}
|
||||
|
||||
/**
|
||||
* Aufruf für die Inorder-Traversierung.
|
||||
*
|
||||
* @see #inorder(BinaryTree)
|
||||
*/
|
||||
public void inorder() {
|
||||
inorder(root);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rekursive Methode für die Inorder-Traversierung.
|
||||
* @param pRoot Der Wurzelknoten des aktuellen Teilbaumes.
|
||||
*/
|
||||
public void inorder( BinaryTree<Integer> pRoot ) {
|
||||
// TODO: Ausgabe das Baumes auf der Kommandozeile in Inorder
|
||||
}
|
||||
|
||||
/**
|
||||
* Findet das Maximum im Baum.
|
||||
*/
|
||||
public int findMax() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Addiert pNum zu jedem Wert im Binärbaum.
|
||||
*/
|
||||
public void add( int pNum ) {
|
||||
|
||||
}
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,48 @@
|
|||
#BlueJ class context
|
||||
comment0.target=Trees
|
||||
comment0.text=\r\n\ Eine\ Sammlung\ von\ Klassenmethoden,\ um\ wiederkehrende\r\n\ Aufgaben\ mit\ bin\u00E4ren\ B\u00E4umen\ zu\ vereinfachen.\r\n\ @version\ 0.1\ (2019-09-13)\r\n\ @author\ J.\ Neugebauer\ <schule@neugebauer.cc>\r\n
|
||||
comment1.params=pRoot
|
||||
comment1.target=int\ getMaxDepth(BinaryTree)
|
||||
comment10.params=pRoot\ pOut
|
||||
comment10.target=void\ printPostorder(BinaryTree,\ java.io.PrintStream)
|
||||
comment11.params=pRoot
|
||||
comment11.target=void\ printInorder(BinaryTree)
|
||||
comment12.params=pRoot\ pOut
|
||||
comment12.target=void\ printInorder(BinaryTree,\ java.io.PrintStream)
|
||||
comment13.params=pNodeCount\ pMinValue\ pMaxValue
|
||||
comment13.target=BinaryTree\ generateBalancedIntegerTree(int,\ int,\ int)
|
||||
comment14.params=pDepth\ pMinValue\ pMaxValue
|
||||
comment14.target=BinaryTree\ generateCompleteIntegerTree(int,\ int,\ int)
|
||||
comment15.params=pNodeCount\ pWeight\ pUncertainty
|
||||
comment15.target=BinaryTree\ generateIntegerTree(int,\ double,\ double)
|
||||
comment16.params=pNodeCount\ pMinValue\ pMaxValue\ pWeight\ pUncertainty
|
||||
comment16.target=BinaryTree\ generateIntegerTree(int,\ int,\ int,\ double,\ double)
|
||||
comment17.params=
|
||||
comment17.target=java.lang.Integer\ call()
|
||||
comment18.params=pNodeCount\ pWeight\ pUncertainty
|
||||
comment18.target=BinaryTree\ generateStringTree(int,\ double,\ double)
|
||||
comment19.params=pNodeCount\ pWords\ pWeight\ pUncertainty
|
||||
comment19.target=BinaryTree\ generateStringTree(int,\ java.lang.String[],\ double,\ double)
|
||||
comment2.params=pRoot
|
||||
comment2.target=int\ countNodes(BinaryTree)
|
||||
comment20.params=
|
||||
comment20.target=java.lang.String\ call()
|
||||
comment21.params=pNodeCount\ pGenerator\ pWeight\ pUncertainty
|
||||
comment21.target=BinaryTree\ generateTree(int,\ java.util.concurrent.Callable,\ double,\ double)
|
||||
comment22.params=pRoot\ pNodeCount\ pGenerator\ pWeight\ pUncertainty
|
||||
comment22.target=BinaryTree\ generateTree(BinaryTree,\ int,\ java.util.concurrent.Callable,\ double,\ double)
|
||||
comment3.params=pRoot
|
||||
comment3.target=int\ countLeaves(BinaryTree)
|
||||
comment4.params=pRoot
|
||||
comment4.target=void\ printPretty(BinaryTree)
|
||||
comment5.params=pRoot\ pOut
|
||||
comment5.target=void\ printPretty(BinaryTree,\ java.io.PrintStream)
|
||||
comment6.params=pRoot\ prefix\ isTail\ sb
|
||||
comment6.target=java.lang.StringBuilder\ printPretty(BinaryTree,\ java.lang.StringBuilder,\ boolean,\ java.lang.StringBuilder)
|
||||
comment7.params=pRoot
|
||||
comment7.target=void\ printPreorder(BinaryTree)
|
||||
comment8.params=pRoot\ pOut
|
||||
comment8.target=void\ printPreorder(BinaryTree,\ java.io.PrintStream)
|
||||
comment9.params=pRoot
|
||||
comment9.target=void\ printPostorder(BinaryTree)
|
||||
numComments=23
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
import java.io.PrintStream;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.Callable;
|
||||
|
||||
/**
|
||||
* Eine Sammlung von Klassenmethoden, um wiederkehrende
|
||||
* Aufgaben mit binären Bäumen zu vereinfachen.
|
||||
* @version 0.1 (2019-09-13)
|
||||
* @author J. Neugebauer <schule@neugebauer.cc>
|
||||
*/
|
||||
public class Trees {
|
||||
|
||||
public static <T> int getMaxDepth( BinaryTree<T> pRoot ) {
|
||||
if( pRoot.isEmpty() ) {
|
||||
return 0;
|
||||
}
|
||||
return 1 + Math.max(
|
||||
getMaxDepth( pRoot.getLeftTree() ),
|
||||
getMaxDepth( pRoot.getRightTree() )
|
||||
);
|
||||
}
|
||||
|
||||
public static <T> int countNodes( BinaryTree<T> pRoot ) {
|
||||
if( pRoot.isEmpty() ) {
|
||||
return 0;
|
||||
}
|
||||
return 1 + countNodes( pRoot.getLeftTree() ) + countNodes( pRoot.getRightTree() );
|
||||
}
|
||||
|
||||
public static <T> int countLeaves( BinaryTree<T> pRoot ) {
|
||||
if( pRoot.isEmpty() ) {
|
||||
return 0;
|
||||
} else if( pRoot.getLeftTree().isEmpty() && pRoot.getRightTree().isEmpty() ) {
|
||||
return 1;
|
||||
}
|
||||
return countLeaves( pRoot.getLeftTree() ) + countLeaves( pRoot.getRightTree() );
|
||||
}
|
||||
|
||||
public static <T> void printPretty( BinaryTree<T> pRoot ) {
|
||||
printPretty(pRoot, System.out);
|
||||
}
|
||||
|
||||
public static <T> void printPretty( BinaryTree<T> pRoot, PrintStream pOut ) {
|
||||
pOut.print(printPretty(pRoot, new StringBuilder(), true, new StringBuilder()).toString());
|
||||
}
|
||||
|
||||
// Adapted from https://stackoverflow.com/a/27153988/10921408
|
||||
private static <T> StringBuilder printPretty( BinaryTree<T> pRoot, StringBuilder prefix, boolean isTail, StringBuilder sb) {
|
||||
if( !pRoot.getRightTree().isEmpty() ) {
|
||||
printPretty(pRoot.getRightTree(), new StringBuilder().append(prefix).append(isTail ? "│ " : " "), false, sb);
|
||||
}
|
||||
sb.append(prefix).append(isTail ? "└── " : "┌── ").append(pRoot.getContent().toString()).append("\n");
|
||||
if( !pRoot.getLeftTree().isEmpty() ) {
|
||||
printPretty(pRoot.getLeftTree(), new StringBuilder().append(prefix).append(isTail ? " " : "│ "), true, sb);
|
||||
}
|
||||
return sb;
|
||||
}
|
||||
|
||||
public static <T> void printPreorder( BinaryTree<T> pRoot ) {
|
||||
printPreorder(pRoot, System.out);
|
||||
}
|
||||
|
||||
public static <T> void printPreorder( BinaryTree<T> pRoot, PrintStream pOut ) {
|
||||
if( pRoot.getContent() == null ) {
|
||||
return;
|
||||
}
|
||||
|
||||
pOut.print(pRoot.getContent().toString() + ",");
|
||||
printPreorder(pRoot.getLeftTree(), pOut);
|
||||
printPreorder(pRoot.getRightTree(), pOut);
|
||||
}
|
||||
|
||||
public static <T> void printPostorder( BinaryTree<T> pRoot ) {
|
||||
printPostorder(pRoot, System.out);
|
||||
}
|
||||
|
||||
public static <T> void printPostorder( BinaryTree<T> pRoot, PrintStream pOut ) {
|
||||
if( pRoot.getContent() == null ) {
|
||||
return;
|
||||
}
|
||||
|
||||
pOut.print(pRoot.getContent().toString() + ",");
|
||||
printPostorder(pRoot.getLeftTree(), pOut);
|
||||
printPostorder(pRoot.getRightTree(), pOut);
|
||||
}
|
||||
|
||||
public static <T> void printInorder( BinaryTree<T> pRoot ) {
|
||||
printInorder(pRoot, System.out);
|
||||
}
|
||||
|
||||
public static <T> void printInorder( BinaryTree<T> pRoot, PrintStream pOut ) {
|
||||
if( pRoot.getContent() == null ) {
|
||||
return;
|
||||
}
|
||||
|
||||
pOut.print(pRoot.getContent().toString() + ",");
|
||||
printInorder(pRoot.getLeftTree(), pOut);
|
||||
printInorder(pRoot.getRightTree(), pOut);
|
||||
}
|
||||
|
||||
public static BinaryTree<Integer> generateBalancedIntegerTree( int pNodeCount, int pMinValue, int pMaxValue ) {
|
||||
return generateIntegerTree(pNodeCount, pMinValue, pMaxValue, 0.5, 0.0);
|
||||
}
|
||||
|
||||
public static BinaryTree<Integer> generateCompleteIntegerTree( int pDepth, int pMinValue, int pMaxValue ) {
|
||||
return generateBalancedIntegerTree((int)Math.pow(2,pDepth)-1, pMinValue, pMaxValue);
|
||||
}
|
||||
|
||||
public static BinaryTree<Integer> generateIntegerTree( int pNodeCount, double pWeight, double pUncertainty ) {
|
||||
return generateIntegerTree(pNodeCount, 0, 100, pWeight, pUncertainty);
|
||||
}
|
||||
|
||||
public static BinaryTree<Integer> generateIntegerTree( int pNodeCount, int pMinValue, int pMaxValue, double pWeight, double pUncertainty ) {
|
||||
final Random rand = new Random();
|
||||
return generateTree(pNodeCount, new Callable<Integer>() {
|
||||
@Override
|
||||
public Integer call() throws Exception {
|
||||
return new Integer(rand.nextInt(pMaxValue-pMinValue)+pMinValue);
|
||||
}
|
||||
}, pWeight, pUncertainty);
|
||||
}
|
||||
|
||||
public static BinaryTree<String> generateStringTree( int pNodeCount, double pWeight, double pUncertainty ) {
|
||||
return generateStringTree(pNodeCount, new String[]{"Jonas", "Martin", "Harald", "Sabine", "Feline", "Kathrin"}, pWeight, pUncertainty);
|
||||
}
|
||||
|
||||
public static BinaryTree<String> generateStringTree( int pNodeCount, final String[] pWords, double pWeight, double pUncertainty ) {
|
||||
final Random rand = new Random();
|
||||
return generateTree(pNodeCount, new Callable<String>() {
|
||||
@Override
|
||||
public String call() throws Exception {
|
||||
return pWords[rand.nextInt(pWords.length)];
|
||||
}
|
||||
}, pWeight, pUncertainty);
|
||||
}
|
||||
|
||||
public static <T> BinaryTree<T> generateTree( int pNodeCount, Callable<T> pGenerator, double pWeight, double pUncertainty ) {
|
||||
return generateTree(new BinaryTree<T>(), pNodeCount, pGenerator, pWeight, pUncertainty);
|
||||
}
|
||||
|
||||
public static <T> BinaryTree<T> generateTree( BinaryTree<T> pRoot, int pNodeCount, Callable<T> pGenerator, double pWeight, double pUncertainty ) {
|
||||
if( pNodeCount > 0 ) {
|
||||
try {
|
||||
pRoot.setContent(pGenerator.call());
|
||||
} catch( Exception ex ) {
|
||||
return pRoot;
|
||||
}
|
||||
|
||||
|
||||
double weight = pWeight + (pUncertainty - (Math.random() * pUncertainty * 2));
|
||||
weight = Math.min(1.0, Math.max(0.0, weight));
|
||||
int leftCount = (int) (pNodeCount * weight);
|
||||
int rightCount = pNodeCount - leftCount - 1;
|
||||
|
||||
generateTree(pRoot.getLeftTree(), leftCount, pGenerator, pWeight, pUncertainty);
|
||||
generateTree(pRoot.getRightTree(), rightCount, pGenerator, pWeight, pUncertainty);
|
||||
}
|
||||
return pRoot;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#BlueJ package file
|
||||
dependency1.from=Trees
|
||||
dependency1.to=BinaryTree
|
||||
dependency1.type=UsesDependency
|
||||
dependency2.from=Traversierungen
|
||||
dependency2.to=BinaryTree
|
||||
dependency2.type=UsesDependency
|
||||
dependency3.from=Traversierungen
|
||||
dependency3.to=Trees
|
||||
dependency3.type=UsesDependency
|
||||
editor.fx.0.height=1026
|
||||
editor.fx.0.width=1696
|
||||
editor.fx.0.x=-8
|
||||
editor.fx.0.y=-8
|
||||
objectbench.height=130
|
||||
objectbench.width=1656
|
||||
package.divider.horizontal=0.6
|
||||
package.divider.vertical=0.8520518358531317
|
||||
package.editor.height=782
|
||||
package.editor.width=1545
|
||||
package.editor.x=0
|
||||
package.editor.y=0
|
||||
package.frame.height=1026
|
||||
package.frame.width=1696
|
||||
package.numDependencies=3
|
||||
package.numTargets=3
|
||||
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=Traversierungen
|
||||
target1.showInterface=false
|
||||
target1.type=ClassTarget
|
||||
target1.width=130
|
||||
target1.x=140
|
||||
target1.y=200
|
||||
target2.height=50
|
||||
target2.name=Trees
|
||||
target2.showInterface=false
|
||||
target2.type=ClassTarget
|
||||
target2.width=80
|
||||
target2.x=680
|
||||
target2.y=290
|
||||
target3.height=50
|
||||
target3.name=BinaryTree
|
||||
target3.showInterface=false
|
||||
target3.type=ClassTarget
|
||||
target3.width=190
|
||||
target3.x=390
|
||||
target3.y=130
|
||||
Loading…
Reference in New Issue