From 88ebe634fd3b406f4fcf31afbf07d96b6fb61789 Mon Sep 17 00:00:00 2001 From: Asecave <39377667+Asecave@users.noreply.github.com> Date: Wed, 18 Nov 2020 20:02:27 +0100 Subject: [PATCH] print hirarchical done --- BinaryTree$BTNode.class | Bin 0 -> 826 bytes BinaryTree.class | Bin 0 -> 2618 bytes BinaryTree.ctxt | 34 +++++++ BinaryTree.java | 210 ++++++++++++++++++++++++++++++++++++++++ README.TXT | 14 +++ Traversierungen.class | Bin 0 -> 2205 bytes Traversierungen.ctxt | 36 +++++++ Traversierungen.java | 116 ++++++++++++++++++++++ Trees$1.class | Bin 0 -> 1032 bytes Trees$2.class | Bin 0 -> 988 bytes Trees.class | Bin 0 -> 6613 bytes Trees.ctxt | 48 +++++++++ Trees.java | 161 ++++++++++++++++++++++++++++++ package.bluej | 55 +++++++++++ 14 files changed, 674 insertions(+) create mode 100644 BinaryTree$BTNode.class create mode 100644 BinaryTree.class create mode 100644 BinaryTree.ctxt create mode 100644 BinaryTree.java create mode 100644 README.TXT create mode 100644 Traversierungen.class create mode 100644 Traversierungen.ctxt create mode 100644 Traversierungen.java create mode 100644 Trees$1.class create mode 100644 Trees$2.class create mode 100644 Trees.class create mode 100644 Trees.ctxt create mode 100644 Trees.java create mode 100644 package.bluej diff --git a/BinaryTree$BTNode.class b/BinaryTree$BTNode.class new file mode 100644 index 0000000000000000000000000000000000000000..5355fc8529d8dbb6d4681e47ab853f264a77e93d GIT binary patch literal 826 zcmZWn+iuf95IyTSbz%%j69|-R3rXv^rR5EYM0uzs1X2_pYDMDF2}|nA*p=-d^#k}I z9->Mh@d11k;%wa3foSEOnKNf+=6Lt_pC7*fyvEBaDrlRiqNBWB1A8X)Jg^ngHQ*T7 z7ci!Al*uR)XbjK%ul`Z!N3)|3lQTKZdIHsxU>5n=Jdpyr=X!+nP<|%e8XgCcpImr} zltddVVP6pk1j|V`8jP4HeBX}Hag z6>s7?V-_#sdR;%v|;1^GN*Cx-~k@dD(^7|)$oLVi#E?aRjFl8jh>5mMp?PH&Du)V SbG%qu9S>W3)){Z;Hf+S literal 0 HcmV?d00001 diff --git a/BinaryTree.class b/BinaryTree.class new file mode 100644 index 0000000000000000000000000000000000000000..38ea73b7fc9ed57796322dd264122c4b527e9cf0 GIT binary patch literal 2618 zcmb_e+fN*26#sp@v-epR3Z*~=MNyaKW+_(f0#ay6OaPOzX`#l;fK%8?mvwhA;mKQ! z&zip2H;oA|CPf31STAoiQRAOv{hj%S-I-nDExycr-#KT_@A93Q-CzFr?neO6VLpiz zo=+f(7h<@WL>T!5FOxA$B^hKUjA>cDD65$mE-6H33rpK?+6v}NrIKBl+p?-vyQ*N6 z+-Up4Y_Vijb_*5T9?+$Eg~W1kqhvWd6+U;)S20%<*0$LD)WY_~$wEl;UMiiI8ZjP)G-qa=+|Y>u)VuWe>GA z8z_*LBPT%lxaIw8sZW#_?3<1luaGQXEpBXjoB3dG-*b)n{vss^v10Yg?Xt7$p2H2I zRBfjwJGtT8bYurlav_r)49HYSu|=JBChKG1`Wh)~L4E#ABW>YkvXM`7ifrnATS%uq zmpuL6K%lW7yYX>fxA95eoL+2JHr*VeJImWUm34c*D3h6~!;i{%Q2CNwbrx-z-l~aH zXgASU^(%>fzW6DAClo@$jQ3XVLTE#hYZB(QgOMf16z|F05mZhcBJ?$PVVvf*g?HdQ z3``(_XVJ->sjG1YUEFmCB0bzm@3ZVFz3(8x70@TWhaR9kcOT)^+|UsW;_M+_!!umG zPSyi6#JhwzW{Geay_k1#J9Q@ymp$tpUwu3Hg$$VQlwi4B%Ca<8@rX8&toBtGJ2l*mSk$G`E`e6;C_);&Blt%<%+QVb_m( zz4k-u#SdNIQ>*V`y?E4($U_n^v`6kW3Zz?FkIfq3!<\r\n\ Materialien\ zu\ den\ zentralen\ NRW-Abiturpruefungen\ im\ Fach\ Informatik\ ab\ 2018\r\n\

