जब एक बाइनरी ट्री बनाने और उसमें तत्व डालने, हटाने और प्रदर्शित करने जैसे ऑपरेशन करने की आवश्यकता होती है, तो इसमें मेथड्स के साथ एक क्लास परिभाषित की जाती है। क्लास का एक इंस्टेंस बनाया जाता है और इसका उपयोग तत्वों तक पहुंचने और ऑपरेशन करने के लिए किया जाता है।
उदाहरण
class Tree_struct:
def __init__(self, data=None, parent=None):
self.key = data
self.children = []
self.parent = parent
def set_root(self, data):
self.key = data
def add_node(self, node):
self.children.append(node)
def search_node(self, key):
if self.key == key:
return self
for child in self.children:
temp = child.search_node(key)
if temp is not None:
return temp
return None
def remove_node(self):
parent = self.parent
index = parent.children.index(self)
parent.children.remove(self)
for child in reversed(self.children):
parent.children.insert(index, child)
child.parent = parent
def bfs(self):
queue = [self]
while queue != []:
popped = queue.pop(0)
for child in popped.children:
queue.append(child)
print(popped.key, end=' ')
my_instance = None
print('मेनू (यह मानता है कोई डुप्लिकेट कुंजी नहीं)')
print('add <data> at root')
print('add <data> below <data>')
print('remove <data>')
print('display')
print('quit')
while True:
do = input('आप क्या करना चाहेंगे? ').split()
operation = do[0].strip().lower()
if operation == 'add':
data = int(do[1])
new_node = Tree_struct(data)
suboperation = do[2].strip().lower()
if suboperation == 'at':
my_instance = new_node
elif suboperation == 'below':
position = do[3].strip().lower()
key = int(position)
ref_node = None
if my_instance is not None:
ref_node = my_instance.search_node(key)
if ref_node is None:
print('ऐसी कोई कुंजी नहीं।')
continue
new_node.parent = ref_node
ref_node.add_node(new_node)
elif operation == 'remove':
data = int(do[1])
to_remove = my_instance.search_node(data)
if my_instance == to_remove:
if my_instance.children == []:
my_instance = None
else:
leaf = my_instance.children[0]
while leaf.children != []:
leaf = leaf.children[0]
leaf.parent.children.remove_node(leaf)
leaf.parent = None
leaf.children = my_instance.children
my_instance = leaf
else:
to_remove.remove_node()
elif operation == 'display':
if my_instance is not None:
print('ब्रेडथ फर्स्ट सर्च ट्रैवर्सल है: ', end='')
my_instance.bfs()
print()
else:
print('ट्री खाली है')
elif operation == 'quit':
break
आउटपुट
मेनू (यह मानता है कोई डुप्लिकेट कुंजी नहीं) add <data> at root add <data> below <data> remove <data> display quit आप क्या करना चाहेंगे? add 5 at root आप क्या करना चाहेंगे? add 6 below 5 आप क्या करना चाहेंगे? add 8 below 6 आप क्या करना चाहेंगे? remove 8 आप क्या करना चाहेंगे? display ब्रेडथ फर्स्ट सर्च ट्रैवर्सल है: 5 6 आप क्या करना चाहेंगे? quit
व्याख्या
आवश्यक विशेषताओं के साथ 'Tree_struct' क्लास बनाई गई है।
इसमें एक खाली सूची बनाने के लिए 'init' फ़ंक्शन है।
'set_root' नामक एक अन्य मेथड ट्री की जड़ निर्दिष्ट करने के लिए परिभाषित की गई है।
'add_node' नामक एक अन्य मेथड ट्री में नोड्स जोड़ने में मदद करता है।
'search_node' नामक एक अन्य मेथड एक विशिष्ट तत्व खोजने में मदद करता है।
'remove_node' नामक एक मेथड ट्री से तत्वों को हटाने के लिए परिभाषित किया गया है।
'bfs' नामक एक अन्य मेथड ट्री पर ब्रेडथ फर्स्ट सर्च करने में मदद करता है।
एक इंस्टेंस बनाया जाता है और 'None' को असाइन किया जाता है।
उपयोगकर्ता इनपुट लिया जाता है कि कौन सा ऑपरेशन करना है।
उपयोगकर्ता की पसंद के आधार पर, ऑपरेशन किया जाता है।
प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।
नोट: यह एक सामान्य ट्री है, बाइनरी ट्री नहीं
कोड में Tree_struct क्लास एक सामान्य ट्री (General Tree) लागू करती है जहां प्रत्येक नोड के कई बच्चे हो सकते हैं (self.children सूची)। एक वास्तविक बाइनरी ट्री में प्रत्येक नोड के अधिकतम 2 बच्चे होते हैं (बाएं और दाएं)।
बाइनरी ट्री कार्यान्वयन के लिए
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
