Innere Knoten zählen in einem binären Baum

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Sonntag 12. Februar 2017, 04:19

Hallo ihr lieben,

ich habe am Ende des Monats eine Klausur in Info 1 und bin gerade dabei dafür zu lernen.
Wir hatten eine Probeklausur in der es eine Aufgabe gibt, wo ich einfach nicht darauf komme, wie man die lösen könnte.

Die Aufgabe selber lautet:

Im Folgenden gehen wir davon aus, dass die Knoten eines Binärbaumes als Tupel (left, label, right) repräsentiert werden, wobei left der linke Teilbaum, label die Makierung und right der Rechte Teilbaum ist.
Der leer Baum wird durch None repräsentiert.

Schreiben Sie die Funktion inner_nodes(tree), die für einen übergebenen Binärbaum tree die Anzahl der inneren Knoten zählt und zurück gibt.

Ich wollte es zunächst mit der mit vertrauteren Definition [label, left, right] versuchen und dachte
vielleicht kanne ich die Preorder traversierung irgendwie verändern, die Knoten die es findet in eine Liste schreiben, das klappt jedoch alles nicht, da die rekursion dabei Probleme macht.

  1. def preorder(node):
  2.     if node is not None:
  3.         print(node[0])
  4.         preorder(node[1])
  5.         preorder(node[2])


Wir haben in der Vorlesung nicht viel anderes erhalten, ein Beispiel der Postorder_implementierung, Search in Tree und eine Searchtree Implementierung.

Ich habe wenig hilfreiches im Internet gefunden, da dort alles mit Klassen gelöst worden ist, was jedoch in dieser Aufgabe nicht gefragt ist, da es ja nur eine einzelen aufgabe ist zu dem thema, die genau so heißt wie oben geschrieben. Der b) Teil in dem soll man nur einen test schreiben.
Es sollte auch relativ wenig Code genügen da es ja eine Klausuraufgabe ist (und auch relativ wenig Platz zum Lösung hinschreiben gegeben wurde).

Ich dachte man müsste irgendwie überprüfen können ob ein Knoten ein Blatt ist und wenn nicht ihn dann in eine Liste schreiben und dann die elemente der liste zählen.

Aber wie gesagt durch die wenige Hilfestellung aus der Vorlesung habe ich keine Ahnung wie ich das anstellen könnte. Ich hatte ja den Ansatz ob man z.B. die obige preorder-funktion umschreiben könnte, meine Versuche scheiterten. Geht das überhaupt als Ansatz oder ist das totaler Mist?

Ich hab 3 verschiedene Bücher hier zu Python, aber in keinem wird auch nur Bäume erwähnt. :/
Kann mir jemand helfen? Bin etwas verzweifelt und hab auch ganz schön angst vor der klausur. :?
Zuletzt geändert von Anonymous am Sonntag 12. Februar 2017, 10:41, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
DasIch
User
Beiträge: 2384
Registriert: Montag 19. Mai 2008, 04:21
Wohnort: Berlin

Re: Innere Knoten zählen in einem binären Baum

Beitragvon DasIch » Sonntag 12. Februar 2017, 05:27

Am sinnvollsten ist erstmal ein paar Beispiele zu wählen, die sollten so einfach wie möglich sein und doch alle möglichen Fälle abdecken. In diesem Fall bieten sich dazu 3 Beispiele an:

  • Blatt / Leerer Baum: None
  • Innerer Knoten: (None, 'label', None)
  • Innerer Knoten mit nicht-leeren Teilbäumen: ((None, 'left', None), 'middle', (None, 'right', None))

Überleg dir was inner_nodes zurückgeben muss damit es für das erste Beispiel das richtige Ergebnis zurück gibt, ignorier dabei die anderen Beispiele. Wenn du das geschafft hast schau dir das nächste Beispiel an und verändere inner_nodes so, dass es das richtige Ergebnis für das erste und das zweite Beispiel zurückgibt usw.

