जब ट्री की मिरर कॉपी बनानी हो और इसे ब्रेडथ फर्स्ट सर्च का उपयोग करके प्रदर्शित करना हो, तो एक बाइनरी ट्री क्लास बनाई जाती है जिसमें रूट एलिमेंट सेट करने, लेफ्ट में एलिमेंट इंसर्ट करने, राइट में एलिमेंट इंसर्ट करने, विशिष्ट एलिमेंट खोजने और पोस्टऑर्डर ट्रैवर्सल करने आदि के लिए मेथड्स होते हैं। क्लास का एक इंस्टेंस बनाया जाता है और इसका उपयोग मेथड्स को एक्सेस करने के लिए किया जा सकता है।
उदाहरण
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_to_left(self, new_node):
self.left = new_node
def insert_to_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_elem(key)
if temp is not None:
return temp
if self.right is not None:
temp = self.right.search_elem(key)
return temp
return None
def copy_mirror(self):
mirror = BinaryTree_struct(self.key)
if self.right is not None:
mirror.left = self.right.copy_mirror()
if self.left is not None:
mirror.right = self.left.copy_mirror()
return mirror
def bfs(self):
queue = [self]
while queue != []:
popped = queue.pop(0)
if popped.left is not None:
queue.append(popped.left)
if popped.right is not None:
queue.append(popped.right)
print(popped.key, end=' ')
my_instance = None
print('मेन्यू (यह मानता है कोई डुप्लिकेट कीज़ नहीं)')
print('insert at root')
print('insert left of ')
print('insert right of ')
print('mirror')
print('quit')
while True:
my_input = input('आप कौन सा ऑपरेशन करेंगे? ').split()
operation = my_input[0].strip().lower()
if operation == 'insert':
data = int(my_input[1])
new_node = BinaryTree_struct(data)
suboperation = my_input[2].strip().lower()
if suboperation == 'at':
my_instance = new_node
else:
position = my_input[4].strip().lower()
key = int(position)
ref_node = None
if my_instance is not None:
ref_node = my_instance.search_elem(key)
if ref_node is None:
print('ऐसी कोई की नहीं है..')
continue
if suboperation == 'left':
ref_node.insert_to_left(new_node)
elif suboperation == 'right':
ref_node.insert_to_right(new_node)
elif operation == 'mirror':
if my_instance is not None:
print('मिरर कॉपी बनाई जा रही है...')
mirror = my_instance.copy_mirror()
print('मूल ट्री का ब्रेडथ फर्स्ट सर्च ट्रैवर्सल है:')
my_instance.bfs()
print()
print('मिरर का ब्रेडथ फर्स्ट ट्रैवर्सल है:')
mirror.bfs()
print()
elif operation == 'quit':
break
आउटपुट
मेन्यू (यह मानता है कोई डुप्लिकेट कीज़ नहीं) insert at root insert left of insert right of mirror quit आप कौन सा ऑपरेशन करेंगे? insert 6 at root आप कौन सा ऑपरेशन करेंगे? insert 9 left of 6 आप कौन सा ऑपरेशन करेंगे? insert 4 right of 6 आप कौन सा ऑपरेशन करेंगे? mirror मिरर कॉपी बनाई जा रही है... मूल ट्री का ब्रेडथ फर्स्ट सर्च ट्रैवर्सल है: 6 9 4 मिरर का ब्रेडथ फर्स्ट ट्रैवर्सल है: 6 4 9 आप कौन सा ऑपरेशन करेंगे? quit बाहर निकलने के लिए quit() या Ctrl-D (यानी EOF) का उपयोग करें
व्याख्या
आवश्यक एट्रिब्यूट्स के साथ 'BinaryTree_struct' क्लास बनाई जाती है।
इसमें एक 'init' फंक्शन होता है जिसका उपयोग लेफ्ट और राइट नोड्स को 'None' असाइन करने के लिए किया जाता है।
'set_root' मेथड परिभाषित की जाती है जो एक रूट नोड को मान असाइन करने में मदद करती है।
इसमें एक 'insert_to_left' मेथड होती है जो ट्री के लेफ्ट नोड में एलिमेंट्स जोड़ने में मदद करती है।
इसमें एक 'insert_to_right' मेथड होती है जो ट्री के राइट नोड्स में एलिमेंट्स जोड़ने में मदद करती है।
इसमें एक 'bfs' मेथड होती है जो ट्री पर ब्रेडथ फर्स्ट सर्च ट्रैवर्सल करने में मदद करती है।
'search_elem' नामक एक मेथड परिभाषित की जाती है जो किसी विशिष्ट एलिमेंट को खोजने में मदद करती है।
इसमें एक 'copy_mirror' मेथड होती है जो बाइनरी ट्री की कॉपी बनाने में मदद करती है।
एक इंस्टेंस बनाया जाता है और 'None' असाइन किया जाता है।
उपयोगकर्ता इनपुट उस ऑपरेशन के लिए लिया जाता है जिसे करने की आवश्यकता है।
उपयोगकर्ता की पसंद के आधार पर ऑपरेशन किया जाता है।
प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।
