Binary Search Tree in python che non funziona

Question

Binary Search Tree in python che non funziona

voti

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

ho scritto il codice qui sopra per implementare un albero binario di ricerca, ma il metodo di inserimento non funziona come previsto, non riesce a aggiungere ancora l'elemento principale. non riesco a capirne la causa.

python algorithm binary-search-tree

È pubblicato 20/06/2010 alle 08:40
fonte dall'utente Bunny Rabbit

In altre lingue...

2 risposte

voti

0

Ecco un altro BST con Python, utilizzando una chiave di ordinamento

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

Classe BinarySearchTree (oggetto):

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

inserire def (self, val): se self._sort_key è None: sort_key = val // se no chiave di ordinamento, chiave di ordinamento è un valore diverso: 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)

chiave di ordinamento è sostituito dal valore se qualsiasi.

Risposto il 29/04/2013 a 13:25
fonte dall'utente octoback

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

Non stai in realtà l'aggiunta di tutti i nodi per l'albero!

La sua più semplice per gestire l'aggiunta del nodo principale in modo esplicito, come vedete ho fatto seguito nella insert.

Una find_placefunzione dovrebbe, presumibilmente dal nome, restituire il nodo padre e anche se si tratta di destra o slot di destra per la chiave? Ho fatto un esplicito _do_insertfunzione qui sotto che sia passeggiate e fa l'inserto.

Da allora in poi, è necessario camminare l'albero, ogni volta vedere se si ricorsione giù un ramo o se hai raggiunto uno slot vuoto, in cui si aggiunge il nuovo nodo.

Potrebbe essere naturale di refactoring il codice per mettere la responsabilità per camminare l'albero (e facendo aggiunge, rimuove e come) nella Nodeclasse.

Nel codice qui sotto, ignoro l'aggiunta di una chiave che è già nell'albero, ho solo silenzio uscita:

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