Wenn inner_nodes mit diesen 3 Beispielen funktioniert und es halbwegs sinnvoll implementiert ist, sollte es immer funktionieren. Um nochmal sicherzugehen, kann man sich aber auch hier nochmal ein paar komplexere Beispiele überlegen.
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Sonntag 12. Februar 2017, 16:00

Danke danke für deine Antwort!
Kann ich denn Strukutren vergleichen, also sagen wenn das die Form hat (None, "irgendwas", None) dann mache das und das?
Das war eigentlich mein größtes Problem. Die Knoten sehen ja alles unterschiedlich aus nur die Form ist gleich.

Hmm ich wollte es urprünglich mit einer If-Schleife und dem Gleichheitsoperator == machen. Ich weiß gar nicht wie ich in den nächsten Knoten gehen könnte außer durch Rekursion und die macht dann wiederum probleme.

Ich frag mich gerade auch ob einen Denkfehler habe.
Ich hätte jetzt gesagt Blatt ist (None, label, None).
innererknoten nur das: ((None, 'left', None), 'middle', (None, 'right', None))
Blatt / Leerer Baum: None
Innerer Knoten: (None, 'label', None)
Innerer Knoten mit nicht-leeren Teilbäumen: ((None, 'left', None), 'middle', (None, 'right', None))


Kannst du mir vllt nochmal ein Tipp geben womit man es implementieren könnte? (if, rekursion)
Ich habe keine Ahnung wie ich sagen kann was ein innere Knoten ist, außer mit dem Gleichheitsoperator == was ja so nicht klappt, da sie ja nicht immer genau gleich sind.

Ich probiers heute abend nochmal. Aber wahrscheinlich muss ich es dann lassen, ich hab schon gestern zu lange zeit damit verbracht darüber zu googlen und die inorder umzuschreiben.
Ich find die Aufgabe irgendwie total mies, es gab in den Übungsblättern 2 Aufgaben über Bäume und auch allgemein, es wird etwas eingeführt und dann geht man davon aus, dass das reicht und man es kann :D . Ich habe erst bei einem Vorkurs aus dem Internet etwas sicherheit im Programmieren bekommen, in dem sich Lösungansätze wiederholt haben in verschiedene Aufgaben, so das sich etwas festigen konnte.

Aber danke dir vielmals!
BlackJack

Re: Innere Knoten zählen in einem binären Baum

Beitragvon BlackJack » Sonntag 12. Februar 2017, 16:54

@mindychen: Also erst einmal ganz wichtig: http://if-schleife.de/

Strukturen vergleichst Du in dem Du die Einzelkomponenten die Dich auf die Werte prüfst die einen inneren Knoten ausmachen. Wie gesagt: Am besten „entpackst“ Du das Tupel auf Namen und machst die Vergleiche mit den benannten Werten. Dann wird das gleich lesbarer. „Pattern matching“ kennt Python nicht. Das ginge in Haskell. :-)

Für Tests auf `None` verwendet man in der Regel ``is`` und ``is not`` statt ``==`` und ``!=`` weil es den Wert `None` garantiert nur einmal gibt. (Singleton)

Warum macht die Rekursion Probleme? Und welche? Das ist eine klassische Aufgabe zum Thema Rekursion/rekursive Datenstruktur. Und die Implementierung ist auch sehr einfach und kurz. Man muss eigentlich nur Rekursion verstanden haben. Dazu muss man Rekursion verstehen. ;-)

Ich würde sagen die Definition von Blatt/Innerer Knoten von DasIch ist falsch und hätte auch gesagt das sein innerer Knoten ein Blatt ist. In der Aufgabe steht ja das `None` der leere Baum ist. Das ein leerer Baum gleichzeitig ein Blatt sein soll steht da nicht. Und ein Blatt ist üblicherweise als Knoten ohne Kinder definiert. Was auf (None, 'irgendwas', None) IMHO zutrifft, denn leere Bäume sind ja keine Kindknoten.

Allerdings ist innerer Knoten nicht *nur* das 3. Beispiel, denn es gibt noch zwei andere Varianten.
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Sonntag 12. Februar 2017, 17:48

