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

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

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

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

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

उदाहरण

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

class TernaryTreeToList:
    def __init__(self):
        self.root = None
        self.head = None
        self.tail = None
    def convert_ternary_tree_to_list(self, node_val):
        if node_val is None:
            return
        left = node_val.left
        mid = node_val.mid
        right = node_val.right
        if (self.head == None):
            self.head = self.tail = node_val
            node_val.middle = None
            self.head.left = None
            self.head.right = None
        else:
            self.tail.right = node_val
            node_val.left = self.tail
            node_val.mid = None
            self.tail = node_val
            self.tail.right = None
        self.convert_ternary_tree_to_list(left)
        self.convert_ternary_tree_to_list(mid)
        self.convert_ternary_tree_to_list(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 = TernaryTreeToList()
print("एलिमेंट्स सूची में जोड़े जा रहे हैं")
my_instance.root = Node(10)
my_instance.root.left = Node(14)
my_instance.root.mid = Node(24)
my_instance.root.right = Node(17)
my_instance.root.left.left = Node(22)
my_instance.root.left.mid = Node(23)
my_instance.root.mid.left = Node(24)
my_instance.root.mid.mid = Node(28)
my_instance.root.mid.right = Node(30)
my_instance.root.right.left = Node(45)
my_instance.root.right.mid = Node(50)
my_instance.root.right.right = Node(80)
my_instance.convert_ternary_tree_to_list(my_instance.root)
my_instance.print_it()

आउटपुट

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

व्याख्या

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