\r\n\

\r\n\ Generische\ Klasse\ BinaryTree\r\n\

\r\n\

\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\

\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\ 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\r\n\ @param\ pRightTree\r\n\ \ \ \ \ \ \ \ \ \ \ \ der\ rechte\ Teilbaum\ vom\ Typ\ BinaryTree\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.\ \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\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\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\ oder\ null,\ wenn\r\n\ der\ aktuelle\ Binaerbaum\ leer\ ist\r\n +numComments=11 diff --git a/BinaryTree.java b/BinaryTree.java new file mode 100644 index 0000000..b589034 --- /dev/null +++ b/BinaryTree.java @@ -0,0 +1,210 @@ + /** + *

+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018 + *

+ *

+ * Generische Klasse BinaryTree + *

+ *

+ * 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. + *

+ * + * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule + * @version Generisch_03 2014-03-01 + */ +public class BinaryTree { + + /* --------- 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 { + + private CT content; + private BinaryTree 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(); + right = new BinaryTree(); + } + + } + + /* ----------- Ende der privaten inneren Klasse -------------- */ + + private BTNode 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(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 + * @param pRightTree + * der rechte Teilbaum vom Typ BinaryTree + */ + public BinaryTree(ContentType pContent, BinaryTree pLeftTree, BinaryTree pRightTree) { + if (pContent != null) { + this.node = new BTNode(pContent); + if (pLeftTree != null) { + this.node.left = pLeftTree; + } else { + this.node.left = new BinaryTree(); + } + if (pRightTree != null) { + this.node.right = pRightTree; + } else { + this.node.right = new BinaryTree(); + } + } 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.
+ * 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(pContent); + this.node.left = new BinaryTree(); + this.node.right = new BinaryTree(); + } + 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 + */ + public void setLeftTree(BinaryTree 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 + */ + public void setRightTree(BinaryTree 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 oder null, wenn + * der aktuelle Binaerbaum leer ist + */ + public BinaryTree 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 oder null, wenn + * der aktuelle Binaerbaum (this) leer ist + */ + public BinaryTree getRightTree() { + if (!this.isEmpty()) { + return this.node.right; + } else { + return null; + } + } + +} diff --git a/README.TXT b/README.TXT new file mode 100644 index 0000000..0ad193f --- /dev/null +++ b/README.TXT @@ -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: diff --git a/Traversierungen.class b/Traversierungen.class new file mode 100644 index 0000000000000000000000000000000000000000..2ea2b8e46765413501a8578d56dfd72a0b5d6984 GIT binary patch literal 2205 zcmbVM+fp1=6kR?Hyv=Q!{Ah|tPA&#DJzn10(x5GBI9Bwn%?C?XB`RPf?tOTk03sVCB1~1W<*8g? z)NFRm73fUGt@=^5y6x=mwrr=gWIYag%j8L`RAO+2ebrzT-Cb`}E!fiBu7>`N%dAZF zqEE-Ni50wW;x)W(Vh}?nP9djb)kG0%CO*Kri8C12@u7*2@Uf0hOni#FChmb9N`5)h zZ{jn2F57-?&k4eL3~?+CN!h!)M3y)1t4)^LB(ma&J2_S5S-y(2BW4ahw>UpP8lNr; ztILsxvhwF#%FQ8GS8g;W!Y~7slBG{UZTTT&3!Ul+ypEA7?p1xo-X+~#!W|F6Y+a=UPE&o$lw*oq?tVGAek7*5Iuy~P5z6oCc#Mvi;(DG z5ZE1FMuC!lI4E+2ejzil^w1ubeUiIV2MjM0Q5YHl!(? z6zR*#SPjOn(4Qn;JmWU|3r^(wYA~PUnB3IR@+6_<<%ZS_pRGrFw2FstNd*;OW#@rW z=*Yvs7$QuHXVc&KI%3FZ?o3(%$}%-$9pFqArm$QS+>$ z-Y>b6evL7%3CZlhK-9X^bmI%mE1AnzQPH{NbYJf`80zaymA*y`Ywc*Oq5UbcvhCoO zML&Jtp$OvqPp`(GVE$(c$W 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 pRoot ) { + // TODO: Ausgabe das Baumes auf der Kommandozeile in Preorder + } + + public void printHirarchical() { + printHirarchical(root, 0); + } + + public void printHirarchical(BinaryTree 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 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 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 ) { + + } +} diff --git a/Trees$1.class b/Trees$1.class new file mode 100644 index 0000000000000000000000000000000000000000..961be0e06409495b956494d7ac980931fdbb1a86 GIT binary patch literal 1032 zcmZuw{ZG?C7=Dg*l+_|*4Do~c1?pCmiC?G?5*eUP1|~w5_?x%xGD^yow6|scSDNsV zXyPB>A7y;6RH$f^zHjfj=brcL`t#Sf9{?7yR6qguwRxaT)q;hZ3CF@59$Lubkwx&l ziMol$CKeb*`aGD8xa=^LntQy@>pkTM^$&!E`%4U?djDXP4_Z9v2?pk#VZKbU;bmX? zYK38{`mcoR)>;fkBka)Wv8FG@R&T#8q8;822q`r~j|VLt`Ffp#hT8RG2HTZVM2&#Q zv7lw4xf2Ny&n{3}1|13*Cabm6hyj<~x+|6FiiozY^?@f2lpo62#1n?{U%dD2J>e;$ z6}J7Zse_9Gd<$SjPsfA(U{K#4F81jiE?REuCf-8|0s$oK_uIsL?)talm z!Nik3)K+~(bHM&RIwQ!qmqy>gc$Q6sae1JT4Ao0`$y4g8; z$5A5I1bwYw2nPAGGj{~$Odny$sT?8aoWS@>_z=ouhlvfum?Uc_-(_6ERa!CKFJft} zxAaqJUgbOTADu&zJ0!J3x^7C_{POOv2ux4(afBaF@J+8O-8dg3MrwyzX6rJUzbw$IjJ! literal 0 HcmV?d00001 diff --git a/Trees$2.class b/Trees$2.class new file mode 100644 index 0000000000000000000000000000000000000000..863e07629d7d012e00e892613be2d70d50de4870 GIT binary patch literal 988 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 I@b|?300HEebpQYW literal 0 HcmV?d00001 diff --git a/Trees.ctxt b/Trees.ctxt new file mode 100644 index 0000000..dd1e194 --- /dev/null +++ b/Trees.ctxt @@ -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\ \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 diff --git a/Trees.java b/Trees.java new file mode 100644 index 0000000..bf672d3 --- /dev/null +++ b/Trees.java @@ -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 + */ +public class Trees { + + public static int getMaxDepth( BinaryTree pRoot ) { + if( pRoot.isEmpty() ) { + return 0; + } + return 1 + Math.max( + getMaxDepth( pRoot.getLeftTree() ), + getMaxDepth( pRoot.getRightTree() ) + ); + } + + public static int countNodes( BinaryTree pRoot ) { + if( pRoot.isEmpty() ) { + return 0; + } + return 1 + countNodes( pRoot.getLeftTree() ) + countNodes( pRoot.getRightTree() ); + } + + public static int countLeaves( BinaryTree 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 void printPretty( BinaryTree pRoot ) { + printPretty(pRoot, System.out); + } + + public static void printPretty( BinaryTree pRoot, PrintStream pOut ) { + pOut.print(printPretty(pRoot, new StringBuilder(), true, new StringBuilder()).toString()); + } + + // Adapted from https://stackoverflow.com/a/27153988/10921408 + private static StringBuilder printPretty( BinaryTree 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 void printPreorder( BinaryTree pRoot ) { + printPreorder(pRoot, System.out); + } + + public static void printPreorder( BinaryTree pRoot, PrintStream pOut ) { + if( pRoot.getContent() == null ) { + return; + } + + pOut.print(pRoot.getContent().toString() + ","); + printPreorder(pRoot.getLeftTree(), pOut); + printPreorder(pRoot.getRightTree(), pOut); + } + + public static void printPostorder( BinaryTree pRoot ) { + printPostorder(pRoot, System.out); + } + + public static void printPostorder( BinaryTree pRoot, PrintStream pOut ) { + if( pRoot.getContent() == null ) { + return; + } + + pOut.print(pRoot.getContent().toString() + ","); + printPostorder(pRoot.getLeftTree(), pOut); + printPostorder(pRoot.getRightTree(), pOut); + } + + public static void printInorder( BinaryTree pRoot ) { + printInorder(pRoot, System.out); + } + + public static void printInorder( BinaryTree pRoot, PrintStream pOut ) { + if( pRoot.getContent() == null ) { + return; + } + + pOut.print(pRoot.getContent().toString() + ","); + printInorder(pRoot.getLeftTree(), pOut); + printInorder(pRoot.getRightTree(), pOut); + } + + public static BinaryTree generateBalancedIntegerTree( int pNodeCount, int pMinValue, int pMaxValue ) { + return generateIntegerTree(pNodeCount, pMinValue, pMaxValue, 0.5, 0.0); + } + + public static BinaryTree generateCompleteIntegerTree( int pDepth, int pMinValue, int pMaxValue ) { + return generateBalancedIntegerTree((int)Math.pow(2,pDepth)-1, pMinValue, pMaxValue); + } + + public static BinaryTree generateIntegerTree( int pNodeCount, double pWeight, double pUncertainty ) { + return generateIntegerTree(pNodeCount, 0, 100, pWeight, pUncertainty); + } + + public static BinaryTree generateIntegerTree( int pNodeCount, int pMinValue, int pMaxValue, double pWeight, double pUncertainty ) { + final Random rand = new Random(); + return generateTree(pNodeCount, new Callable() { + @Override + public Integer call() throws Exception { + return new Integer(rand.nextInt(pMaxValue-pMinValue)+pMinValue); + } + }, pWeight, pUncertainty); + } + + public static BinaryTree generateStringTree( int pNodeCount, double pWeight, double pUncertainty ) { + return generateStringTree(pNodeCount, new String[]{"Jonas", "Martin", "Harald", "Sabine", "Feline", "Kathrin"}, pWeight, pUncertainty); + } + + public static BinaryTree generateStringTree( int pNodeCount, final String[] pWords, double pWeight, double pUncertainty ) { + final Random rand = new Random(); + return generateTree(pNodeCount, new Callable() { + @Override + public String call() throws Exception { + return pWords[rand.nextInt(pWords.length)]; + } + }, pWeight, pUncertainty); + } + + public static BinaryTree generateTree( int pNodeCount, Callable pGenerator, double pWeight, double pUncertainty ) { + return generateTree(new BinaryTree(), pNodeCount, pGenerator, pWeight, pUncertainty); + } + + public static BinaryTree generateTree( BinaryTree pRoot, int pNodeCount, Callable 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; + } + +} diff --git a/package.bluej b/package.bluej new file mode 100644 index 0000000..c20b73a --- /dev/null +++ b/package.bluej @@ -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