यह नए डेवलपर्स को देने के लिए एक पसंदीदा प्रश्न है। यदि आपके पास एक अच्छा डेटा संरचना वर्ग है तो यह बहुत आसान है।

एकल लिंक की गई सूची को उलट दें। (यह लीटकोड 206 है)

कार्यान्वयन के लिए, मैंने लिंक की गई सूची को एक सामान्य प्रकार बनाना चुना है।

type Node[T any] struct {
    Data T
    Next *Node[T]
}

type LinkedList[T any] struct {
    Head *Node[T]
}

func (ll *LinkedList[T]) Append(data T) {
    newNode := &Node[T]{Data: data, Next: nil}

    if ll.Head == nil {
        ll.Head = newNode
        return
    }

    current := ll.Head
    for current.Next != nil {
        current = current.Next
    }
    current.Next = newNode
}

और रिवर्स फ़ंक्शन के लिए, यह एक ही पास के साथ किया जाता है, यह पहचानते हुए कि हमें बस पिछले नोड के लिए एक पॉइंटर बनाए रखना है, फिर दिए गए नोड के 'अगले' को पिछले पर सेट करना है।

जब हम अंत तक पहुंचते हैं, तब हमें पता चलता है कि वर्तमान नोड सूची का नया 'प्रमुख' है।

func (ll *LinkedList[T]) ReverseLinkedList() {
    var prev *Node[T] = nil
    var ptr *Node[T] = ll.Head
    for ptr != nil {
        var next *Node[T] = ptr.Next
        ptr.Next = prev
        prev = ptr
        if next == nil {
            ll.Head = ptr
        }
        ptr = next
    }
}

क्या हम सीमा की स्थिति से चूक गए हैं? यदि सूची अब दोहरी रूप से जुड़ी हुई सूची है तो क्या जटिलताएँ जुड़ जाती हैं? टिप्पणियों में क्या है मुझे जानने दें।

धन्यवाद!

इस पोस्ट और इस श्रृंखला के सभी पोस्ट का कोड यहां पाया जा सकता है