Swift में एल्गोरिदम और डेटा संरचनाएँ: iOS डेवलपर के लिए पूर्ण गाइड

Swift में एल्गोरिदम और डेटा संरचनाएँ: बुनियादी से उन्नत तकनीकों तक

एल्गोरिदम और डेटा संरचनाओं की समझ वह नींव है जो एक नौसिखिए डेवलपर को अनुभवी इंजीनियर से अलग करती है। Swift पर काम करने वाले iOS/macOS डेवलपर के लिए, यह ज्ञान सीधे ऐप के प्रदर्शन, इंटरफ़ेस की प्रतिक्रिया समय और मेमोरी उपयोग की दक्षता को प्रभावित करता है। इस लेख में, हम प्रमुख डेटा संरचनाओं और एल्गोरिदम पर चर्चा करेंगे जो प्रत्येक Swift डेवलपर को जानना चाहिए, व्यावहारिक कोड उदाहरणों के साथ।

1. Swift में बुनियादी डेटा संरचनाएँ: ऐरे, सेट और डिक्शनरी

Swift शक्तिशाली अंतर्निहित संग्रह प्रदान करता है, लेकिन उनकी आंतरिक संरचना को समझने से अधिक कुशल कोड लिखने में मदद मिलती है।

ऐरे (Array)

ऐरे इंडेक्स द्वारा एक्सेस किए जाने वाले तत्वों का एक क्रमबद्ध संग्रह है। Swift में, Array को एक डायनामिक ऐरे के रूप में लागू किया गया है जिसमें अंत में जोड़ने के लिए amortized जटिलता O(1) है।

// निर्माण और बुनियादी संचालन
var numbers = [1, 2, 3, 4, 5]
numbers.append(6) // औसतन O(1)
numbers.insert(0, at: 0) // O(n) — तत्वों का स्थानांतरण
let first = numbers[0] // O(1)
numbers.removeLast() // O(1)
numbers.remove(at: 2) // O(n) — स्थानांतरण

सेट (Set)

Set अद्वितीय तत्वों का एक अक्रमबद्ध संग्रह है। यह हैश टेबल पर आधारित है, जो सम्मिलन, विलोपन और खोज के लिए O(1) देता है।

var uniqueNumbers: Set<Int> = [1, 2, 3, 3, 4]
print(uniqueNumbers) // [1, 2, 3, 4] — डुप्लिकेट हटा दिए गए
uniqueNumbers.insert(5) // O(1)
let contains = uniqueNumbers.contains(3) // true, O(1)

डिक्शनरी (Dictionary)

"कुंजी-मान" जोड़े को संग्रहीत करने के लिए एक साहचर्य सरणी। यह भी हैश टेबल पर आधारित है।

var scores: [String: Int] = ["Alice": 95, "Bob": 87]
scores["Charlie"] = 92 // O(1)
if let aliceScore = scores["Alice"] {
    print("Alice: \\(aliceScore)")
}
scores.removeValue(forKey: "Bob") // O(1)

2. कस्टम डेटा संरचनाएँ: स्टैक, क्यू और लिंक्ड लिस्ट

हालाँकि Swift में स्टैक और क्यू की अंतर्निहित कार्यान्वयन नहीं है, लेकिन इन्हें आसानी से स्वयं लागू किया जा सकता है।

स्टैक (Stack) — LIFO

स्टैक "अंतिम में आया, पहले बाहर" के सिद्धांत पर काम करता है। इसका उपयोग क्रियाओं को पूर्ववत करने, ट्री को गहराई में ट्रैवर्स करने के लिए किया जाता है।

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

var stack = Stack<Int>()
stack.push(1); stack.push(2); stack.push(3)
print(stack.pop()!) // 3
print(stack.peek()!) // 2

क्यू (Queue) — FIFO

क्यू "पहले में आया, पहले बाहर" के सिद्धांत पर काम करता है। इसका उपयोग कार्यों को आने के क्रम में संसाधित करने के लिए किया जाता है।

struct Queue<Element> {
    private var input: [Element] = []
    private var output: [Element] = []
    
    mutating func enqueue(_ element: Element) { input.append(element) }
    
    mutating func dequeue() -> Element? {
        if output.isEmpty {
            output = input.reversed()
            input.removeAll()
        }
        return output.popLast()
    }
    
    var isEmpty: Bool { input.isEmpty && output.isEmpty }
}

var queue = Queue<String>()
queue.enqueue("First"); queue.enqueue("Second")
print(queue.dequeue()!) // "First"

लिंक्ड लिस्ट (Linked List)

लिंक्ड लिस्ट नोड्स से बनी होती है, जिनमें से प्रत्येक अगले नोड को संदर्भित करता है। यह सूची के बीच में तत्वों को कुशलतापूर्वक सम्मिलित/हटाने की अनुमति देता है।

class ListNode<T> {
    var value: T
    var next: ListNode?
    init(_ value: T) { self.value = value }
}

class LinkedList<T> {
    var head: ListNode<T>?
    
    func append(_ valu