केवल लेफ्ट सबट्री में नोड्स प्रिंट करने का पायथन प्रोग्राम

जब लेफ्ट सबट्री में नोड्स प्रिंट करने हों, तो एक क्लास बनाई जा सकती है जिसमें रूट नोड सेट करने, इनऑर्डर ट्रैवर्सल करने, रूट नोड के दाईं ओर एलिमेंट्स इंसर्ट करने, रूट नोड के बाईं ओर एलिमेंट्स इंसर्ट करने आदि के लिए मेथड्स परिभाषित की जा सकती हैं। क्लास का एक इंस्टेंस बनाया जाता है और मेथड्स का उपयोग आवश्यक ऑपरेशन करने के लिए किया जा सकता है।

उदाहरण

class BinaryTree_struct:
    def __init__(self, data=None):
        self.key = data
        self.left = None
        self.right = None
    def set_root(self, data):
        self.key = data
    def inorder_traversal(self):
        if self.left is not None:
            self.left.inorder_traversal()
        print(self.key, end=' ')
        if self.right is not None:
            self.right.inorder_traversal()
    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_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 print_left_part(self):
        if self.left is not None:
            self.left.inorder_traversal()

my_instance = None
print('मेन्यू (यह मानता है कोई डुप्लिकेट कीज़ नहीं)')
print('insert  at root')
print('insert  left of ')
print('insert  right of ')
print('left')
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_at_left(new_node)
            elif suboperation == 'right':
                ref_node.insert_at_right(new_node)
    elif operation == 'left':
        print('लेफ्ट सबट्री के नोड्स हैं:', end='')
        if my_instance is not None:
            my_instance.print_left_part()
        print()
    elif operation == 'quit':
        break

आउटपुट

मेन्यू (यह मानता है कोई डुप्लिकेट कीज़ नहीं)
insert  at root
insert  left of 
insert  right of 
left
quit
आप कौन सा ऑपरेशन करेंगे? insert 5 at root
आप कौन सा ऑपरेशन करेंगे? insert 6 left of 5
आप कौन सा ऑपरेशन करेंगे? insert 8 right of 5
आप कौन सा ऑपरेशन करेंगे? left
लेफ्ट सबट्री के नोड्स हैं: 6
आप कौन सा ऑपरेशन करेंगे? quit
बाहर निकलने के लिए quit() या Ctrl-D (यानी EOF) का उपयोग करें

व्याख्या

• आवश्यक एट्रिब्यूट्स के साथ 'BinaryTree_struct' क्लास बनाई जाती है।

• इसमें एक 'init' फंक्शन होता है जिसका उपयोग लेफ्ट और राइट नोड्स को 'None' असाइन करने के लिए किया जाता है।

• 'set_root' मेथड परिभाषित की जाती है जो बाइनरी ट्री के रूट मान को सेट करने में मदद करती है।

• इसमें एक 'insert_at_right' मेथड होती है जो ट्री के राइट नोड्स में एलिमेंट्स जोड़ने में मदद करती है।

• इसमें एक 'insert_at_left' मेथड होती है जो ट्री के लेफ्ट नोड्स में एलिमेंट्स जोड़ने में मदद करती है।

• 'inorder_traversal' नामक एक अन्य मेथड जो इनऑर्डर ट्रैवर्सल करती है।

• 'search_elem' नामक एक मेथड परिभाषित की जाती है जो किसी विशिष्ट एलिमेंट को खोजने में मदद करती है।

• 'print_left_part' नामक एक अन्य मेथड परिभाषित की जाती है जो कंसोल पर बाइनरी ट्री के केवल लेफ्ट पार्ट को प्रदर्शित करने में मदद करती है।

• एक इंस्टेंस बनाया जाता है और 'None' असाइन किया जाता है।

• उपयोगकर्ता इनपुट उस ऑपरेशन के लिए लिया जाता है जिसे करने की आवश्यकता है।

• उपयोगकर्ता की पसंद के आधार पर ऑपरेशन किया जाता है।

• प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।