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

जब दिए गए बाइनरी ट्री को डबल लिंक्ड लिस्ट में बदलने की आवश्यकता होती है, तो एक 'Node' क्लास बनाने की आवश्यकता होती है। इस क्लास में दो एट्रिब्यूट्स होते हैं, नोड में मौजूद डेटा, और लिंक्ड लिस्ट के अगले नोड तक पहुंच।

एक और 'linked_list' क्लास बनाने की आवश्यकता होती है जिसमें एक इनिशियलाइज़ेशन फ़ंक्शन होगा, और नोड का हेड 'None' से इनिशियलाइज़ किया जाएगा।

डबल लिंक्ड लिस्ट में, नोड्स में पॉइंटर्स होते हैं। वर्तमान नोड में अगले नोड के साथ-साथ पिछले नोड का पॉइंटर होगा। सूची में अंतिम मान का अगले पॉइंटर में 'NULL' मान होगा। इसे दोनों दिशाओं में ट्रैवर्स किया जा सकता है।

बाइनरी ट्री एक नॉन-लीनियर डेटा स्ट्रक्चर है, जिसमें एक रूट नोड होता है और रूट को छोड़कर हर नोड का एक पैरेंट नोड हो सकता है। एक बाइनरी ट्री नोड में अधिकतम दो बच्चे हो सकते हैं।

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

उदाहरण

class Node:
    def __init__(self, my_data):
        self.right = None
        self.data = my_data
        self.left = None

class BinaryTreeToList:
    def __init__(self):
        self.root = None
        self.head = None
        self.tail = None
    def convert_tree_to_list(self, node_val):
        if node_val is None:
            return
        self.convert_tree_to_list(node_val.left)
        if (self.head == None):
            self.head = self.tail = node_val
        else:
            self.tail.right = node_val
            node_val.left = self.tail
            self.tail = node_val
        self.convert_tree_to_list(node_val.right)
    def print_it(self):
        curr = self.head
        if (self.head == None):
            print("सूची खाली है")
            return
        print("नोड्स हैं:")
        while curr != None:
            print(curr.data)
            curr = curr.right

my_instance = BinaryTreeToList()
print("एलिमेंट्स सूची में जोड़े जा रहे हैं")
my_instance.root = Node(10)
my_instance.root.left = Node(14)
my_instance.root.right = Node(17)
my_instance.root.left.left = Node(22)
my_instance.root.left.right = Node(29)
my_instance.root.right.left = Node(45)
my_instance.root.right.right = Node(80)
my_instance.convert_tree_to_list(my_instance.root)
my_instance.print_it()

आउटपुट

एलिमेंट्स सूची में जोड़े जा रहे हैं
नोड्स हैं:
22
14
29
10
45
17
80

व्याख्या

• 'Node' क्लास बनाई जाती है।
• आवश्यक एट्रिब्यूट्स के साथ एक और क्लास बनाई जाती है।
• 'convert_tree_to_list' नामक एक और मेथड परिभाषित किया गया है, जिसका उपयोग दिए गए बाइनरी ट्री को डबल लिंक्ड लिस्ट में बदलने के लिए किया जाता है।
• 'print_it' नामक एक और मेथड परिभाषित किया गया है, जो सर्कुलर लिंक्ड लिस्ट के नोड्स प्रदर्शित करता है।
• 'binary_tree_to_list' क्लास का एक ऑब्जेक्ट बनाया जाता है, और ट्री को डबल लिंक्ड लिस्ट में बदलने के लिए उस पर मेथड्स कॉल किए जाते हैं।
• एक 'init' मेथड परिभाषित किया जाता है, जो डबल लिंक्ड लिस्ट के रूट, हेड, और टेल नोड्स को None पर सेट करता है।
• 'convert_tree_to_list' मेथड को कॉल किया जाता है।
• यह बाइनरी ट्री के माध्यम से पुनरावृति करता है, और इसे डबल लिंक्ड लिस्ट में बदलता है।
• इसे 'print_it' मेथड का उपयोग करके कंसोल पर प्रदर्शित किया जाता है।