c++ - रचन - व्हाट इस फ्लोचार्ट




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

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

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

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

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

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

नहीं।

यदि यह आप अक्सर जांच करना चाहते हैं, तो आप एक आवरण वर्ग बनाना चाहते हैं जो एक "सॉर्ट किए गए ध्वज" को जारी रखता है जो झूठी शुरुआत करता है, जब भी कोई आइटम जोड़ा जाता है, और एक सदस्य फ़ंक्शन सॉर्ट जोड़ते हैं () जो सेट करता है सॉर्ट करने के बाद यह ध्वज सच है


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

नहीं।

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


जैसा कि अन्य लोगों ने उल्लेख किया है, हल करने वाली स्थिति निर्धारित करने के लिए एक निश्चय ही ओ (एन) है लेकिन एक हल ध्वज के आपके उल्लेख से, मुझे आश्चर्य है कि अगर आप ऐसा कुछ नहीं चाहते हैं:

हमारे आवेदन की नींव पुस्तकालयों में एक कंटेनर वर्ग शामिल है जिसे सदस्यता के लिए पूछताछ किया जा सकता है। यहां एक संक्षिप्त स्केच है:

class ObjList {
public:
    ObjList() {};
    ~ObjList() {};

    bool isMember(const Item *);
    void add(const Item *, bool sort = false);

private:

    unsigned int last_sorted_d;

    bool sorted_d;
    unsigned int count_d;
    Item *store_d;
};

isMember () तत्वों की क्रमबद्ध सीमा पर एक द्विआधारी खोज का उपयोग करता है, फिर क्रमबद्ध सीमा के बाद वस्तुओं की एक रैखिक खोज। सम्मिलन प्रोग्रामर की पसंद के अनुसार आइटमों को एक तरह से ट्रिगर कर सकता है या नहीं। उदाहरण के लिए, अगर आपको पता है कि आप तंग लूप में हजारों मद जोड़ेंगे, तो आखिरी प्रविष्टि तक क्रांति न करें।

उपरोक्त सिर्फ एक स्केच है, और स्टोर पॉइंटर्स की एक सरणी से अधिक जटिल है, लेकिन आपको यह विचार मिलता है।


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


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


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


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


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

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

:-)


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




vector