SortedList ve SortedDictionary arasındaki fark nedir?

A arasında gerçek bir pratik fark var mı SortedList<TKey,TValue> ve aSortedDictionary<TKey,TValue> ? Birini diğerini değil, özellikle kullanacağınız durumlar var mı?

Evet - performans özellikleri önemli ölçüde farklılık gösterir. Muhtemelen onları aramak daha iyi olur SortedListve SortedTreebu da uygulamayı daha yakından yansıtır.

Farklı durumlardaki farklı işlemlerin performansıyla ilgili ayrıntılar için her biri için MSDN belgelerine bakın ( SortedList, SortedDictionary). İşte güzel bir özet ( SortedDictionarydokümanlardan):

SortedDictionary<TKey, TValue>Jenerik sınıf n sözlükte eleman sayısıdır O (log n) alma, bir ikili arama ağacı. SortedList<TKey, TValue>Bunda jenerik sınıfa benzer . İki sınıf benzer nesne modellerine sahiptir ve her ikisinde de O (log n) alımı vardır. İki sınıfın farklı olduğu yerler bellek kullanımı ve takma ve çıkarma hızıdır:

• SortedList<TKey, TValue>daha az bellek kullanır SortedDictionary<TKey, TValue>.

• SortedDictionary<TKey, TValue>sıralanmamış veriler için daha hızlı ekleme ve çıkarma işlemleri vardır, O (log n), O (n) yerine SortedList<TKey, TValue>.

• Liste sıralı verilerden bir defada doldurulursa SortedList<TKey, TValue>, daha hızlıdır SortedDictionary<TKey, TValue>.

( SortedListaslında bir ağaç kullanmak yerine sıralanmış bir diziyi korur. Öğeleri bulmak için yine de ikili arama kullanır.)

İşte yardımcı oluyorsa tablo görünümü ...

Bir itibaren performans perspektifinden:

+------------------+---------+----------+--------+----------+----------+---------+
| 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).

Bir itibaren uygulanması bakış açısı:

+------------+---------------+----------+------------+------------+------------------+
| 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              |
+------------+---------------+----------+------------+------------+------------------+

To kabaca ham performans gerektiriyorsa başka kelimelerle, SortedDictionarydaha iyi bir seçim olabilir. Daha az bellek ek yükü ve endeksli alım gerekiyorsa SortedListdaha iyi uyuyor.Hangisinin ne zaman kullanılacağı hakkında daha fazla bilgi için bu soruya bakın.

Burada , burada , burada , burada ve burada daha fazlasını okuyabilirsiniz .

Bu konuda bir göz atmak için açık Reflektörü kırdım, çünkü biraz karışıklık var gibi görünüyor SortedList. Aslında bir ikili arama ağacı değildir , anahtar / değer çiftlerinin sıralı (anahtar ile) dizisidir . Ayrıca, TKey[] keysanahtar / değer çiftleriyle senkronize olarak sıralanan ve ikili arama için kullanılan bir değişken de vardır .

İşte iddialarımı yedeklemek için bazı kaynak (.NET 4.5 hedefleme).

Özel üyeler

// 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 (IDictionary, 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): geçersiz

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): geçersiz

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++;
}

SortedList için MSDN sayfasına göz atın :

Açıklamalar bölümünden:

SortedList<(Of <(TKey, TValue>)>)Jenerik sınıf bir ikili arama ağacı O(log n)alımı, nsözlükte elemanların sayısıdır. SortedDictionary<(Of <(TKey, TValue>)>)Bunda jenerik sınıfa benzer . İki sınıf benzer nesne modellerine sahiptir ve her ikisi de O(log n)geri çağırma özelliğine sahiptir. İki sınıfın farklı olduğu yerler bellek kullanımı ve takma ve çıkarma hızıdır:

• SortedList<(Of <(TKey, TValue>)>)daha az bellek kullanır SortedDictionary<(Of <(TKey, TValue>)>).

• SortedDictionary<(Of <(TKey, TValue>)>)Daha hızlı yerleştirilmesini ve sıralanmamış veriler için kaldırma işlemleri vardır O(log n)karşı O(n)için SortedList<(Of <(TKey, TValue>)>).

• Liste sıralı verilerden bir defada doldurulursa SortedList<(Of <(TKey, TValue>)>), daha hızlıdır SortedDictionary<(Of <(TKey, TValue>)>).

Bu, performansların birbirleriyle nasıl karşılaştırıldığının görsel temsilidir.

Yeterince konuyla ilgili zaten söyleniyor, ancak basit tutmak için benim almam.

Sıralı sözlük şu durumlarda kullanılmalıdır:

• Daha fazla ekleme ve silme işlemi gerekir.
• Veriler sıralanmamış.
• Anahtar erişimi yeterlidir ve dizin erişimi gerekli değildir.
• Bellek bir darboğaz değildir.

Diğer tarafta, Sıralı Liste aşağıdaki durumlarda kullanılmalıdır.

• Daha fazla arama ve daha az kesici uç ve silme işlemi gerekir.
• Veriler zaten sıralanmıştır (hepsi değilse de, çoğu).
• Dizin erişimi gerekiyor.
• Bellek bir yüktür.

Bu yardımcı olur umarım!!

İndeks erişimi (burada belirtilmiştir) pratik farktır. Halef veya selefine erişmeniz gerekiyorsa SortedList'e ihtiyacınız var. SortedDictionary bunu yapamaz, bu nedenle sıralama (ilk / foreach) nasıl kullanabileceğiniz ile oldukça sınırlıdır.