Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन प्रोग्राम: N नोड्स की डबल लिंक्ड लिस्ट बनाएं और रिवर्स ऑर्डर में प्रदर्शित करें


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

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

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

उदाहरण

class Node:
    def __init__(self, my_data):
        self.prev = None
        self.data = my_data
        self.next = None

class ReverseList:
    def __init__(self):
        self.head = None
        self.tail = None
    def add_data(self, my_data):
        new_node = Node(my_data)
        if(self.head == None):
            self.head = self.tail = new_node
            self.head.previous = None
            self.tail.next = None
        else:
            self.tail.next = new_node
            new_node.previous = self.tail
            self.tail = new_node
            self.tail.next = None
    def reverse_vals(self):
        curr = self.head
        while(curr != None):
            temp = curr.next
            curr.next = curr.previous
            curr.previous = temp
            curr = curr.previous
        temp = self.head
        self.head = self.tail
        self.tail = temp
    def print_it(self):
        curr = self.head
        if (self.head == None):
            print("सूची खाली है")
            return
        print("नोड्स हैं:")
        while curr != None:
            print(curr.data)
            curr = curr.next

my_instance = ReverseList()
print("एलिमेंट्स सूची में जोड़े जा रहे हैं")
my_instance.add_data(10)
my_instance.add_data(14)
my_instance.add_data(24)
my_instance.add_data(17)
my_instance.add_data(22)
my_instance.print_it()
print("डबल लिंक्ड लिस्ट में रिवर्स नोड्स हैं: ")
my_instance.reverse_vals()
my_instance.print_it()

आउटपुट

एलिमेंट्स सूची में जोड़े जा रहे हैं
नोड्स हैं:
10
14
24
17
22
डबल लिंक्ड लिस्ट में रिवर्स नोड्स हैं:
नोड्स हैं:
22
17
24
14
10

व्याख्या

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

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

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

  1. - लिंक्ड लिस्ट के आंतरिक नोड्स को उल्टा करने का पायथन प्रोग्राम

    मान लीजिए हमारे पास एक लिंक्ड लिस्ट है, हमारे पास i और j दो मान भी हैं, हमें लिंक्ड लिस्ट को i से jवें नोड्स तक उल्टा करना है। और अंत में अपडेटेड लिस्ट लौटाएं। उदाहरण के लिए, यदि इनपुट [1,2,3,4,5,6,7,8,9] i = 2 j = 6 है, तो आउटपुट [1, 2, 7, 6, 5, 4, 3, 8, 9] होगा। इसे हल करने के लिए, हम निम्न चरणों

  1. - पायथन में लिंक्ड लिस्ट को उलटने का प्रोग्राम

    2 होगी।इसे हल करने के लिए, हम इस दृष्टिकोण का पालन करेंगे −सूची को रिकर्सिव तरीके से उलटने के लिए एक प्रक्रिया परिभाषित करें solve(head, back)यदि head मौजूद नहीं है, तो head वापस करेंtemp := head.nexthead.next := backback := headयदि temp खाली है, तो head वापस करेंhead := tempsolve(head, back)