Go में एल्गोरिदम और डेटा संरचनाएँ: व्यावहारिक गाइड

Go में एल्गोरिदम और डेटा संरचनाएँ: व्यावहारिक गाइड

Go (Golang) एक कंपाइल्ड, स्टैटिकली टाइप की गई भाषा है जिसे Google ने बनाया है। इसकी सादगी, उच्च प्रदर्शन और बिल्ट-इन कंकरेंसी सपोर्ट इसे backend डेवलपमेंट, माइक्रोसर्विसेज और सिस्टम प्रोग्रामिंग के लिए एक बेहतरीन विकल्प बनाते हैं। हालांकि, Go में कुशल कोड लिखने के लिए सिर्फ सिंटैक्स जानना काफी नहीं है — यह समझना जरूरी है कि एल्गोरिदम और डेटा संरचनाएँ कैसे काम करती हैं। इस लेख में हम Go की प्रमुख डेटा संरचनाओं और एल्गोरिदम को प्रैक्टिकल उदाहरणों के साथ समझेंगे।

1. Go में स्टैक (Stack)

स्टैक एक डेटा संरचना है जो LIFO (Last In, First Out) सिद्धांत पर काम करती है। Go में कोई बिल्ट-इन "स्टैक" टाइप नहीं है, लेकिन इसे slice की मदद से आसानी से इम्प्लीमेंट किया जा सकता है।

स्टैक इम्प्लीमेंटेशन का उदाहरण:

package main\n\nimport "fmt"\n\ntype Stack struct {\n    items []int\n}\n\n// Push स्टैक के ऊपर एक एलिमेंट जोड़ता है\nfunc (s *Stack) Push(item int) {\n    s.items = append(s.items, item)\n}\n\n// Pop स्टैक के ऊपर से एलिमेंट हटाकर लौटाता है\nfunc (s *Stack) Pop() (int, bool) {\n    if len(s.items) == 0 {\n        return 0, false\n    }\n    lastIndex := len(s.items) - 1\n    item := s.items[lastIndex]\n    s.items = s.items[:lastIndex]\n    return item, true\n}\n\n// Peek बिना हटाए स्टैक के ऊपर का एलिमेंट दिखाता है\nfunc (s *Stack) Peek() (int, bool) {\n    if len(s.items) == 0 {\n        return 0, false\n    }\n    return s.items[len(s.items)-1], true\n}\n\nfunc main() {\n    stack := Stack{}\n    stack.Push(10)\n    stack.Push(20)\n    stack.Push(30)\n\n    item, ok := stack.Pop()\n    if ok {\n        fmt.Println("निकाला गया:", item) // 30\n    }\n    fmt.Println("स्टैक का शीर्ष:", stack.Peek()) // 20\n}

Go में स्टैक Push और Pop ऑपरेशन के लिए O(1) की एमॉर्टाइज्ड कॉम्प्लेक्सिटी के साथ कुशल है। इसका उपयोग ब्रैकेट सीक्वेंस की जाँच या undo (पूर्ववत) कार्यों जैसे कार्यों के लिए करें।

2. Go में क्यू (Queue)

क्यू FIFO (First In, First Out) सिद्धांत पर काम करती है। इसे शुरुआत और अंत के पॉइंटर्स के साथ slice के आधार पर इम्प्लीमेंट करते हैं।

क्यू इम्प्लीमेंटेशन का उदाहरण:

package main\n\nimport "fmt"\n\ntype Queue struct {\n    items []int\n}\n\n// Enqueue क्यू के अंत में एलिमेंट जोड़ता है\nfunc (q *Queue) Enqueue(item int) {\n    q.items = append(q.items, item)\n}\n\n// Dequeue क्यू की शुरुआत से एलिमेंट हटाकर लौटाता है\nfunc (q *Queue) Dequeue() (int, bool) {\n    if len(q.items) == 0 {\n        return 0, false\n    }\n    item := q.items[0]\n    q.items = q.items[1:]\n    return item, true\n}\n\n// Front बिना हटाए पहला एलिमेंट दिखाता है\nfunc (q *Queue) Front() (int, bool) {\n    if len(q.items) == 0 {\n        return 0, false\n    }\n    return q.items[0], true\n}\n\nfunc main() {\n    queue := Queue{}\n    queue.Enqueue(1)\n    queue.Enqueue(2)\n    queue.Enqueue(3)\n\n    item, ok := queue.Dequeue()\n    if ok {\n        fmt.Println("निकाला गया:", item) // 1\n    }\n    fmt.Println("क्यू में पहला:", queue.Front()) // 2\n}

ध्यान दें: इस इम्प्लीमेंटेशन में Dequeue ऑपरेशन की कॉम्प्लेक्सिटी O(n) है, क्योंकि पहले एलिमेंट को हटाने पर पूरा slice शिफ्ट होता है। प्रोडक्शन कोड के लिए रिंग बफर (ring buffer) या डबली लिंक्ड लिस्ट (container/list) का उपयोग करें।

3. Go में बबल सॉर्ट (Bubble Sort)

बबल सॉर्ट सबसे सरल लेकिन अकुशल एल्गोरिदम में से एक है। फिर भी, यह सीखने के लिए बहुत अच्छा है। कॉम्प्लेक्सिटी: O(n²)।

package main\n\nimport "fmt"\n\nfunc bubbleSort(arr []int) {\n    n := len(arr)\n    for i := 0; i < n-1; i++ {\n        swapped := false\n        for j := 0; j < n-i-1; j++ {\n            if arr[j] > arr[j+1] {\n                arr[j], arr[j+1] = arr[j+1], arr[j]\n                swapped = true\n            }\n        }\n        // अगर कोई स्वैप नहीं हुआ — ऐरे पहले से सॉर्टेड है\n        if !swapped {\n            break\n        }\n    }\n}\n\nfunc main() {\n    data := []int{64, 34, 25, 12, 22, 11, 90}\n    bubbleSort(data)\n    fmt.Println("सॉर्टेड ऐरे:", data)\n}

बबल सॉर्ट छोटे डेटासेट के लिए उपयोगी है, लेकिन बड़े डेटा के लिए क्विक सॉर्ट या मर्ज सॉर्ट जैसे अधिक कुशल एल्गोरिदम का उपयोग करें।