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

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

सर्कुलर लिंक्ड लिस्ट में, हेड और रियर एक-दूसरे से सटे होते हैं। वे एक सर्कल बनाने के लिए जुड़े होते हैं, और अंतिम नोड में 'NULL' मान नहीं होता।

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

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

उदाहरण

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

class ListCreation:
    def __init__(self):
        self.head = Node(None)
        self.tail = Node(None)
        self.head.next = self.tail
        self.tail.next = self.head
    def add_data(self, my_data):
        new_node = Node(my_data)
        if self.head.data is None:
            self.head = new_node
            self.tail = new_node
            new_node.next = self.head
        else:
            self.tail.next = new_node
            self.tail = new_node
            self.tail.next = self.head
    def sort_list(self):
        curr = self.head
        if(self.head == None):
            print("सूची खाली है")
        else:
            while(True):
                index_val = curr.next
                while(index_val != self.head):
                    if(curr.data > index_val.data):
                        temp = curr.data
                        curr.data = index_val.data
                        index_val.data = temp
                    index_val = index_val.next
                curr = curr.next
                if(curr.next == self.head):
                    break
    def print_it(self):
        curr = self.head
        if self.head is None:
            print("सूची खाली है")
            return
        else:
            print(curr.data)
            while(curr.next != self.head):
                curr = curr.next
                print(curr.data)
            print("\n")

class CircularLinkedList:
    my_cl = ListCreation()
    print("नोड्स सूची में जोड़े जा रहे हैं")
    my_cl.add_data(21)
    my_cl.add_data(54)
    my_cl.add_data(78)
    my_cl.add_data(99)
    my_cl.add_data(27)
    print("सूची है:")
    my_cl.print_it()
    print("सूची क्रमबद्ध की जा रही है")
    my_cl.sort_list()
    print("क्रमबद्ध सूची है: ")
    my_cl.print_it()

आउटपुट

नोड्स सूची में जोड़े जा रहे हैं
सूची है:
21
54
78
99
27
सूची क्रमबद्ध की जा रही है
क्रमबद्ध सूची है:
21
27
54
78
99

व्याख्या

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