अजगर में बाइनरी खोजें ट्री काम नहीं कर रहा

Question

अजगर में बाइनरी खोजें ट्री काम नहीं कर रहा

वोट

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

मैं एक द्विआधारी खोज वृक्ष लागू करने के लिए ऊपर दिए गए कोड लिखा था लेकिन डालने विधि काम नहीं कर रहा अपेक्षा के अनुरूप, तो यह और भी जड़ तत्व जोड़ने के लिए विफल रहता है। मैं कारण समझने के नहीं कर सकते।

python algorithm binary-search-tree

20/06/2010 को 08:40
का स्रोत उपयोगकर्ता Bunny Rabbit

अन्य भाषाओं में...

2 जवाब

वोट

0

यहाँ अजगर के साथ एक और BST, एक छँटाई कुंजी का उपयोग

वाम = 0 सही = 1 = 2 मूल्य SORT_KEY = -1

वर्ग BinarySearchTree (वस्तु):

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

डेफ (स्वयं, वैल) सम्मिलित करें: sort_key = वैल // अगर कोई तरह कुंजी, प्रकार कुंजी मान बाकी है: self._sort_key कोई नहीं है अगर sort_key = self._sort_key (वैल)

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)

क्रमबद्ध कुंजी मान यदि कोई द्वारा बदल दिया गया है।

29/04/2013 को 13:25
का स्रोत उपयोगकर्ता octoback

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

आप वास्तव में पेड़ के लिए किसी भी नोड्स जोड़ने नहीं कर रहे हैं!

इसका सबसे आसान रूट नोड के जोड़ने का प्रबंधन करने के स्पष्ट रूप से, जैसा कि आप देख मैं में नीचे किया insert।

एक find_placeसमारोह, नाम से शायद, माता पिता के नोड वापसी होगी और यह भी कि क्या यह बाईं या कुंजी के लिए सही स्लॉट है? मैं एक स्पष्ट कर दिया है _do_insertकि नीचे समारोह दोनों चलता है और डालने करता है।

तब से, अगर आप एक शाखा नीचे recurse पेड़, हर बार देखकर चलने के लिए की जरूरत है या आप एक खाली स्लॉट है, जहां आप नए नोड जोड़ने पहुँच गए हैं या नहीं।

यह (कहते हैं, दूर करता है और इस तरह के और कर) में पेड़ चलने के लिए जिम्मेदारी डाल करने के लिए अपने कोड refactor करने के लिए प्राकृतिक हो सकता है Nodeवर्ग।

नीचे दिए गए कोड में, मैं एक महत्वपूर्ण पेड़ में है कि पहले से ही जोड़ने की अनदेखी, मैं तो बस चुपचाप बाहर निकलें:

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