सी #: क्या आप सॉर्ट किए गए सॉर्ट किए गए डिक्शनरी को सॉर्ट करते हैं?

Question

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

Answer 1

जब आप संग्रह की गणना करते हैं तो इसे कुंजी द्वारा क्रमबद्ध किया जाता है (भले ही आप Values संग्रह कहें)। आंतरिक रूप से संग्रह एक बाइनरी खोज पेड़ के रूप में लागू किया जाता है (दस्तावेज़ीकरण के अनुसार)। मूल्यों का सम्मिलन और लुकअप दोनों ओ (लॉग एन) हैं (जिसका अर्थ है कि वे बहुत कुशल हैं)।

Answer 2

हां, इसका मतलब यह है कि इसका क्या अर्थ है।

संपादित करें: वह हिस्सा जो कहता है "क्या इसका मतलब यह है कि आप यह सुनिश्चित कर सकते हैं कि जब आप इसे पूर्वानुमान में बताएंगे तो इसे हल किया जाएगा?"

Answer 3

From MSDN:

शब्दकोश एक अनुसार क्रमबद्ध आदेश एक आंतरिक पेड़ का उपयोग करने में बनाए रखा है। प्रत्येक नया तत्व सही क्रम स्थिति पर स्थित है, और पेड़ सॉर्ट ऑर्डर को बनाए रखने के लिए समायोजित किया जाता है जब भी कोई तत्व हटा दिया जाता है। जबकि गणना करते हुए, सॉर्ट ऑर्डर बनाए रखा गया है।

Answer 4

यदि आप SortedDictionary में आइटमों की गणना करते हैं, तो आइटम आइटम कुंजी के क्रम क्रम में वापस आ जाएंगे। और यदि आप SortedDictionary में कुंजियों द्वारा गणना करते हैं, तो कुंजी क्रमबद्ध क्रम में भी वापस आ जाएगी। और शायद कुछ हद तक आश्चर्यजनक रूप से, यदि आप SortedDictionary को इसके मानों से गिनते हैं, तो मानों को क्रमशः मानों के क्रम क्रम में क्रमबद्ध क्रम में क्रमबद्ध किया जाता है।

प्रदर्शन:

ध्यान दें कि यह डेमो आइटम SortedDictionary को जोड़ा गया में हैं नहीं क्रमबद्ध क्रम में जोड़ा।

इसके अलावा, यदि आप अपने मूल्यों से अपने शब्दकोश को गिनाने की योजना बना रहे हैं और डुप्लिकेट मान की संभावना है, तो अपने रिवर्स लुकअप फ़ंक्शन return an IEnumerable<T> पर विचार करें। (बेशक, बड़े शब्दकोशों के लिए, ऊपर अपने मूल्य द्वारा एक प्रमुख खराब प्रदर्शन में हो सकता है की तलाश में।)

using System; 
using System.Collections.Generic; 
using System.Linq; 

class SortedDictionaryEnumerationDemo 
{ 
    static void Main() 
    { 
     var dict = new SortedDictionary<int, string>(); 
     dict.Add(4, "Four"); 
     dict.Add(5, "Five"); 
     dict.Add(1, "One"); 
     dict.Add(3, "Three"); 
     dict.Add(2, "Two"); 

     Console.WriteLine("== Enumerating Items =="); 
     foreach (var item in dict) 
     { 
      Console.WriteLine("{0} => {1}", item.Key, item.Value); 
     } 

     Console.WriteLine("\n== Enumerating Keys =="); 
     foreach (int key in dict.Keys) 
     { 
      Console.WriteLine("{0} => {1}", key, dict[key]); 
     } 

     Console.WriteLine("\n== Enumerating Values =="); 
     foreach (string value in dict.Values) 
     { 
      Console.WriteLine("{0} => {1}", value, GetKeyFromValue(dict, value)); 
     } 
    } 

    static int GetKeyFromValue(SortedDictionary<int, string> dict, string value) 
    { 
     // Use LINQ to do a reverse dictionary lookup. 
     try 
     { 
      return 
       (from item in dict 
       where item.Value.Equals(value) 
       select item.Key).First(); 
     } 
     catch (InvalidOperationException e) 
     { 
      return -1; 
     } 
    } 
} 

अपेक्षित आउटपुट:

== Enumerating Items == 
1 => One 
2 => Two 
3 => Three 
4 => Four 
5 => Five 

== Enumerating Keys == 
1 => One 
2 => Two 
3 => Three 
4 => Four 
5 => Five 

== Enumerating Values == 
One => 1 
Two => 2 
Three => 3 
Four => 4 
Five => 5