képviseli a bináris keresés fák python

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()

stb, stb - alapvetően, mint bármely más nyelven, amely felhasználja adatai helyett mutatók (mint a Java, C #, stb.)

szerkesztése :

Természetesen a létét sillywalkbuta valóban, mert pontosan ugyanazt a funkcionalitást egy singe bélés külső részlet a tetején a walkmódszer:

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

és walkbe tudja szerezni bármilyen más funkciót a csomópontokon-in-order patak, míg a sillywalkkaphat, csak a pikula. De, hé, az OP mondja yielda „megfélemlítő” (vajon hány Python 2.6 egyéb 30 kulcsszavak érdemelnek ilyen pánik szava az OP ítélete? -), így remélem, printhogy nem!

Ez mind teljesen túl a tényleges kérdés, a képviselő BSTs: hogy a kérdés teljesen a válasz __init__- egy payloadattribútumot, a csomópont hasznos, leftés rightattribútumot sem None(értelme, ez a csomópont nincs leszármazottai azon az oldalon), vagy egy Node( a tetején a sub-tree leszármazottak megfelelő oldalán). Természetesen a BST korlát az, hogy minden bal leszármazottja egyes csomópont (ha van ilyen) egy hasznos kisebb vagy egyenlő, mint a kérdéses csomópont, minden igazit (ismét, ha van ilyen) nagyobb hasznos teher - tettem hozzá insert, csak hogy megmutassa, milyen triviális az, hogy azt állítják, hogy kényszer, walk(és most sillywalk), hogy mennyire jelentéktelen is az, hogy minden csomópont növekvő sorrendben rakományt. Ismét az alapötlet csak azonos módon, ahogy azt jelentik BST bármilyen nyelven, amely felhasználja adatai helyett mutatók, mint például a C # és Java.