जब रिकर्सन का उपयोग करके किसी पेड़ पर गहराई से पहली खोज करने की आवश्यकता होती है, तो एक वर्ग परिभाषित किया जाता है, और उस पर विधियों को परिभाषित किया जाता है जो चौड़ाई पहली खोज करने में सहायता करते हैं।
नीचे उसी के लिए एक प्रदर्शन है -
उदाहरण
class BinaryTree_struct:
def __init__(self, key=None):
self.key = key
self.left = None
self.right = None
def set_root(self, key):
self.key = key
def insert_at_left(self, new_node):
self.left = new_node
def insert_at_right(self, new_node):
self.right = new_node
def search_elem(self, key):
if self.key == key:
return self
if self.left is not None:
temp = self.left.search(key)
if temp is not None:
return temp
if self.right is not None:
temp = self.right.search(key)
return temp
return None
def depth_first_search(self):
print('entering {}...'.format(self.key))
if self.left is not None:
self.left.depth_first_search()
print('at {}...'.format(self.key))
if self.right is not None:
self.right.depth_first_search()
print('leaving {}...'.format(self.key))
btree_instance = None
print('Menu (no duplicate keys)')
print('insert <data> at root')
print('insert <data> left of <data>')
print('insert <data> right of <data>')
print('dfs')
print('quit')
while True:
my_input = input('What would you like to do? ').split()
op = my_input[0].strip().lower()
if op == 'insert':
data = int(my_input[1])
new_node = BinaryTree_struct(data)
sub_op = my_input[2].strip().lower()
if sub_op == 'at':
btree_instance = new_node
else:
position = my_input[4].strip().lower()
key = int(position)
ref_node = None
if btree_instance is not None:
ref_node = btree_instance.search_elem(key)
if ref_node is None:
print('No such key.')
continue
if sub_op == 'left':
ref_node.insert_at_left(new_node)
elif sub_op == 'right':
ref_node.insert_at_right(new_node)
elif op == 'dfs':
print('depth-first search traversal:')
if btree_instance is not None:
btree_instance.depth_first_search()
print()
elif op == 'quit':
break आउटपुट
Menu (no duplicate keys) insert <data> at root insert <data> left of <data> insert <data> right of <data> dfs quit What would you like to do? insert 5 at root What would you like to do? insert 6 left of 5 What would you like to do? insert 8 right of 5 What would you like to do? dfs depth-first search traversal: entering 5... entering 6... at 6... leaving 6... at 5... entering 8... at 8... leaving 8... leaving 5... What would you like to do? quit Use quit() or Ctrl-D (i.e. EOF) to exit
स्पष्टीकरण
-
आवश्यक विशेषताओं के साथ 'BinaryTree_struct' वर्ग बनाया गया है।
-
इसमें एक 'init' फंक्शन है जिसका इस्तेमाल 'बाएं' और 'राइट' नोड्स को 'कोई नहीं' असाइन करने के लिए किया जाता है।
-
पेड़ की जड़ को निर्दिष्ट करने के लिए 'set_root' नामक एक अन्य विधि को परिभाषित किया गया है।
-
'insert_at_left' नाम की एक अन्य विधि परिभाषित की गई है जो पेड़ के बाईं ओर नोड्स जोड़ने में मदद करती है।
-
'insert_at_right' नाम की एक अन्य विधि परिभाषित की गई है जो पेड़ के दाईं ओर नोड्स जोड़ने में मदद करती है।
-
'Search_elem' नामक एक अन्य विधि को परिभाषित किया गया है जो एक विशिष्ट तत्व की खोज में मदद करता है।
-
'डेप्थ_फर्स्ट_सर्च' नाम की एक विधि परिभाषित की गई है, जो बाइनरी ट्री पर डेप्थ फर्स्ट सर्च करने में मदद करती है।
-
कक्षा का एक उदाहरण बनाया जाता है और 'कोई नहीं' को सौंपा जाता है।
-
एक मेनू दिया गया है।
-
उपयोगकर्ता इनपुट उस ऑपरेशन के लिए लिया जाता है जिसे निष्पादित करने की आवश्यकता होती है।
-
उपयोगकर्ता की पसंद के आधार पर, ऑपरेशन किया जाता है।
-
प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।
