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