अद्वितीय कुंजी-मान-जोड़ी संग्रह

Question

कोई संरचना है कि दोनों इन आपरेशनों के अनुमति देता है?

मेरे समस्या:

मैं मूल रूप से कुंजी का मान प्राप्त करने में सक्षम होने की जरूरत है या मूल्य के प्रमुख वास्तव में तेजी से, स्मृति को डुप्लिकेट के बिना (ताकि दो शब्दकोशों सवाल से बाहर हैं)।

बहुत महत्वपूर्ण नोट: सभी कुंजी अद्वितीय हैं और सभी मान अद्वितीय हैं। इस जानकारी के साथ मैं महसूस करता हूं.TryGetValue और ओ (एन) .TryGetKey के लिए ओ (1) की तुलना में बेहतर समय में इस कार्य को पूरा करना संभव होना चाहिए।

संपादित करें:

मेरे मामले में, मैं strings और ints के बीच एक मैपिंग की है। ग्रंथों और उनकी आईडी के ~ 650,000 कुंजी-मूल्य जोड़े हैं। इसलिए मैं मूल रूप से एक विशिष्ट आईडी के साथ स्ट्रिंग प्राप्त करना चाहता हूं लेकिन एक निश्चित स्ट्रिंग की आईडी भी प्राप्त करना चाहता हूं।

Answer 1

आप ऐसी चीज कर सकते हैं;

Dictionary<string, string> types = new Dictionary<string, string>() 
      { 
         {"1", "one"}, 
         {"2", "two"}, 
         {"3", "three"} 
      }; 

      var myValue = types.FirstOrDefault(x => x.Value == "one").Key; 

Answer 2

आप जो करना चाहिए value के लिए value आवरण और आवरण जो चाहिए key आवरण के लिए मूल्य और लिंक होता है के लिए महत्वपूर्ण और लिंक होता है key के लिए कुछ आवरण लिख सकते हैं। और दो अलग HashSet एस का उपयोग करें।
इस मामले में आप स्मृति डुप्लिकेटिंग से बचें। आपको लिंक के लिए केवल अतिरिक्त मेमोरी चाहिए।

Answer 3

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

इसके आस-पास एक तरीका ऑब्जेक्ट के अंदर संरचना मूल्य बॉक्स है, फिर बॉक्सिंग ऑब्जेक्ट को दो शब्दकोशों में साझा करें। यदि आप DictionaryBase से उत्तराधिकारी का उपयोग करते हैं तो यह वास्तव में लागू करने में काफी आसान है।

public sealed class TwoWayDictionary<TKey, TValue> : DictionaryBase 
{ 
    Hashtable reverseLookup = new Hashtable(); 

    public void Add(TKey key, TValue value) 
    { 
     this.Dictionary.Add(key, value); 
    } 

    public void Remove(TKey key) 
    { 
     this.Dictionary.Remove(key); 
    } 

    public bool TryGetValue(TKey key, out TValue value) 
    { 
     object lookup = Dictionary[key]; 
     if (lookup == null) 
     { 
      value = default(TValue); 
      return false; 
     } 
     else 
     { 
      value = (TValue)lookup; 
      return true; 
     } 
    } 

    public bool TryGetKey(TValue value, out TKey key) 
    { 
     object lookup = reverseLookup[value]; 
     if (lookup == null) 
     { 
      key = default(TKey); 
      return false; 
     } 
     else 
     { 
      key = (TKey)lookup; 
      return true; 
     } 
    } 

    //If OnInsertComplete or OnSetComplete raises a exception DictionaryBase will 
    // roll back the operation it completed. 
    protected override void OnInsertComplete(object key, object value) 
    { 
     reverseLookup.Add(value, key); 
    } 

    protected override void OnSetComplete(object key, object oldValue, object newValue) 
    { 
     if(reverseLookup.Contains(newValue)) 
      throw new InvalidOperationException("Duplicate value"); 
     if(oldValue != null) 
      reverseLookup.Remove(oldValue); 
     reverseLookup[newValue] = key; 
    } 

    protected override void OnRemoveComplete(object key, object value) 
    { 
     reverseLookup.Remove(value); 
    } 
} 

Dictionary और reverseLookup शब्दकोशों ही संदर्भ का हिस्सा तो यह दृढ़ता से टाइप किया दो शब्दकोशों का उपयोग कर बड़े structs के साथ तुलना में एक छोटे स्मृति पदचिह्न होगा।

एक पूर्ण Dictionary<TKey, TValue> कार्यान्वयन लिखने के बिना जो कुंजी और मूल्यों के लिए दो आंतरिक बाल्टी संग्रह और बाल्टी के चेन के लिए दो लिंक्ड सूचियों का उपयोग करता है, मुझे नहीं लगता कि आपको बेहतर परिणाम मिल सकते हैं।