SortedList और SortedDictionary के बीच अंतर क्या है?

Question

क्या ए SortedList<TKey,TValue>और ए के बीच कोई वास्तविक व्यावहारिक अंतर है SortedDictionary<TKey,TValue>? क्या ऐसी कोई परिस्थितियाँ हैं जहाँ आप विशेष रूप से एक का उपयोग करेंगे और दूसरे का नहीं?

Comments

संबंधित: एक SortedList या एक SortedDictionary उपयोग करने के लिए जब

— लियाम

मैं उलझन में हूं। SortedList में SortedList<TKey,TValue>एक के बजाय दो प्रकार के पैरामीटर क्यों होते हैं SortedList<T>? इसे लागू क्यों नहीं करता है IList<T>?

— कर्नल पैनिक

@ColonelPanic क्योंकि कार्यात्मक रूप से SortedList एक नक्शा है, न कि एक रैखिक संग्रह। नाम को मूर्ख मत बनने दो। जैसे एक शब्दकोश, आप एक कुंजी में पास करते हैं, आपको एक मूल्य वापस मिलता है। जबकि शब्दकोश अव्यवस्थित है, SortedList अपने प्राकृतिक क्रमबद्ध क्रम में आदेशित है।

— नवफाल

Answer 1

हां - उनकी प्रदर्शन विशेषताओं में काफी भिन्नता है। शायद उन्हें कॉल करना बेहतर होगा SortedListऔर SortedTreeजैसा कि कार्यान्वयन को अधिक बारीकी से दर्शाता है।

प्रत्येक साइट के लिए MSDN डॉक्स देखें ( SortedList, SortedDictionary) अलग-अलग साइटूटेशन में अलग-अलग ऑपरेशन के लिए प्रदर्शन के विवरण के लिए। यहाँ एक अच्छा सारांश ( SortedDictionaryडॉक्स से):

SortedDictionary<TKey, TValue>सामान्य वर्ग हे (लॉग एन) पुनः प्राप्ति, जहां n शब्दकोश में तत्वों की संख्या है के साथ एक द्विआधारी खोज वृक्ष है। इसमें, यह SortedList<TKey, TValue>सामान्य वर्ग के समान है । दो वर्गों में समान ऑब्जेक्ट मॉडल हैं, और दोनों में ओ (लॉग एन) पुनर्प्राप्ति है। जहाँ दो वर्ग अलग-अलग होते हैं, स्मृति उपयोग और सम्मिलन और हटाने की गति:

• SortedList<TKey, TValue>से कम मेमोरी का उपयोग करता है SortedDictionary<TKey, TValue>।

• SortedDictionary<TKey, TValue>अनियोजित डेटा के लिए तेजी से सम्मिलन और निष्कासन संचालन है, O (n) के विपरीत O (n) SortedList<TKey, TValue>।

• यदि सूची सभी प्रकार के डेटा से एक बार में पॉपुलेट की जाती है, SortedList<TKey, TValue>तो इससे अधिक तेज़ है SortedDictionary<TKey, TValue>।

( SortedListवास्तव में एक पेड़ का उपयोग करने के बजाय एक क्रमबद्ध सरणी बनाए रखता है। यह अभी भी तत्वों को खोजने के लिए द्विआधारी खोज का उपयोग करता है।)

Comments

संकेत के लिए सभी को बहुत बहुत धन्यवाद। मुझे लगता है कि मैं आरटीएफएम के लिए बहुत आलसी हूं ... एसओ पर अच्छे लोगों से पूछना आसान है;) मैंने जवाब के लिए आप दोनों को वोट दिया; जॉन को ट्रिगर पर पहले होने का जवाब क्रेडिट मिलता है। :)

— शाऊल बेहार

मुझे लगता है कि SortedList परिभाषा को सही किया जाना चाहिए क्योंकि मुझे विश्वास नहीं है कि यह एक द्विआधारी खोज पेड़ है ...?

— नचौद

मैंने परावर्तक का उपयोग करके देखा और पाया कि इसने बाइनरी सर्च ट्री का उपयोग नहीं किया।

— डैनियल इमेम्स

