representar árboles binarios de búsqueda en pitón

class Node(object):

  def __init__(self, payload):
    self.payload = payload
    self.left = self.right = 0

    # this concludes the "how to represent" asked in the question.  Once you
    # represent a BST tree like this, you can of course add a variety of
    # methods to modify it, "walk" over it, and so forth, such as:

  def insert(self, othernode):
    "Insert Node `othernode` under Node `self`."
    if self.payload <= othernode.payload:
      if self.left: self.left.insert(othernode)
      else: self.left = othernode
    else:
      if self.right: self.right.insert(othernode)
      else: self.right = othernode

  def inorderwalk(self):
    "Yield this Node and all under it in increasing-payload order."
    if self.left:
      for x in self.left.inorderwalk(): yield x
    yield self
    if self.right:
      for x in self.right.inorderwalk(): yield x

  def sillywalk(self):
    "Tiny, silly subset of `inorderwalk` functionality as requested."
    if self.left:
      self.left.sillywalk()
    print(self.payload)
    if self.right:
      self.right.sillywalk()

etc, etc -, básicamente, como en cualquier otro idioma que utiliza referencias en lugar de punteros (como Java, C #, etc).

Editar :

Por supuesto, la propia existencia de sillywalkes tonto de hecho, debido a exactamente la misma funcionalidad es un fragmento externo singe-liner en la parte superior del walkmétodo:

for x in tree.walk(): print(x.payload)

y con la walkque se puede obtener casi cualquier otra funcionalidad en el flujo de nodos en orden, mientras que, con el sillywalk, puede obtener casi diddly-squat. Pero, bueno, el PO dice yieldes "intimidante" (Me pregunto cuántos de Python 2.6 otras 30 palabras clave merecen tales palabras asustar a juicio de la OP -?), Así que espero printno lo es!

Todo esto es completamente más allá de la cuestión real, en la que representan BSTs: que pregunta se responde por completo en el __init__- un payloadatributo para mantener la carga útil del nodo, lefty el rightatributo para mantener bien None(es decir, este nodo tiene descendientes de ese lado) o una Node( la parte superior de la sub-árbol de descendientes en el lado apropiado). Por supuesto, la restricción BST es que cada descendiente izquierda de cada nodo (si lo hay) tiene una capacidad de carga igual o menor que la del nodo en cuestión, cada uno derecho (de nuevo, en su caso) tiene una mayor carga útil - añadí insertjusto para mostrar lo trivial que es mantener esa restricción, walk(y ahora sillywalk) para mostrar cómo es trivial que es conseguir que todos los nodos con el fin de aumentar la carga útil. Una vez más, la idea general es idéntica a la manera en que se representa un BST en cualquier idioma que utiliza referencias en lugar de punteros, como, por ejemplo, C # y Java.