c++ रचन एक सदिश सॉर्ट किया गया है या नहीं, यह जांचने के लिए सर्वश्रेष्ठ एल्गोरिथम




व्हाट इस फ्लोचार्ट (11)

क्या std::vector सॉर्ट किया गया है यह जांचने का सबसे अच्छा तरीका क्या होगा? क्या लूप जांच की तुलना में तेज़ कुछ है जो v[i]<=v[i+1] ? क्या यह तेज़ / तेज गति के साथ क्लीनर है? या क्या यह वास्तव में बेहतर है कि आप हर समय कॉल करें (हालांकि "v पहले से ही सॉर्ट किया गया है" केस काफी सामान्य है)?

हम सुरक्षित रूप से वेक्टर को ग्रहण कर सकते हैं जिसमें केवल पीओडी, आमतौर पर float और कभी-कभी double एस और int एस होते हैं।

वेक्टर का आकार गैर-तुच्छ (आमतौर पर कुछ हज़ारों मद हैं), लेकिन चरम नहीं है (गीगाबाइट आकार के नहीं)।

  • कुछ उदाहरणों में हम तुरंत बाद वेक्टर को सॉर्ट करेंगे, हालांकि अन्य उदाहरण हैं जहां हम नहीं करते (यह हमारे एल्गोरिदम का एक त्रुटि मामला है)।
  • जब भी संभव हो हम एक ध्वज "IsSorted" का उपयोग करते हैं

क्या लूप जांच की तुलना में तेज़ कुछ है जो वी [i] <= वी [i + 1]?

नहीं।

हालांकि, यदि आप वेक्टर को सॉर्ट करना है या नहीं, तो यह तय करने के लिए चेक को करने के लिए जा रहे हैं, यदि आप सही क्रम-एल्गोरिथम का उपयोग करते हैं, तो आप हमेशा बेहतर तरीके से सॉर्ट करना चाहते हैं, अर्थात std :: stable_sort और std :: sort नहीं


std::adjacent_find(v.begin(), v.end(), std::greater<type>()) == v.end()

यदि आपके सी ++ मानक पुस्तकालय कार्यान्वयन में एल्ग्रिथ्म is_sorted () है, तो यह सबसे अच्छा विकल्प है


सी ++ - 11 में एल्गोरिथ्म में शामिल है I_sorted


मल्टीपल सीपीयू कोर पर विचार करें

यह आपके प्लेटफार्म पर निर्भर करता है और वेक्टर में वस्तुओं की संख्या पर निर्भर करता है। आपको सबसे अच्छी बात यह जानने के लिए बेंचमार्क होना होगा

यह जवाब देना संभव नहीं है: क्या लूप जांच की तुलना में तेज़ कुछ है जो वी [i] <= वी [i + 1]?
कोई साथ।

क्योंकि ... कंप्यूटर अब एक दिन में कई सीपीयू / कोर / हाइपरथ्रेडिंग हैं इसलिए, कई थ्रेड्स को चेक करने के काम को विभाजित करके कंप्यूटर में परादीप का फायदा उठाने के लिए बहुत तेज़ हो सकता है, इसलिए प्रत्येक सीपीयू समानांतर में एक छोटी सी सीमा की जांच कर सकता है।

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


std::is_sorted का सबसे अच्छा तरीका है:

is_sorted(v.begin(), v.end())

:-)


यदि जब आप आइटम डालें तो सम्मिलन बिंदु को खोजने के लिए आप द्विआधारी खोज का उपयोग करते हैं, तो इसका कभी भी आदेश नहीं दिया जाता है


बेशक, मुझे आपकी समस्या का कोई ज्ञान नहीं है, इसलिए कृपया मुझे अनदेखा करें यदि मैं कहूं कि वह प्रासंगिक नहीं है, लेकिन मुझे लगता है कि अगर मुझे एक संग्रह की आवश्यकता होती है तो जब भी मैं इसका उपयोग करता हूं, तो एक स्वाभाविक रूप से संगठित संग्रह vector<T> सबसे अच्छा विकल्प नहीं हो सकता है


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


क्या लूप जांच की तुलना में तेज़ कुछ है जो वी [i] <= वी [i + 1]?

यह देखने के लिए कि क्या यह सॉर्ट किया गया है, तो यह किसी भी मूल्य की जांच करने की आवश्यकता होगी, यदि आप सदिश को बदलते समय स्वयं बदलते रहें या पहले से ही सॉर्ट किए गए डेटास्ट्रक्चर का इस्तेमाल न करें तो ओ (एन) से तेज़ी से नहीं मिलेगा।

या क्या यह वास्तव में बेहतर है कि आप हर समय कॉल करें (हालांकि "v पहले से ही सॉर्ट किया गया है" केस काफी सामान्य है)?

याद रखें कि जल्दी से सबसे खराब केस व्यवहार तब होता है जब सूची पहले ही सॉर्ट कर दी जाती है (और धुरी गलत चुना जाता है) इस तरह के व्यवहार से बचने के लिए आप एक प्रतिस्थापन के रूप में std :: stable_sort को देखना चाहते हैं।


सॉर्ट करने के लिए आपको प्रत्येक आइटम की जांच करनी होगी। तो वी [i] <= वी [i + 1] सबसे तेज़ संभव जांच है





vector