Binary Search Boom in python werkt niet

Question

Binary Search Boom in python werkt niet

stemmen

2

class Node:
    '''represents a new node in the BST'''
    def __init__(self,key):
        self.key=key
        self.disconnect()
    def disconnect(self):
        self.left=None;
        self.right=None;
        self.parent=None;
    def __str__(self):
        return 'node with kay %s'%self.key

class BST:
    def __init__(self):
        self.root=None
    def insert(self,t):
        '''inserts a new element into the tree'''
        self.find_place(self.root,t)

    def find_place(self,node,key):
        finds the right place of the element recursively
        if node is None:
            node=Node(key)
            print node
        else:
            if node.key > key:
                find_place(node.left,key)
            else:
                find_place(node.right,key)
def test():
    '''function to test if the BST is working correctly'''

schreef ik de bovenstaande code te implementeren van een binaire zoekboom maar de insert methode werkt niet zoals verwacht, niet in slaagt om zelfs de root-element toe te voegen. Ik kan de oorzaak niet undestand.

python algorithm binary-search-tree

De vraag is gesteld op 20/06/2010 om 08:40
bron van user Bunny Rabbit

In andere talen...

2 antwoorden

stemmen

0

Hier is nog een BST met Python, met behulp van een sorteersleutel

LEFT RIGHT = 0 = 1 VALUE = 2 = -1 SORT_KEY

klasse BinarySearchTree (object):

def __init__(self, sort_key=None):
    self._root = []  
    self._sort_key = sort_key
    self._len = 0

def voegen (zelf, val): als self._sort_key is None: sort_key = val // als er geen soort sleutel, een soort sleutel is waarde anders: sort_key = self._sort_key (val)

node = self._root
while node:
    if sort_key < node[_SORT_KEY]:
        node = node[LEFT]
    else:
        node = node[RIGHT]

if sort_key is val:
    node[:] = [[], [], val]
else:
    node[:] = [[], [], val, sort_key]
self._len += 1

def minimum(self):
    return self._extreme_node(LEFT)[VALUE]

def maximum(self):
    return self._extreme_node(RIGHT)[VALUE]

def find(self, sort_key):
    return self._find(sort_key)[VALUE]

def _extreme_node(self, side):
    if not self._root:
        raise IndexError('Empty')
    node = self._root
    while node[side]:
        node = node[side]
    return node

def _find(self, sort_key):
    node = self._root
    while node:
        node_key = node[SORT_KEY]
        if sort_key < node_key:
            node = node[LEFT]
        elif sort_key > node_key:
            node = node[RIGHT]
        else:
            return node
    raise KeyError("%r not found" % sort_key)

Sorteer sleutel wordt vervangen door de waarde indien van toepassing.

antwoordde op 29/04/2013 om 13:25
bron van user octoback

Will · Accepted Answer · 2010-06-20 08:51

Je bent niet echt toevoeging van knooppunten aan de boom!

Het is het gemakkelijkst om het beheer van de toevoeging van de root node expliciet, zoals je ziet heb ik hieronder in de insert.

Een find_placefunctie zou vermoedelijk uit de naam, de terugkeer van de bovenliggende knooppunt en of het de linker of rechter sleuf voor de sleutel? Ik heb een expliciet gemaakt _do_insert, zoals hieronder is dat zowel wandelingen en doet het inzetstuk.

Vanaf dat moment, moet je de boom te lopen, elke keer zien als je recurse beneden een tak of dat u een leeg slot, waar u het nieuwe knooppunt toe te voegen hebt bereikt.

Het zou natuurlijk om uw code refactoren om de verantwoordelijkheid voor de walking zetten (en het doen toevoegt, verwijdert en dergelijke) in de Nodeklasse.

In de onderstaande code, negeer ik het toevoegen van een sleutel die al in de boom, ik heb net in stilte af te sluiten:

def insert(self,t):
    '''inserts a new element into the tree'''
    if self.root is None:
        self.root = Node(t)
    else:
        self._do_insert(self.root,t)

def _do_insert(self,parent,t):
    if t > parent.key:
        if parent.left is None:
            parent.left = Node(t)
        else:
            self._do_insert(parent.left,t)
    elif t < parent.key:
        if parent.right is None:
            parent.right = Node(t)
        else:
            self._do_insert(parent.right,t)
    else:
        # raise a KeyError or something appropriate?
        pass