जावा आदिम पर एक रेडिक्स प्रकार का उपयोग क्यों नहीं करता है?

Question

java.util.Arrays.sort(/* int[], char[], short[], byte[], boolean[] */) एक मूलांक के बजाय 'ट्यून्ड एस्कॉर्ट' के रूप में कार्यान्वित किया जाता है।

मैंने थोड़ी देर पहले एक गति की तुलना की थी, और n> 10000 की तरह कुछ के साथ, मूलांक क्रम हमेशा तेज था। क्यों?

Answer 1

मैं यह अनुमान लगाऊंगा कि:

• Array.sort को quicksort के रूप में कार्यान्वित किया जाता है, क्योंकि quicksort एक तुलनित्र दिए गए सभ्य समय में कुछ भी सॉर्ट कर सकता है।
• 10000 प्रविष्टियों की सूची छाँटना इतना आम नहीं है। 10000 या अधिक तत्वों के डेटा-संरचना तक पहुंचना आम है। यदि आपको ऑर्डर बनाए रखने की आवश्यकता होती है, तो एक संतुलित खोज ट्री अक्सर आपके पूरे सरणी को क्रमबद्ध करने के लिए जाने से बेहतर होता है कि आपको हर बार सबसे छोटे तत्व की आवश्यकता हो।
• प्राइमरी को क्रमबद्ध करना इतना सामान्य नहीं है, इसके बावजूद कि विश्वविद्यालय क्या सिखा सकता है।

मुद्दा यह है, यह इतना सामान्य उपयोग का मामला नहीं है, कि इसका अनुकूलन मानक पुस्तकालय में होना चाहिए। यदि आपने एक आवेदन लिखा है, जिसमें प्रदर्शन संबंधी समस्याएं हैं, जहां आप प्रोफाइलिंग के माध्यम से यह निर्धारित करते हैं कि 10000+ इन्टर्स की एक सरणी छांटना वास्तव में अड़चन है, तो आप हाथ से छँटाई लिख सकते हैं या पहले डेटा संरचना की अपनी पसंद पर पुनर्विचार कर सकते हैं। जगह।

Comments

100% निश्चित नहीं है, लेकिन मुझे लगता है कि कुछ मामलों में अब टिमसॉर्ट का उपयोग किया जाता है।

— मार्टिनेज वेरबर्ग

लेकिन Array.sort के रूप में कुछ नहीं है, कई Array.sorts हैं, और सवाल संख्यात्मक प्रकारों के लिए इस विशेष के बारे में था।

— दानूबियन नाविक

Answer 2

Back2dos ने यह सब कहा है, मैं केवल उस बिंदु को स्पष्ट करने की कोशिश करूंगा जो मुझे लगता है कि सबसे महत्वपूर्ण है:

मूलांक सॉर्ट केवल बाइनरी अंक पैटर्न के आधार पर सरणी के भीतर निहित वास्तविक आदिम मूल्यों को सॉर्ट कर सकता है। वास्तविक वास्तविक दुनिया के सॉफ्टवेयर इंजीनियरिंग परिदृश्यों में, यह मामला लगभग कभी भी सामने नहीं आया है । हम जो अधिक बार करते हैं, वह अधिक जटिल (गैर-आदिम) डेटा संरचनाओं की सॉर्ट सरणियाँ होती हैं, और कुछ बार हम अनुक्रमणिका के एरे को अन्य संस्थाओं में सॉर्ट करते हैं।

अब, अन्य संस्थाओं को अनुक्रमित की एक सरणी वास्तव में आदिमों की एक सरणी है, लेकिन सॉर्ट क्रम तुलनित्र इंटरफ़ेस (और / या C # में प्रतिनिधि) द्वारा प्रदान किया जाता है, जो अनुक्रमित की तुलना नहीं करता है, लेकिन अनुक्रमणिकाओं द्वारा अनुक्रमित इकाइयां। इस प्रकार, क्रम क्रम आदिमों के मूल्यों के क्रम के लिए बिल्कुल कोई संबंध नहीं रखता है, और इसलिए इस परिदृश्य में मूलांक छंटाई बिल्कुल बेकार है।

एक उदाहरण:

हमारे पास स्ट्रिंग्स की एक सरणी है: [0] = "माइक", [1] = "अल्बर्ट", [2] = "मौरो"। फिर हम उन तारों को अनुक्रमित करने की एक सरणी घोषित करते हैं: [0] = 0, [1] = 1, [2] = 2। फिर, हम अनुक्रमणिका के सरणी को क्रमबद्ध करते हैं, इसे एक तुलनित्र पास करते हैं, जो स्वयं अनुक्रमणिका की तुलना नहीं करता है, लेकिन इन सूचकांक द्वारा संदर्भित वास्तविक तार। छांटने के बाद, अनुक्रमित सरणी का परिणाम इस तरह दिखेगा: [0] = 1, [1] = 0, [2] = 2। जैसा कि आप देख सकते हैं, इस प्रकार के आदेश का सरणी के भीतर निहित मूल्यों के द्विआधारी पैटर्न से कोई लेना-देना नहीं है, और फिर भी अनुक्रमों के इस सरणी को ट्रैवर्स करके और प्रत्येक संगत स्ट्रिंग को लाकर, हम क्रमबद्ध क्रम में तारों का दौरा करते हैं।