संकेत करने के लिए पूर्णांक पहचानकर्ता परिवर्तित

वोट
1

मैं प्रकार के आईडी मान हैं unsigned int। मैं में एक सूचक को एक आईडी मैप करने की आवश्यकता निरंतर समय


कुंजी वितरण:

आईडी uint_max 0 की रेंज में एक मूल्य होगा। कुंजी के अधिकांश एक समूह में क्लस्टर किया जाएगा, लेकिन वहाँ बाहरी कारकों के कारण हो जाएगा।


कार्यान्वयन:

  • मैं सी ++ ext hash_map सामान का उपयोग कर के बारे में सोचा है, लेकिन मैंने सुना है जब कुंजी एक विशाल क्षमता श्रृंखला है उनके प्रदर्शन भी महान नहीं है।

  • मैं भी श्रृंखलित देखने के कुछ फार्म का उपयोग करने का सोचा है (समकक्ष रिकर्सिवली सी chucks में रेंज उप-विभाजित करने के लिए)। एक श्रेणी में कोई भी कुंजी देखते हैं, तो उस सीमा शून्य पर इंगित करेंगे।

    एन = कुंजी रेंज

    स्तर 0 = [0, एन / 16) (सी = 16, इसलिए 16 टुकड़ों में विभाजित), [एन / 16, 2 * (एन / 16)), ...

    स्तर 1 (सी में विभाजित 16 =, तो 16 * 16 टुकड़े) = ...


किसी और को कैसे इस मानचित्रण और अधिक कुशलता से लागू किया जा सकता पर विचार है?

अद्यतन करें:

निरंतर रूप से, मैं तो बस प्रत्येक कुंजी देखने में काफी मद में मूल्यों का # से प्रभावित नहीं है का मतलब है। मैं यह मतलब नहीं था यह एक एकल सेशन होना ही था।

27/08/2009 को 06:11
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


7 जवाब

वोट
11

एक हैश मैप का उपयोग करें ( unordered_map)। यह ~ हे (1) देखो-अप बार देता है। आप "सुना" यह बुरा था, लेकिन आप इसे, परीक्षण, और निर्धारित यह एक समस्या होने की कोशिश की थी? यदि नहीं, तो एक हैश मैप का उपयोग करें।

बाद अपने कोड पूरा होने के करीब हो जाता है, यह प्रोफाइल और निर्धारित करता है, तो लुक-अप बार अपने कार्यक्रम में सुस्ती के मुख्य कारण हैं। उम्मीद है कि इस नहीं होगा।

27/08/2009 को 06:14
का स्रोत उपयोगकर्ता

वोट
3

आप एक पेड़ के आधार पर समाधान चाहते हैं और अपने आईडी सीमा {0..n-1} में हैं तो आप कहा जाता है एक बहुत ही शांत डेटा संरचना का उपयोग कर सकते वैन Emde बोअस पेड़ । यह हे में सभी कार्यों उपज (लॉग लॉग ऑन एन) और हे (एन) अंतरिक्ष का उपयोग करेगा।

27/08/2009 को 06:35
का स्रोत उपयोगकर्ता

वोट
1

कितनी वस्तुएँ इस तरह के एक नक्शे में हो रहे हैं और यह कितनी बार बदल गया है?

यदि सभी मूल्यों प्रोसेसर की कैश में फिट है, तो एक std::vector<std::pair<unsigned int,T*>>presorted मूल्यों और द्विआधारी खोज के साथ पहुंच जा रहा हे (एन) के बावजूद सबसे तेजी से हो सकता है।

27/08/2009 को 10:40
का स्रोत उपयोगकर्ता

वोट
1

GMAN से पता चलता है एक unordered_map शायद एक अच्छा समाधान है। आप इस हैश नक्शे में टकराव की एक बड़ी संख्या के बारे में चिंतित हैं, तो एक हैश समारोह है कि आपके डेटा क्लस्टरिंग निकाल देंगे का उपयोग करें। उदाहरण के लिए, आप बाइट्स चारों ओर स्वैप कर सकते हैं।

नोट करने के लिए एक अच्छा मुद्दा यह है कि आप शायद अधिक समय डिबगिंग बिताने और एक है कि पहले से ही अच्छी वंशावली गया है की तुलना में एक कस्टम डेटा संरचना साबित होगा।

27/08/2009 को 06:55
का स्रोत उपयोगकर्ता

वोट
1

इस के लिए अपने राम रिजर्व 4GB, और बस सूचक करने के लिए अपने uint डाली। यह निश्चित रूप से निरंतर समय है।

27/08/2009 को 06:20
का स्रोत उपयोगकर्ता

वोट
1

अपने पूर्णांक मूल्यों 32 बिट विस्तृत कर रहे हैं, तो आप एक 64-बिट मंच इस्तेमाल कर सकते हैं, स्मृति के 32 गीगाबाइट (4 अरब संकेत प्रति 8 बाइट्स) का आवंटन, और एक फ्लैट सरणी का उपयोग करें। यही कारण है कि के रूप में पास के रूप में आप लगातार देखने-समय पर प्राप्त करने के लिए जा रहे हैं हो जाएगा।

27/08/2009 को 06:17
का स्रोत उपयोगकर्ता

वोट
1

आप निरंतर समय पाने के लिए नहीं जा रहे हैं।

मैं शायद एक प्रयोग करेंगे बी + ट्री

27/08/2009 को 06:15
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more