oh, ja klar meinte doch if-abfragen :D *haha* :oops:
ok, danke danke danke!

es hilft mir sehr wenigstens sicher die Richtung zu wissen, dann wirkt es nicht so aussichtslos.
eigentlich hatte ich rekursionen schon ganz gut mittlerweile verstanden. Am Anfang hab ich sie total gehasst, aber dann viele Aufgaben die man auch einfach ohne Rekursion hätte Implementieren können alle mit Rekursion gelöst :D.
Aber an der baum Struktur mit diesen verschachtelten listen bzw. jetzt tupeln tue ich mich etwas schwer.,

ich mach mich gleich nochmal dran.
BlackJack

Re: Innere Knoten zählen in einem binären Baum

Beitragvon BlackJack » Sonntag 12. Februar 2017, 20:59

@Mindychen: Die Baumstruktur ist ja aber genau der Grund warum eine rekursive Funktion Sinn macht, eben weil es eine rekursive Datenstruktur ist. Der ”Trick” ist eigentlich immer nur in der Funktion bei einem Aufruf nicht zu viel machen zu wollen. Mir hat es am Anfang geholfen so zu tun als wenn man schon eine Funktion hat, die die Aufgabe löst. Also zum Beispiel `magic_inner_nodes()`. Und nun kann man eine `inner_nodes()`-Funktion für *einen* Knoten im Baum schreiben, die diese `magic_inner_nodes()` verwendet. Wenn man das gemacht hat, kann man den oder die Aufrufe von `magic_inner_nodes()` einfach in `inner_nodes()`-Aufrufe ändern, denn diese Funktion macht ja jetzt was sie soll unter der Voraussetzung man hat eine Funktion die das macht. Rekursion halt. :-)

Mal mit Haskell ein Beispiel wie das in einer Sprache mit „pattern matching“ aussehen kann auf so einer Baumstruktur zu operieren:
  1. data Tree a = Node (Tree a) a (Tree a)
  2.    | Nil
  3.    deriving Show
  4.  
  5. fac 0 = 1
  6. fac n = n * fac (n - 1)
  7.  
  8. evaluate Nil                   = 0
  9. evaluate (Node Nil  n   Nil)   = read n
  10. evaluate (Node left "+" right) = evaluate left + evaluate right
  11. evaluate (Node left "*" right) = evaluate left * evaluate right
  12. evaluate (Node left "!" Nil)   = fac $ evaluate left
  13.  
  14. main :: IO ()
  15. main =
  16.   let tree = Node (Node (Node Nil "23" Nil) "*" (Node Nil "42" Nil))
  17.                   "+"
  18.                   (Node (Node Nil "5" Nil) "!" Nil)
  19.   in do
  20.     putStrLn $ show $ evaluate tree
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Sonntag 12. Februar 2017, 22:18

Danke dir.
Ich hab meinen Tutor geschrieben, der hat es mir dann mit einem Pseudocode erklärt, damit habe ich es dann geschafft. x)
Im Nachinein war mein Problem, dass ich es nur mit einer einzelnden Rekursion probiert habe.
Es aber zwei gebraucht hat:

Code: Alles auswählen

return countInnerNodes(tree[0]) + countInnerNodes(tree[2]) + 1


Also ich kanns jetzt nachvollziehen und habe auch eine Funktion für Blätter und für alle Knoten geschrieben, jedoch die denkweise um darauf zu kommen ist jetzt noch nicht so da :D.

Bräuchte vllt noch andere Aufgaben die man so ähnlich löst um es noch besser zu begreifen und alleine dann drauf zu kommen (fibonacci ist ja z.B. eine aber die kenne ich schon).
Es war überhaupt gar nicht auf meinen Schirm zwei Rekursionen zu nutzen, daher war es wirklich unlösbar so für mich :D.
BlackJack

Re: Innere Knoten zählen in einem binären Baum

Beitragvon BlackJack » Sonntag 12. Februar 2017, 22:45

