मैं बढ़ती TDictionary के साथ मेमोरी से बाहर निकलने से कैसे बच सकता हूं?

Question

TDictionary<TKey,TValue> एक आंतरिक सरणी कि दोगुनी है का उपयोग करता है अगर यह भरा हुआ है:

newCap := Length(FItems) * 2; 
if newCap = 0 then 
    newCap := 4; 
Rehash(newCap); 

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

क्या इस व्यवहार को प्रभावित करने का कोई तरीका है? अन्य संग्रह वर्ग इस परिदृश्य से कैसे निपटते हैं?

Answer 1

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

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

यदि आप ऐसा नहीं कर सकते हैं (आपको शब्दकोश में मौजूद वस्तुओं की संख्या पता नहीं है) तो आपको पहली बार TDictionary चुनने और डेटा संरचना का चयन करने के लिए पुनर्विचार करना होगा जो आपके विशेष एल्गोरिदम के लिए बेहतर समझौता प्रदान करता है। उदाहरण के लिए आप बाइनरी सर्च पेड़ का उपयोग कर सकते हैं, क्योंकि वे मौजूदा नोड्स में जानकारी घूर्णन करके संतुलन करते हैं, फिर से आवंटन कभी की आवश्यकता नहीं है।