Swift में ऐरे सॉर्टिंग: चौंकाने वाले प्रदर्शन परीक्षण

Swift Beta Performance: ऐरे सॉर्टिंग — क्या गलत हुआ?

यदि आपने कभी Swift के पहले बीटा संस्करणों के युग में Stack Overflow पर देखा होगा, तो आपको निश्चित रूप से वह प्रसिद्ध प्रश्न याद होगा जिसने हज़ारों व्यूज़ और सैकड़ों टिप्पणियाँ प्राप्त कीं। यह कुछ इस प्रकार था: "Swift Beta में ऐरे सॉर्टिंग Objective-C की तुलना में 100 गुना धीमी क्यों है?"

उस समय, 2014 में, यह iOS समुदाय के लिए एक वास्तविक झटका था। डेवलपर्स, जो Objective-C में बिजली की तेज़ सॉर्टिंग के आदी थे, ने अचानक देखा कि उनके ऐप बिना किसी कारण के हैंग हो रहे हैं। आज, वर्षों बाद, हम शांति से इस समस्या का विश्लेषण कर सकते हैं: समझ सकते हैं कि वास्तव में धीमेपन का कारण क्या था, Swift कैसे विकसित हुआ, और सबसे महत्वपूर्ण बात, आधुनिक Swift में ऐरे को सही तरीके से कैसे सॉर्ट करें ताकि अतीत की गलतियाँ न दोहराई जाएँ।

इस लेख में, हम केवल पुराने बग को दोबारा नहीं बताएँगे। हम अपने स्वयं के परीक्षण करेंगे, कोड लिखेंगे और पता लगाएँगे कि Swift में कौन से सॉर्टिंग एल्गोरिदम वास्तव में तेज़ हैं, और कौन से शुरुआती लोगों के लिए जाल हैं। चलिए शुरू करते हैं!

संक्षिप्त पृष्ठभूमि: Swift Beta में क्या हुआ?

Swift के पहले बीटा संस्करण में, 100,000 पूर्णांकों की एक ऐरे को सॉर्ट करने में 20 सेकंड तक लग सकते थे। Objective-C में, वही ऑपरेशन 0.2 सेकंड में पूरा होता था। 100 गुना का अंतर! इसका कारण यह था कि प्रारंभिक Swift ने सॉर्टिंग एल्गोरिदम का अकुशल कार्यान्वयन (पिवट तत्व के खराब चयन के साथ Introsort) इस्तेमाल किया, और अनुकूलन फ़्लैग (-O) के बिना संकलन करने पर अनुकूलन में समस्याएँ थीं।

इसके अलावा, बीटा संस्करण में अक्सर ऐरे तक प्रत्येक पहुँच के लिए डायनामिक बाउंड्स चेकिंग (bounds checking) तंत्र सक्रिय होता था, जो भारी ओवरहेड जोड़ता था। निष्कर्ष सरल था: Swift कच्चा था, लेकिन इसकी क्षमता बहुत बड़ी थी।

आज Swift में ऐरे कैसे सॉर्ट करें? सर्वोत्तम अभ्यास

आधुनिक Swift (संस्करण 5.x और नया) एक परिपक्व भाषा है। ऐरे सॉर्टिंग न केवल तेज़ हो गई है, बल्कि मुख्यधारा की भाषाओं में सबसे तेज़ में से एक है। आइए मुख्य विधियों को समझते हैं।

1. अंतर्निहित विधि sort() — स्वर्ण मानक

सबसे सरल और अनुशंसित तरीका sort() (इन-प्लेस सॉर्टिंग) या sorted() (नई सॉर्टेड ऐरे लौटाता है) विधि का उपयोग करना है।

import Foundation\n\nvar numbers = [5, 3, 8, 1, 9, 2]\nnumbers.sort() // इन-प्लेस सॉर्टिंग\nprint(numbers) // [1, 2, 3, 5, 8, 9]\n\nlet sortedNumbers = numbers.sorted() // नई ऐरे लौटाता है\nprint(sortedNumbers) // [1, 2, 3, 5, 8, 9]

sort() आंतरिक रूप से TimSort का उपयोग करता है — एक हाइब्रिड एल्गोरिदम जो औसतन O(n log n) और लगभग सॉर्ट किए गए डेटा पर O(n) में काम करता है। यह वही एल्गोरिदम है जो Python और Java में उपयोग होता है। यह आधुनिक प्रोसेसर के लिए शानदार ढंग से अनुकूलित है।

2. क्लोज़र के साथ सॉर्टिंग: अनुकूलन

यदि आपको ऐरे को अवरोही क्रम में या किसी जटिल मानदंड के अनुसार सॉर्ट करने की आवश्यकता है, तो क्लोज़र का उपयोग करें:

let words = ["सेब", "संतरा", "केला", "कीवी"]\nlet sortedByLength = words.sorted { $0.count < $1.count }\nprint(sortedByLength) // ["कीवी", "सेब", "केला", "संतरा"]\n\nlet descendingNumbers = numbers.sorted(by: >)\nprint(descendingNumbers) // [9, 8, 5, 3, 2, 1]

महत्वपूर्ण: क्लोज़र एक शुद्ध फ़ंक्शन (pure function) होना चाहिए — बिना किसी दुष्प्रभाव के। अन्यथा, आपको अप्रत्याशित व्यवहार और प्रदर्शन में गिरावट का जोखिम हो सकता है।

3. कस्टम स्ट्रक्चर की सॉर्टिंग

जब आप अपने स्वयं के डेटा प्रकारों के साथ काम करते हैं, तो Comparable प्रोटोकॉल को लागू करना सबसे अच्छा है। यह आपको क्लोज़र के बिना sort() का उपयोग करने की अनुमति देगा।

struct Person: Comparable {\n    let name: String\n    let age: Int\n\n    static func < (lhs: Person, rhs: Person) -> Bool {\n        return lhs.age < rhs.age // उम्र के अनुसार सॉर्ट करें\n    }\n}\n\nle