@Mindychen: In der Traversierungsfunktionen sind ist doch auch ein rekursiver Aufruf für den rechten und den linken Teilbaum und so eine Funktion hattest Du doch schon im ersten Beitrag‽

Ich würde wie schon mal geschrieben dringend von den ”magischen” Indexzugriffen Abstand nehmen und das Tupel ”entpacken”. Es wird viel verständlicher wenn man mit Namen operiert statt mit 0, 1, und 2. Dann kommt man auch eher darauf, dass man zwei rekursive Aufrufe in der Funktion braucht.

Die ``+ 1`` am Ende sieht falsch aus. Das würde ja nur stimmen wenn es sich bei `tree` auch tatsächlich um einen inneren Knoten handelt.

Fibonacci ist aber eigentlich eine Funktion bei der die rekursive Lösung vorsichtig ausgedrückt suboptimal ist. Es macht mehr Sinn Sachen rekursiv zu lösen wo das auch Sinn macht weil man die nicht so leicht durch eine Schleife ersetzen kann.

Ich habe übrigens gerade Modul gefunden mit dem man Python-Funktionen „pattern matching“ per Decorator verpassen kann. Mal das Haskellprogramm damit ausgedrückt:
  1. from math import factorial
  2. from patterns import patterns
  3.  
  4.  
  5. @patterns
  6. def evaluate():
  7.     if (None, n, None): int(n)
  8.     if (left, '+', right): evaluate(left) + evaluate(right)
  9.     if (left, '*', right): evaluate(left) * evaluate(right)
  10.     if (left, '!', None): factorial(evaluate(left))
  11.  
  12.  
  13. def main():
  14.     tree = (
  15.         ((None, '23', None), '*', (None, '42', None)),
  16.         '+',
  17.         ((None, '5', None), '!', None)
  18.     )
  19.     print(evaluate(tree))
  20.  
  21.  
  22. if __name__ == '__main__':
  23.     main()
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Montag 13. Februar 2017, 03:24

ah oki :). ja, danke für den tipp! ich werde in zukunft es erstmal versuchen zu "entpacken" :). im prinzip kam ich dann auch so drauf, mein tutor hatte mir nur einen pseudo code mit (left, lable, right) geschickt, dadurch hatte ich dann besser verstanden was wirklich konkret gefragt ist (das return war aber schon so dargestellt wie unten).

  1. def countInnerNodes(tree):
  2.     if tree == None:
  3.         return 0
  4.     elif len(tree) == 1:
  5.         return 0
  6.     elif tree[0] == None and tree[2] == None:
  7.         return 0
  8.     else:
  9.         return countInnerNodes(tree[0]) +1 + countInnerNodes(tree[2])


Also so sieht die funktion aus. Ja oben in meiner preorderfunktion werden aber einzelene rekursionen (also nicht zusammen addiert oder sonst was) und vorallem konnte ich mich da an der postorder funktion aus der Vorlesung orientieren.
Aber ja ehrlich gesagt fand ich die auch schwer zu verstehen.
Die Funktion funktioniert auch bei allen getesten bäume :)
Zuletzt geändert von Anonymous am Montag 13. Februar 2017, 09:31, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Sirius3
User
Beiträge: 6631
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Sirius3 » Montag 13. Februar 2017, 06:28

@Mindychen: zumindest der zweite Fall sollte bei einem fehlerfrei definierten Baum nicht auftreten. Da würde ich Python in einen ValueError laufen lassen:
  1. def count_inner_nodes(tree):
  2.     left, label, right = tree
  3.     if left is right is None:
  4.         return 0
  5.     result = 1
  6.     if left is not None:
  7.         result += count_inner_nodes(left)
  8.     if right is not None:
  9.         result += count_inner_nodes(right)
  10.     return result
Mindychen
User
Beiträge: 6
Registriert: Sonntag 12. Februar 2017, 04:07

Re: Innere Knoten zählen in einem binären Baum

