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

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

उदाहरण

class BinaryTree_structure:
    def __init__(self, key=None):
        self.key = key
        self.left = None
        self.right = None

    def set_root(self, key):
        self.key = key

    def in_order_traversal(self):
        if self.left is not None:
            self.left.in_order_traversal()
        print(self.key, end=' ')
        if self.right is not None:
            self.right.in_order_traversal()

    def insert_left(self, new_node):
        self.left = new_node

    def insert_right(self, new_node):
        self.right = new_node

    def search_val(self, key):
        if self.key == key:
            return self
        if self.left is not None:
            temp = self.left.search_val(key)
            if temp is not None:
                return temp
        if self.right is not None:
            temp = self.right.search_val(key)
            return temp
        return None

btree = None
print('मेन्यू (यह मानता है कि कोई डुप्लिकेट कीज़ नहीं हैं)')
print('insert  at root')
print('insert  left of ')
print('insert  right of ')
print('quit')
while True:
    print('बाइनरी ट्री का इनऑर्डर ट्रैवर्सल: ', end='')
    if btree is not None:
        btree.in_order_traversal()
    print()
    do = input('आप क्या करना चाहेंगे? ').split()
    operation = do[0].strip().lower()
    if operation == 'insert':
        data = int(do[1])
        new_node = BinaryTree_structure(data)
        sub_op = do[2].strip().lower()
        if sub_op == 'at':
            btree = new_node
        else:
            position = do[4].strip().lower()
            key = int(position)
            ref_node = None
            if btree is not None:
                ref_node = btree.search_val(key)
            if ref_node is None:
                print('ऐसी कोई की मौजूद नहीं है')
                continue
            if sub_op == 'left':
                ref_node.insert_left(new_node)
            elif sub_op == 'right':
                ref_node.insert_right(new_node)
    elif operation == 'quit':
        break

आउटपुट

मेन्यू (यह मानता है कि कोई डुप्लिकेट कीज़ नहीं हैं)
insert  at root
insert  left of 
insert  right of 
quit
बाइनरी ट्री का इनऑर्डर ट्रैवर्सल: 
आप क्या करना चाहेंगे? insert 45 at root
बाइनरी ट्री का इनऑर्डर ट्रैवर्सल: 45
आप क्या करना चाहेंगे? insert 78 left of 45
बाइनरी ट्री का इनऑर्डर ट्रैवर्सल: 78 45
आप क्या करना चाहेंगे? insert 90 right of 45
बाइनरी ट्री का इनऑर्डर ट्रैवर्सल: 78 45 90
आप क्या करना चाहेंगे? quit

व्याख्या

• 'BinaryTree_structure' क्लास बनाई गई है।

• इसमें एक 'set_root' फंक्शन है जो ट्री के लिए रूट वैल्यू सेट करने में मदद करता है।

• 'in_order_traversal' नामक एक मेथड डिफाइन की गई है, जो ट्री को 'लेफ्ट->नोड->राइट' क्रम में ट्रैवर्स करने में मदद करती है।

• 'insert_left' नामक एक अन्य मेथड डिफाइन की गई है, जो रूट वैल्यू के बाईं ओर एलिमेंट जोड़ने में मदद करती है।

• 'insert_right' नामक एक अन्य मेथड डिफाइन की गई है, जो रूट वैल्यू के दाईं ओर एलिमेंट जोड़ने में मदद करती है।

• 'search_val' नामक एक अन्य मेथड डिफाइन की गई है, जो स्टैक के टॉप से वैल्यू डिलीट करने और डिलीट की गई वैल्यू रिटर्न करने में मदद करती है।

• चार विकल्प दिए गए हैं, जैसे 'insert at root', 'insert to left of', 'insert to right of' और 'quit'।

• यूज़र के इनपुट/चॉइस के आधार पर, संबंधित ऑपरेशन किए जाते हैं।

• यह आउटपुट कंसोल पर डिस्प्ले किया जाता है।