Binary Recherche Arbre en python ne fonctionne pas

Question

Binary Recherche Arbre en python ne fonctionne pas

voix

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'''

je l'ai écrit le code ci-dessus pour mettre en œuvre un arbre de recherche binaire, mais la méthode d'insertion ne fonctionne pas comme prévu, elle ne met pas même l'élément racine. Je ne peux pas undestand la cause.

python algorithm binary-search-tree

Créé 20/06/2010 à 08:40
source utilisateur Bunny Rabbit

Dans d'autres langues...

2 réponses

voix

0

Voici un autre BST avec Python, en utilisant une clé de tri

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

BinarySearchTree classe (objet):

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

insérer def (auto, val): si self._sort_key est None: sort_key = val // si aucune clé de tri, clé de tri est la valeur d'autre: 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)

clé de tri est remplacée par la valeur le cas échéant.

Créé 29/04/2013 à 13:25
source utilisateur octoback

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

Vous n'êtes pas en fait d'ajouter des nœuds à l'arbre!

Son plus facile à gérer l'ajout de nœud racine explicitement, comme vous le voyez , je l'ai fait ci - dessous dans le insert.

Une find_placefonction serait, probablement du nom, retourner le nœud parent et aussi si elle est la gauche ou la fente à droite pour la clé? Je l' ai fait explicite la _do_insertfonction ci - dessous que les deux promenades et fait l'insert.

A partir de là, vous devez marcher l'arbre, à chaque fois de voir si vous RECURSE en bas d'une branche ou si vous avez atteint un emplacement vide, où vous ajoutez le nouveau nœud.

Il pourrait être naturel de factoriser votre code pour mettre la responsabilité de marcher l'arbre (et faire ajoute, supprime et autres) dans la Nodeclasse.

Dans le code ci-dessous, je ne pas tenir compte d'ajouter une clé qui est déjà dans l'arbre, je ne quitte silencieusement:

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