In Ordnung BST Traversal: find

Ich versuche, das kth kleinste Element des binären Suchbaums zu finden und ich habe Probleme mit Rekursion. Ich verstehe, wie man den Baum inorder / postorder etc. ausdruckt, aber ich versäumt, den Rang des Elements zurückzugeben. Kann jemand anfangen, wo ich einen Fehler mache? Im Allgemeinen habe ich harte Zeit Verständnis Rekursion in Bäumen.

Edit: Dies ist eine Übung, also suche ich nicht nach eingebauten Funktionen. Ich habe eine andere Lösung, wo ich die Anzahl der linken und rechten Kinder behalte, während ich Knoten einfügst und dieser Code funktioniert gut. Ich frage mich, ob es möglich ist, dies mit intra traversal zu tun, weil es eine einfachere Lösung zu sein scheint.

class BinaryTreeNode: def __init__(self, data, left=None, right=None): self.data = data self.left = left self.right = right def traverseInOrder(root,order): if root == None: return traverseInOrder(root.left,order+1) print root.data, print order traverseInOrder(root.right,order) """ a / \ bc / \ / \ defg / \ hi """ h = BinaryTreeNode("h") i = BinaryTreeNode("i") d = BinaryTreeNode("d", h, i) e = BinaryTreeNode("e") f = BinaryTreeNode("f") g = BinaryTreeNode("g") b = BinaryTreeNode("b", d, e) c = BinaryTreeNode("c", f, g) a = BinaryTreeNode("a", b, c) print traverseInOrder(a,0) 

    2 Solutions collect form web for “In Ordnung BST Traversal: find”

    Wenn dies eine akademische Übung ist, lassen Sie traverseInOrder (oder eine ähnliche Methode, die auf den Zweck zugeschnitten ist) die Anzahl der Kinder zurück, die sie besucht haben. Von dort geht es einfacher.

    Wenn dies nicht akademisch ist, werfen Sie einen Blick auf http://stromberg.dnsalias.org/~dstromberg/datastructures/ – die Wörterbuch-ähnliche Objekte sind alle Bäume und unterstützen Iteratoren – so finden die nth ist eine Frage der Zip ( Baum, Bereich (n)).

    Sie konnten das smallets-Element im Binär-Suchbaum zuerst finden. Dann von diesem Element rufen Sie eine Methode, um Ihnen das nächste Element k mal.

    Für find_smallest_node Methode, beachten Sie, dass Sie alle Knoten "in-order" durchqueren können, bis zum kleinsten zu erreichen. Aber dieser Ansatz nimmt O (n) Zeit.

    Allerdings brauchst du keine Rekursion, um den kleinsten Knoten zu finden, denn bei BST ist der kleinste Knoten einfach der linkste Knoten, also kannst du die Knoten durchqueren, bis du einen Knoten gefunden hast, der kein linkes Kind hat und O (log n) Zeit braucht :

     class BST(object): def find_smallest_node(self): if self.root == None: return walking_node = self.root smallest_node = self.root while walking_node != None: if walking_node.data <= smallest_node.data: smallest_node = walking_node if walking_node.left != None: walking_node = walking_node.left elif walking_node.left == None: walking_node = None return smallest_node def find_k_smallest(self, k): k_smallest_node = self.find_smallest_node() if k_smallest_node == None: return else: k_smallest_data = k_smallest_node.data count = 1 while count < k: k_smallest_data = self.get_next(k_smallest_data) count += 1 return k_smallest_data def get_next (self, key): ... 

    Es braucht nur, um die Eltern der Knoten zu halten, wenn sie sie in den Baum einfügen.

     class Node(object): def __init__(self, data, left=None, right=None, parent=None): self.data = data self.right = right self.left = left self.parent = parent 

    Eine Implementierung der bst-Klasse mit den oben genannten Methoden und auch def get_next (self, key) Funktion ist hier . Der obere Ordner enthält die Testfälle für ihn und es funktionierte.

    Python ist die beste Programmiersprache der Welt.