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

Swift में एल्गोरिदम और डेटा संरचनाएँ: शुरुआत से विशेषज्ञ तक

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

1. Swift में बुनियादी डेटा संरचनाएँ

Swift की मानक लाइब्रेरी कई अंतर्निहित संरचनाएँ प्रदान करती है जो किसी भी ऐप्लिकेशन की नींव होती हैं।

ऐरे (Array)

एक ही प्रकार के तत्वों का क्रमबद्ध संग्रह। इंडेक्स द्वारा यादृच्छिक पहुँच का समर्थन करता है।

var numbers: [Int] = [10, 20, 30, 40, 50]numbers.append(60)numbers.insert(5, at: 0)print(numbers[2]) // आउटपुट: 30

डिक्शनरी (Dictionary)

अद्वितीय कुंजी द्वारा तेज़ी से डेटा खोजने के लिए 'कुंजी-मान' जोड़ियों का संग्रह।

var userScores: [String: Int] = ["Alice": 95, "Bob": 87]userScores["Charlie"] = 92if let score = userScores["Alice"] {    print("Alice का स्कोर: \\(score)")}

सेट (Set)

अद्वितीय तत्वों का अक्रमबद्ध संग्रह। उपस्थिति की जाँच या डुप्लिकेट हटाने के लिए आदर्श।

let fruits: Set = ["Apple", "Banana", "Orange", "Apple"]print(fruits.count) // आउटपुट: 3 (डुप्लिकेट हटा दिया गया)

2. Swift में स्टैक और क्यू का कार्यान्वयन

स्टैक और क्यू क्लासिक डेटा संरचनाएँ हैं जिन्हें अक्सर ऐरे के ऊपर कार्यान्वित किया जाता है।

स्टैक (Stack) — LIFO (Last In, First Out)

तत्वों को एक ही सिरे से जोड़ा और हटाया जाता है।

struct Stack<T> {    private var elements: [T] = []        mutating func push(_ value: T) {        elements.append(value)    }        mutating func pop() -> T? {        return elements.popLast()    }        func peek() -> T? {        return elements.last    }}

var stack = Stack<Int>()stack.push(1)stack.push(2)stack.push(3)print(stack.pop()!) // आउटपुट: 3

क्यू (Queue) — FIFO (First In, First Out)

तत्वों को अंत में जोड़ा जाता है और शुरुआत से हटाया जाता है।

struct Queue<T> {    private var elements: [T] = []        mutating func enqueue(_ value: T) {        elements.append(value)    }        mutating func dequeue() -> T? {        return elements.isEmpty ? nil : elements.removeFirst()    }}

var queue = Queue<String>()queue.enqueue("First")queue.enqueue("Second")print(queue.dequeue()!) // आउटपुट: First

3. सॉर्टिंग और सर्चिंग एल्गोरिदम

दो मौलिक एल्गोरिदम देखें जो वास्तविक प्रोजेक्ट्स में उपयोगी होते हैं।

क्विक सॉर्ट (Quick Sort)

एक कुशल 'डिवाइड एंड कॉन्कर' एल्गोरिदम जिसकी औसत जटिलता O(n log n) है।

func quickSort(_ array: [Int]) -> [Int] {    guard array.count > 1 else { return array }        let pivot = array[array.count / 2]    let less = array.filter { $0 < pivot }    let equal = array.filter { $0 == pivot }    let greater = array.filter { $0 > pivot }        return quickSort(less) + equal + quickSort(greater)}

let unsorted = [3, 6, 8, 10, 1, 2, 1]print(quickSort(unsorted)) // आउटपुट: [1, 1, 2, 3, 6, 8, 10]

बाइनरी सर्च (Binary Search)

केवल सॉर्ट किए गए ऐरे पर काम करता है। जटिलता O(log n) है।

func binarySearch(_ array: [Int], target: Int) -> Int? {    var low = 0    var high = array.count - 1        while low <= high {        let mid = (low + high) / 2        if array[mid] == target {            return mid        } else if array[mid] < target {            low = mid + 1        } else {            high = mid - 1        }    }    return nil}

let sortedArray = [1, 3, 5, 7, 9, 11]if let index = binarySearch(sortedArray, target: 7) {    p
```