मुझे लगता है कि Sorteddfox एक AVL- ट्री या रेड-ब्लैकट्री (सभी ऑपरेशन लागत O (लोगन) है। और SortedList एक द्विआधारी-खोज है (इसमें सबसे खराब स्थिति में o (n) समय खर्च होता है)

— घोस्टबेर

Answer 2

यहाँ एक सारणीबद्ध दृश्य है अगर यह मदद करता है ...

एक से प्रदर्शन परिप्रेक्ष्य:

+------------------+---------+----------+--------+----------+----------+---------+
| Collection       | Indexed | Keyed    | Value  | Addition |  Removal | Memory  |
|                  | lookup  | lookup   | lookup |          |          |         |
+------------------+---------+----------+--------+----------+----------+---------+
| SortedList       | O(1)    | O(log n) | O(n)   | O(n)*    | O(n)     | Lesser  |
| SortedDictionary | n/a     | O(log n) | O(n)   | O(log n) | O(log n) | Greater |
+------------------+---------+----------+--------+----------+----------+---------+

* Insertion is O(1) for data that are already in sort order, so that each 
  element is added to the end of the list (assuming no resize is required).

एक से कार्यान्वयन परिप्रेक्ष्य:

+------------+---------------+----------+------------+------------+------------------+
| Underlying | Lookup        | Ordering | Contiguous | Data       | Exposes Key &    |
| structure  | strategy      |          | storage    | access     | Value collection |
+------------+---------------+----------+------------+------------+------------------+
| 2 arrays   | Binary search | Sorted   | Yes        | Key, Index | Yes              |
| BST        | Binary search | Sorted   | No         | Key        | Yes              |
+------------+---------------+----------+------------+------------+------------------+

करने के लिए मोटे तौर पर संक्षिप्त व्याख्या, अगर आप कच्चे प्रदर्शन की आवश्यकता होती है SortedDictionaryएक बेहतर विकल्प हो सकता है। यदि आपको कम मेमोरी ओवरहेड और अनुक्रमित पुनर्प्राप्ति की आवश्यकता होती है, तो यह SortedListबेहतर है।यह प्रश्न देखें कि किसका उपयोग कब करना है।

आप और अधिक पढ़ सकते हैं यहाँ , यहाँ , यहाँ , यहाँ और यहाँ ।

Comments

ध्यान दें कि यदि आप अच्छा प्रदर्शन और अपेक्षाकृत कम मेमोरी उपयोग और अनुक्रमित पुनर्प्राप्ति चाहते हैं, तो इसके बजाय BDictionary<Key,Value>LoycCore में विचार करें SortedDictionary।

— क्वर्टी

हां, इस लेख के निचले भाग को देखें । यह पता चला है BDictionaryकि आमतौर पर SortedDictionaryबहुत बड़े आकार को छोड़कर धीमी होती है , लेकिन यह तेजी से होता है SortedListअगर वहाँ 700 से अधिक आइटम हैं। मेमोरी का उपयोग पेड़ की पत्तियों में सरणियों के उपयोग की तुलना में केवल थोड़ा अधिक SortedList(की तुलना में कम SortedDictionary) होना चाहिए ।

— Qwertie

Answer 3

मैं खुले परावर्तक को इस पर एक नज़र रखने के लिए क्रैक करता हूं क्योंकि ऐसा लगता है कि इसे लेकर थोड़ा भ्रम है SortedList। यह वास्तव में एक द्विआधारी खोज पेड़ नहीं है, यह कुंजी-मूल्य वाले जोड़े का एक सॉर्ट (कुंजी द्वारा) सरणी है । वहाँ भी है एकTKey[] keys चर जो कुंजी-मूल्य जोड़े के साथ सिंक में क्रमबद्ध है और द्विआधारी खोज के लिए उपयोग किया जाता है।

मेरे दावों का बैकअप लेने के लिए यहां कुछ स्रोत (.NET 4.5 को लक्षित) किया गया है।

निजी सदस्य

// Fields
private const int _defaultCapacity = 4;
private int _size;
[NonSerialized]
private object _syncRoot;
private IComparer<TKey> comparer;
private static TKey[] emptyKeys;
private static TValue[] emptyValues;
private KeyList<TKey, TValue> keyList;
private TKey[] keys;
private const int MaxArrayLength = 0x7fefffff;
private ValueList<TKey, TValue> valueList;
private TValue[] values;
private int version;

SortedList.ctor (IDEDIA, IComparer)

public SortedList(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer) : this((dictionary != null) ? dictionary.Count : 0, comparer)
{
    if (dictionary == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
    }
    dictionary.Keys.CopyTo(this.keys, 0);
    dictionary.Values.CopyTo(this.values, 0);
    Array.Sort<TKey, TValue>(this.keys, this.values, comparer);
    this._size = dictionary.Count;
}

SortedList.Add (TKey, TValue): शून्य

public void Add(TKey key, TValue value)
{
    if (key == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }
    int num = Array.BinarySearch<TKey>(this.keys, 0, this._size, key, this.comparer);
    if (num >= 0)
    {
        ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
    }
    this.Insert(~num, key, value);
}

SortedList.RemoveAt (int): शून्य

public void RemoveAt(int index)
{
    if ((index < 0) || (index >= this._size))
    {
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
    }
    this._size--;
    if (index < this._size)
    {
        Array.Copy(this.keys, index + 1, this.keys, index, this._size - index);
        Array.Copy(this.values, index + 1, this.values, index, this._size - index);
    }
    this.keys[this._size] = default(TKey);
    this.values[this._size] = default(TValue);
    this.version++;
}

Answer 4

की जाँच करें SortedList के लिए MSDN पेज :

टिप्पणी अनुभाग से:

SortedList<(Of <(TKey, TValue>)>)सामान्य वर्ग के साथ एक द्विआधारी खोज वृक्ष है O(log n)पुनर्प्राप्ति, जहां nशब्दकोश में तत्वों की संख्या है। इसमें, यह SortedDictionary<(Of <(TKey, TValue>)>)सामान्य वर्ग के समान है । दो वर्गों में समान ऑब्जेक्ट मॉडल होते हैं, और दोनों में O(log n)पुनर्प्राप्ति होती है। जहाँ दो वर्ग अलग-अलग होते हैं, स्मृति उपयोग और सम्मिलन और हटाने की गति:

• SortedList<(Of <(TKey, TValue>)>)से कम मेमोरी का उपयोग करता है SortedDictionary<(Of <(TKey, TValue>)>)।

• SortedDictionary<(Of <(TKey, TValue>)>)के O(log n)रूप में के O(n)लिए विरोध के रूप में तेजी से सम्मिलन और हटाए गए डेटा को हटाने के लिए है SortedList<(Of <(TKey, TValue>)>)।

• यदि सूची सभी प्रकार के डेटा से एक बार में पॉपुलेट की जाती है, SortedList<(Of <(TKey, TValue>)>)तो इससे अधिक तेज़ है SortedDictionary<(Of <(TKey, TValue>)>)।

Comments

उद्धृत पाठ गलत है (और MSDN पर अद्यतन किया गया था): SortedList एक "बाइनरी सर्च ट्री" नहीं है, यह "कुंजी / मूल्य जोड़े का एक सरणी" है।

— एल्ड्रिच कोन्ड्रम

Answer 5

यह दृश्य का प्रतिनिधित्व है कि प्रदर्शन एक दूसरे की तुलना कैसे करते हैं।

Comments

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

— एलेक्स कोस्टिन

Answer 6

पर्याप्त विषय पर पहले से ही कहा जाता है, हालांकि इसे सरल रखने के लिए, यहाँ मेरा लेना है।

सॉर्ट किए गए शब्दकोश का उपयोग तब किया जाना चाहिए जब-

• अधिक आवेषण और हटाने के संचालन की आवश्यकता होती है।
• संयुक्त राष्ट्र में डेटा।
• कुंजी का उपयोग पर्याप्त है और सूचकांक पहुंच की आवश्यकता नहीं है।
• स्मृति अड़चन नहीं है।

दूसरी तरफ, क्रमबद्ध सूची का उपयोग तब किया जाना चाहिए जब-

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

उम्मीद है की यह मदद करेगा!!

Answer 7

इंडेक्स एक्सेस (यहां उल्लिखित) व्यावहारिक अंतर है। यदि आपको उत्तराधिकारी या पूर्ववर्ती तक पहुंचने की आवश्यकता है, तो आपको SortedList की आवश्यकता है। क्रमबद्धता ऐसा नहीं कर सकती है ताकि आप काफी हद तक सीमित रहें कि आप छंटाई (पहली / छंटनी) का उपयोग कैसे कर सकते हैं।