Was ist der Unterschied zwischen SortedList und SortedDictionary?

Gibt es einen wirklichen praktischen Unterschied zwischen a SortedList<TKey,TValue>und a SortedDictionary<TKey,TValue>? Gibt es Umstände, unter denen Sie speziell das eine und nicht das andere verwenden würden?

Ja - ihre Leistungsmerkmale unterscheiden sich erheblich. Es wäre wahrscheinlich besser, sie zu nennen SortedListund SortedTreewie spiegelt die Umsetzung näher.

In den MSDN-Dokumenten für jeden von ihnen ( SortedList, SortedDictionary) finden Sie Details zur Leistung für verschiedene Vorgänge in verschiedenen Situationen. Hier ist eine schöne Zusammenfassung (aus den SortedDictionaryDokumenten):

Die SortedDictionary<TKey, TValue>generische Klasse ist ein binärer Suchbaum mit O-Abruf (log n), wobei n die Anzahl der Elemente im Wörterbuch ist. In dieser Hinsicht ähnelt es der SortedList<TKey, TValue>generischen Klasse. Die beiden Klassen haben ähnliche Objektmodelle und beide haben einen O (log n) -Abruf. Wo sich die beiden Klassen unterscheiden, ist die Speichernutzung und die Geschwindigkeit des Einfügens und Entfernens:

• SortedList<TKey, TValue>verbraucht weniger Speicher als SortedDictionary<TKey, TValue>.

• SortedDictionary<TKey, TValue>hat schnellere Einfüge- und Entfernungsvorgänge für unsortierte Daten, O (log n) im Gegensatz zu O (n) für SortedList<TKey, TValue>.

• Wenn die Liste auf einmal aus sortierten Daten gefüllt wird, SortedList<TKey, TValue>ist dies schneller als SortedDictionary<TKey, TValue>.

(verwaltet SortedListtatsächlich ein sortiertes Array, anstatt einen Baum zu verwenden. Es verwendet immer noch die binäre Suche, um Elemente zu finden.)

Hier ist eine tabellarische Ansicht, wenn es hilft ...

Aus Sicht der Leistung :

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

Aus Sicht der Implementierung :

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

Um es grob zu paraphrasieren: Wenn Sie Rohleistung benötigen, ist SortedDictionarydies möglicherweise die bessere Wahl. Wenn Sie weniger Speicheraufwand benötigen und der indizierte Abruf SortedListbesser passt. In dieser Frage erfahren Sie mehr darüber, wann Sie welche verwenden sollen.

Sie können hier , hier , hier , hier und hier mehr lesen .

Ich habe Reflector aufgeschlagen, um mir das anzusehen, da es ein bisschen Verwirrung zu geben scheint SortedList. Es ist in der Tat kein binärer Suchbaum, sondern ein sortiertes (nach Schlüssel) Array von Schlüssel-Wert-Paaren . Es gibt auch eine TKey[] keysVariable, die synchron mit den Schlüssel-Wert-Paaren sortiert und für die binäre Suche verwendet wird.

Hier ist eine Quelle (für .NET 4.5), um meine Ansprüche zu sichern.

Private Mitglieder

// 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): nichtig

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): void

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

Überprüfen Sie die MSDN-Seite für SortedList :

Aus dem Abschnitt Bemerkungen:

Die SortedList<(Of <(TKey, TValue>)>)generische Klasse ist ein binärer Suchbaum mit O(log n)Abruf, wobei ndie Anzahl der Elemente im Wörterbuch angegeben ist. In dieser Hinsicht ähnelt es der SortedDictionary<(Of <(TKey, TValue>)>)generischen Klasse. Die beiden Klassen haben ähnliche Objektmodelle und beide haben einen O(log n)Abruf. Wo sich die beiden Klassen unterscheiden, ist die Speichernutzung und die Geschwindigkeit des Einfügens und Entfernens:

• SortedList<(Of <(TKey, TValue>)>)verbraucht weniger Speicher als SortedDictionary<(Of <(TKey, TValue>)>).

• SortedDictionary<(Of <(TKey, TValue>)>)hat schnellere Einfüge- und Entfernungsvorgänge für unsortierte Daten O(log n)im Gegensatz zu O(n)für SortedList<(Of <(TKey, TValue>)>).

• Wenn die Liste auf einmal aus sortierten Daten gefüllt wird, SortedList<(Of <(TKey, TValue>)>)ist dies schneller als SortedDictionary<(Of <(TKey, TValue>)>).

Dies ist eine visuelle Darstellung des Vergleichs der Leistungen untereinander.

Zu diesem Thema ist bereits genug gesagt, aber um es einfach zu halten, hier ist meine Meinung.

Sortiertes Wörterbuch sollte verwendet werden, wenn-

• Weitere Einfüge- und Löschvorgänge sind erforderlich.
• Daten unbestellt.
• Der Schlüsselzugriff ist ausreichend und der Indexzugriff ist nicht erforderlich.
• Speicher ist kein Engpass.

Auf der anderen Seite sollte die sortierte Liste verwendet werden, wenn

• Es sind mehr Suchvorgänge und weniger Einfügungen und Löschvorgänge erforderlich.
• Die Daten sind bereits sortiert (wenn nicht alle, die meisten).
• Indexzugriff ist erforderlich.
• Speicher ist ein Overhead.

Hoffe das hilft!!

Der Indexzugriff (hier erwähnt) ist der praktische Unterschied. Wenn Sie auf den Nachfolger oder Vorgänger zugreifen müssen, benötigen Sie SortedList. SortedDictionary kann das nicht, daher sind Sie ziemlich eingeschränkt in der Verwendung der Sortierung (first / foreach).