Beitragvon Mindychen » Montag 13. Februar 2017, 09:06

ahja genau, das ist mir schon mal passiert, dass ich die None 's vergessen habe. ich war schon müde und dachte man müsste auch einen knoten eingeben können ohne fehler also (lable), aber das müsste ja dann (None, lable, None) heißen. :oops:
BlackJack

Re: Innere Knoten zählen in einem binären Baum

Beitragvon BlackJack » Montag 13. Februar 2017, 09:22

@Sirius3: Dein Code funktioniert nicht für den leeren Baum, der ist in der Aufgabe ja einfach als `None` definiert.

@all: Das `patterns`-Modul hat mich zur Programmiersprache Coconut gebracht. Das ist eine Obermenge von Python um funktionale Konstrukte wie „pattern matching“ erweitert. Der Compiler spuckt reguläres Python aus.
  1. from math import factorial
  2.  
  3.  
  4. def is_inner_node(None) = False
  5.  
  6. @addpattern(is_inner_node)
  7. def is_inner_node((None, _, None)) = False
  8.  
  9. @addpattern(is_inner_node)
  10. def is_inner_node(_) = True
  11.  
  12.  
  13. def count_inner_nodes(None) = 0
  14.  
  15. @addpattern(count_inner_nodes)
  16. def count_inner_nodes((left, _, right) as node) =
  17.     (
  18.         (0 if is_inner_node(node) else 1)
  19.         + count_inner_nodes(left)
  20.         + count_inner_nodes(right)
  21.     )
  22.  
  23.  
  24. def evaluate(None) = 0
  25.  
  26. @addpattern(evaluate)
  27. def evaluate((None, n, None)) = int(n)
  28.  
  29. @addpattern(evaluate)
  30. def evaluate((left, '+', right)) = evaluate(left) + evaluate(right)
  31.  
  32. @addpattern(evaluate)
  33. def evaluate((left, '*', right)) = evaluate(left) * evaluate(right)
  34.  
  35. @addpattern(evaluate)
  36. def evaluate((left, '!', None)) = left |> evaluate |> factorial
  37.  
  38.  
  39. def main():
  40.     tree = (
  41.         ((None, '23', None), '*', (None, '42', None)),
  42.         '+',
  43.         ((None, '5', None), '!', None)
  44.     )
  45.     tree |> count_inner_nodes |> print
  46.     tree |> evaluate |> print
  47.  
  48.  
  49. if __name__ == '__main__':
  50.     main()

Zum Vergleich noch mal das ganze Programm in Haskell:
  1. data Tree a = Node (Tree a) a (Tree a)
  2.    | Nil
  3.    deriving Show
  4.  
  5. isInnerNode Nil              = False
  6. isInnerNode (Node Nil _ Nil) = False
  7. isInnerNode _                = True
  8.  
  9. countInnerNodes Nil = 0
  10. countInnerNodes node @ (Node left _ right) =
  11.   let thisCount = if isInnerNode node then 1 else 0
  12.       leftCount = countInnerNodes left
  13.       rightCount = countInnerNodes right
  14.   in thisCount + leftCount + rightCount
  15.  
  16. fac 0 = 1
  17. fac n = n * fac (n - 1)
  18.  
  19. evaluate Nil                   = 0
  20. evaluate (Node Nil  n   Nil)   = read n
  21. evaluate (Node left "+" right) = evaluate left + evaluate right
  22. evaluate (Node left "*" right) = evaluate left * evaluate right
  23. evaluate (Node left "!" Nil)   = fac $ evaluate left
  24.  
  25. main :: IO ()
  26. main =
  27.   let tree = Node (Node (Node Nil "23" Nil) "*" (Node Nil "42" Nil))
  28.                   "+"
  29.                   (Node (Node Nil "5" Nil) "!" Nil)
  30.   in do
  31.     putStrLn $ show $ countInnerNodes tree
  32.     putStrLn $ show $ evaluate tree

Wer ist online?

Mitglieder in diesem Forum: Bing [Bot], Yahoo [Bot]