std :: मानचित्र सम्मिलित करें या std :: मानचित्र खोजें?

Question 1

एक मानचित्र मानकर जहां आप मौजूदा प्रविष्टियों को संरक्षित करना चाहते हैं। 20% समय, आप जो प्रविष्टि डाल रहे हैं वह नया डेटा है। वहाँ एसटीडी :: नक्शा :: खोजने के लिए एक फायदा है तो एसटीडी :: नक्शा :: डालें कि पुनरावृत्त का उपयोग कर डालें? या यह डालने का प्रयास करने के लिए तेज है और फिर इस पर कार्य करता है कि क्या यह इंगित करता है कि रिकॉर्ड रिकॉर्ड था या नहीं डाला गया था?

Question 2

जवाब है आप न तो। इसके बजाय आप स्कॉट Meyers द्वारा प्रभावी STL के आइटम 24 द्वारा सुझाए गए कुछ करना चाहते हैं :

typedef map<int, int> MapType;    // Your map type may vary, just change the typedef

MapType mymap;
// Add elements to map here
int k = 4;   // assume we're searching for keys equal to 4
int v = 0;   // assume we want the value 0 associated with the key of 4

MapType::iterator lb = mymap.lower_bound(k);

if(lb != mymap.end() && !(mymap.key_comp()(k, lb->first)))
{
    // key already exists
    // update lb->second if you care to
}
else
{
    // the key does not exist in the map
    // add it to the map
    mymap.insert(lb, MapType::value_type(k, v));    // Use lb as a hint to insert,
                                                    // so it can avoid another lookup
}

Question 3

इस प्रश्न का उत्तर इस बात पर भी निर्भर करता है कि मानचित्र में आपके द्वारा संग्रहित मूल्य प्रकार बनाना कितना महंगा है:

typedef std::map <int, int> MapOfInts;
typedef std::pair <MapOfInts::iterator, bool> IResult;

void foo (MapOfInts & m, int k, int v) {
  IResult ir = m.insert (std::make_pair (k, v));
  if (ir.second) {
    // insertion took place (ie. new entry)
  }
  else if ( replaceEntry ( ir.first->first ) ) {
    ir.second->second = v;
  }
}

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

हालाँकि, कॉल करने के लिए आवश्यक है कि आपके पास पहले से निर्मित नया "मूल्य" हो:

class LargeDataType { /* ... */ };
typedef std::map <int, LargeDataType> MapOfLargeDataType;
typedef std::pair <MapOfLargeDataType::iterator, bool> IResult;

void foo (MapOfLargeDataType & m, int k) {

  // This call is more expensive than a find through the map:
  LargeDataType const & v = VeryExpensiveCall ( /* ... */ );

  IResult ir = m.insert (std::make_pair (k, v));
  if (ir.second) {
    // insertion took place (ie. new entry)
  }
  else if ( replaceEntry ( ir.first->first ) ) {
    ir.second->second = v;
  }
}

'इंसर्ट' को कॉल करने के लिए हम अपने मूल्य प्रकार के निर्माण के लिए महंगी कॉल का भुगतान कर रहे हैं - और इस प्रश्न में आपने जो कहा है उससे आप इस नए मूल्य का 20% समय का उपयोग नहीं करेंगे। उपरोक्त मामले में, यदि मानचित्र मान प्रकार बदलना कोई विकल्प नहीं है, तो पहले यह सुनिश्चित करने के लिए कि हमें तत्व का निर्माण करने की आवश्यकता है, उसे खोजने के लिए अधिक कुशल है।

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

Question 4

2 के बीच गति में मुश्किल से कोई अंतर होगा, खोजने के लिए एक पुनरावृत्तिकर्ता को वापस लाएगा, सम्मिलित करता है और वैसे ही नक्शे को पहले से मौजूद होने का पता लगाने के लिए वैसे भी खोज करेगा।

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

Question 5

मुझे लगता है कि यदि आप एक खोज करते हैं तो सम्मिलित करें, अतिरिक्त लागत तब होगी जब आप कुंजी नहीं ढूंढेंगे और सम्मिलित करने के बाद प्रदर्शन करेंगे। यह वर्णमाला के क्रम में पुस्तकों को देखने और पुस्तक को न ढूंढने की तरह है, फिर पुस्तकों के माध्यम से फिर से देखना है कि इसे कहां डालें। यह उबलता है कि आप किस तरह से चाबियों को संभालेंगे और यदि वे लगातार बदल रहे हैं। अब इसमें कुछ लचीलापन है यदि आप इसे नहीं ढूंढते हैं, तो आप लॉग इन कर सकते हैं, अपवाद, जो भी आप चाहते हैं ...

Question 6

मैं शीर्ष उत्तर पर खो गया हूं।

रिटर्न मैप खोजें .end () अगर यह कुछ भी नहीं मिला है जिसका मतलब है कि अगर आप नई चीजें जोड़ रहे हैं तो

iter = map.find();
if (iter == map.end()) {
  map.insert(..) or map[key] = value
} else {
  // do nothing. You said you did not want to effect existing stuff.
}

दो बार के रूप में धीमी है

map.insert

किसी भी तत्व के लिए पहले से ही नक्शे में नहीं है क्योंकि इसे दो बार खोजना होगा। एक बार यह देखने के लिए कि क्या वहाँ है, फिर से नई चीज़ लगाने के लिए जगह ढूंढनी होगी।

Question 7

यदि आप दक्षता के बारे में चिंतित हैं, तो आप हैश_मैप <> की जांच कर सकते हैं ।

आमतौर पर नक्शा <> एक द्विआधारी पेड़ के रूप में लागू किया जाता है। आपकी आवश्यकताओं के आधार पर, एक हैश_मैप अधिक कुशल हो सकता है।

Question 8

मुझे लगता है कि टिप्पणी छोड़ने के लिए पर्याप्त अंक नहीं हैं, लेकिन टिक जवाब मुझे लंबा लगता है - जब आप इस बात पर विचार करते हैं कि इंट्रैक्टर वैसे भी रिटर्न लौटाता है, तो लोअरबाउंड खोजते हुए क्यों जाएं, जब आप सिर्फ इट्रेटर का उपयोग कर सकते हैं। अजीब।

Question 9

दक्षता के बारे में कोई भी उत्तर आपके एसटीएल के सटीक कार्यान्वयन पर निर्भर करेगा। सुनिश्चित करने के लिए जानने का एकमात्र तरीका यह है कि दोनों तरीकों को बेंचमार्क किया जाए। मुझे लगता है कि अंतर महत्वपूर्ण होने की संभावना नहीं है, इसलिए आपकी पसंद की शैली के आधार पर निर्णय लें।

Question 10

नक्शा [कुंजी] - इसे छाँटने दें। यह आपके इरादे को सबसे प्रभावी ढंग से संप्रेषित कर रहा है।

हाँ, काफी उचित है।

यदि आप एक खोज करते हैं और एक प्रविष्टि करते हैं तो आप 2 x O (लॉग एन) का प्रदर्शन कर रहे होते हैं, जब आपको एक मिस मिलती है, तो केवल यह पता चलता है कि क्या आपको यह सम्मिलित करने की आवश्यकता है कि क्या डालने की आवश्यकता नहीं है । बस एक सीधे सम्मिलित करें और फिर परिणाम की जांच करना वह तरीका है जिससे मैं जाऊंगा।