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

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

Swift — Apple द्वारा iOS, macOS, watchOS और tvOS के विकास के लिए बनाई गई एक शक्तिशाली और सहज प्रोग्रामिंग भाषा है। हालाँकि, सिंटैक्स और फ्रेमवर्क का ज्ञान केवल आधी सफलता है। कुशल, तेज़ और स्केलेबल एप्लिकेशन लिखने के लिए, यह समझना आवश्यक है कि एल्गोरिदम और डेटा संरचनाएँ कैसे काम करती हैं। इस लेख में, हम Swift में कोड के विशिष्ट उदाहरणों के साथ मुख्य अवधारणाओं पर चर्चा करेंगे। आप सीखेंगे कि स्टैक, क्यू, सॉर्टिंग एल्गोरिदम और बाइनरी सर्च को कैसे लागू किया जाए, और यह ज्ञान वास्तविक विकास में कहाँ उपयोग होता है।

Swift में स्टैक (Stack): LIFO क्रियान्वयन

स्टैक एक संग्रह है जो "अंतिम आया, पहला गया" (LIFO) सिद्धांत पर काम करता है। प्लेटों के ढेर की कल्पना करें: आप केवल ऊपर वाली प्लेट लेते हैं। iOS में, स्टैक का उपयोग नेविगेशन (UINavigationController) या क्रियाओं को पूर्ववत करने (Undo) के लिए किया जाता है।

जेनेरिक का उपयोग करके Swift में स्टैक लागू करें:

struct Stack<Element> {    private var elements: [Element] = []        mutating func push(_ element: Element) {        elements.append(element)    }        @discardableResult    mutating func pop() -> Element? {        return elements.popLast()    }        func peek() -> Element? {        return elements.last    }        var isEmpty: Bool {        return elements.isEmpty    }        var count: Int {        return elements.count    }}

// उपयोग का उदाहरणvar stack = Stack<String>()stack.push("पहला")stack.push("दूसरा")stack.push("तीसरा")

print(stack.pop()!) // तीसराprint(stack.peek()!) // दूसरा

कहाँ उपयोग होता है? ब्राउज़िंग इतिहास प्रदर्शित करने वाले एप्लिकेशन में, पार्सर में (कोष्ठक जाँच), ग्राफ़ ट्रैवर्सल एल्गोरिदम (DFS) में।

क्यू (Queue): कार्य प्रसंस्करण के लिए FIFO

क्यू "पहला आया, पहला गया" (FIFO) सिद्धांत पर काम करता है। जैसे दुकान में कतार: जो पहले खड़ा होता है, उसे पहले सेवा मिलती है। Swift में, क्यू का उपयोग अक्सर कार्य प्रबंधन (DispatchQueue), नेटवर्क अनुरोधों या एनिमेशन के प्रसंस्करण के लिए किया जाता है।

क्यू का मूल कार्यान्वयन:

struct Queue<Element> {    private var elements: [Element] = []        mutating func enqueue(_ element: Element) {        elements.append(element)    }        @discardableResult    mutating func dequeue() -> Element? {        return isEmpty ? nil : elements.removeFirst()    }        func front() -> Element? {        return elements.first    }        var isEmpty: Bool {        return elements.isEmpty    }        var count: Int {        return elements.count    }}

// उपयोग का उदाहरणvar queue = Queue<Int>()queue.enqueue(1)queue.enqueue(2)queue.enqueue(3)

print(queue.dequeue()!) // 1print(queue.front()!)   // 2

प्रदर्शन समस्या: ऐरे पर removeFirst() की जटिलता O(n) है, क्योंकि सभी तत्व स्थानांतरित हो जाते हैं। उच्च प्रदर्शन के लिए ContiguousArray या दो-तरफ़ा क्यू (deque) का उपयोग करें। वास्तविक परियोजनाओं में, Apple मल्टीथ्रेडिंग के लिए DispatchQueue की सिफारिश करता है।

सॉर्टिंग एल्गोरिदम: बबल से क्विक सॉर्ट तक

सॉर्टिंग सबसे सामान्य कार्यों में से एक है। Swift में बिल्ट-इन sort() है, लेकिन आंतरिक तंत्र को समझने से आपको किसी विशिष्ट कार्य के लिए इष्टतम एल्गोरिदम चुनने में मदद मिलेगी।

बबल सॉर्ट (Bubble Sort) — O(n²)

सरल, लेकिन धीमा एल्गोरिदम। सीखने के लिए उपयोगी, लेकिन प्रोडक्शन के लिए नहीं।

func bubbleSort(_ array: inout [Int]) {    guard array.count > 1 else { return }        for i in 0..<array.count {        var swapped = false        for j in 0..<(array.count - 1 - i) {            if array[j] > array[j + 1] {                array.swapAt(j, j + 1)                swapped =