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

जब एक सिंगली लिंक्ड लिस्ट को सर्कुलर लिंक्ड लिस्ट में बदलने की आवश्यकता होती है, तो 'convert_to_circular_list' नामक एक मेथड परिभाषित की जाती है जो सुनिश्चित करती है कि अंतिम तत्व पहले तत्व को इंगित करे, जिससे यह प्रकृति में सर्कुलर बन जाता है।

उदाहरण

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

class LinkedList_struct:
    def __init__(self):
        self.head = None
        self.last_node = None

    def add_elements(self, data):
        if self.last_node is None:
            self.head = Node(data)
            self.last_node = self.head
        else:
            self.last_node.next = Node(data)
            self.last_node = self.last_node.next

def convert_to_circular_list(my_list):
    if my_list.last_node:
        my_list.last_node.next = my_list.head

def last_node_points(my_list):
    last = my_list.last_node
    if last is None:
        print('सूची खाली है...')
        return
    if last.next is None:
        print('अंतिम नोड None को इंगित करता है...')
    else:
        print('अंतिम नोड उस तत्व को इंगित करता है जिसमें {} है...'.format(last.next.data))

my_instance = LinkedList_struct()
my_input = input('लिंक्ड लिस्ट के तत्व दर्ज करें... ').split()
for data in my_input:
    my_instance.add_elements(int(data))

last_node_points(my_instance)
print('लिंक्ड लिस्ट को सर्कुलर लिंक्ड लिस्ट में बदला जा रहा है...')
convert_to_circular_list(my_instance)
last_node_points(my_instance)

आउटपुट

लिंक्ड लिस्ट के तत्व दर्ज करें... 56 32 11 45 90 87
अंतिम नोड None को इंगित करता है...
लिंक्ड लिस्ट को सर्कुलर लिंक्ड लिस्ट में बदला जा रहा है...
अंतिम नोड उस तत्व को इंगित करता है जिसमें 56 है...

व्याख्या

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

• आवश्यक विशेषताओं के साथ एक अन्य 'LinkedList_struct' क्लास बनाई गई है।

• इसमें एक 'init' फ़ंक्शन है जो पहले तत्व, यानी 'head' को 'None' और अंतिम नोड को 'None' पर इनिशियलाइज़ करता है।

• 'add_elements' नामक एक अन्य मेथड परिभाषित की गई है, जिसका उपयोग लिंक्ड लिस्ट में पिछले नोड को प्राप्त करने के लिए किया जाता है।

• 'convert_to_circular_list' नामक एक अन्य मेथड परिभाषित की गई है जो अंतिम नोड को पहले नोड पर इंगित करती है, जिससे यह प्रकृति में सर्कुलर बन जाता है।

• 'last_node_points' नामक एक मेथड परिभाषित की गई है, जो जांचती है कि सूची खाली है, या अंतिम नोड 'None' को इंगित करता है, या यह लिंक्ड लिस्ट के एक विशिष्ट नोड को इंगित करता है।

• 'LinkedList_struct' क्लास का एक ऑब्जेक्ट बनाया जाता है।

• लिंक्ड लिस्ट में तत्वों के लिए उपयोगकर्ता इनपुट लिया जाता है।

• तत्वों को लिंक्ड लिस्ट में जोड़ा जाता है।

• इस लिंक्ड लिस्ट पर 'last_node_points' मेथड कॉल की जाती है।

• प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।

सर्कुलर लिंक्ड लिस्ट के लाभ

• किसी भी नोड से पूरी सूची को ट्रैवर्स किया जा सकता है

• राउंड-रॉबिन शेड्यूलिंग के लिए उपयोगी

• कतार कार्यान्वयन के लिए कुशल (कोई NULL चेक नहीं)

• बफर/कैश कार्यान्वयन के लिए उपयुक्त

सर्कुलर लिंक्ड लिस्ट में ट्रैवर्सल

def traverse_circular(self):
    if self.head is None:
        return
    current = self.head
    while True:
        print(current.data, end=' ')
        current = current.next
        if current == self.head:
            break
    print()

सावधानी

सर्कुलर लिंक्ड लिस्ट में अनंत लूप से बचने के लिए ट्रैवर्सल में टर्मिनेशन कंडीशन (current == head) आवश्यक है।