Rückwärts Sortiert Wörterbuch in .NET

Question

Gibt es eine Möglichkeit, nach hinten (rückwärts) laufen kann durch eine SortedDictionary in c #?

Oder gibt es eine Möglichkeit, die SortedDictionary in absteigender Reihenfolge zu beginnen zu definieren?

Answer 1

Die SortedDictionary selbst nicht unterstützt Rückwärtsiteration, aber Sie haben mehrere Möglichkeiten, um den gleichen Effekt zu erzielen.

1. Mit .Reverse-Methode (Linq). (Dies wird die gesamte Wörterbuch Ausgabe vorab berechnen muß, sondern ist die einfachste Lösung)

   var Rand = new Random();
   
   var Dict = new SortedDictionary<int, string>();
   
   for (int i = 1; i <= 10; ++i) {
       var newItem = Rand.Next(1, 100);
       Dict.Add(newItem, (newItem * newItem).ToString());
   }
   
   foreach (var x in Dict.Reverse()) {
       Console.WriteLine("{0} -> {1}", x.Key, x.Value);
   }
   

2. Machen Sie die Wörterbuch-Sortierreihenfolge in absteigender Reihenfolge.

   class DescendingComparer<T> : IComparer<T> where T : IComparable<T> {
       public int Compare(T x, T y) {
           return y.CompareTo(x);
       }
   }
   
   // ...
   
   var Dict = new SortedDictionary<int, string>(new DescendingComparer<int>());
   

3. Verwenden SortedList<TKey, TValue> statt. Die Leistung ist nicht so gut wie das Wörterbuch der (O (n) anstelle von O (log n)), aber Sie haben Random-Access an den Elementen wie in Arrays. Wenn Sie die generische IDictionary-Schnittstelle verwenden, werden Sie nicht den Rest des Codes zu ändern.

Bearbeiten :: Iterieren auf SortedLists

Sie greifen nur die Elemente von Index!

var Rand = new Random();


var Dict = new SortedList<int, string>();

for (int i = 1; i <= 10; ++i) {
    var newItem = Rand.Next(1, 100);
    Dict.Add(newItem, (newItem * newItem).ToString());
}

// Reverse for loop (forr + tab)
for (int i = Dict.Count - 1; i >= 0; --i) {
    Console.WriteLine("{0} -> {1}", Dict.Keys[i], Dict.Values[i]);
}

Answer 2

Der einfachste Weg, um die SortedDictionary in umgekehrter Reihenfolge, mit zu beginnen zu definieren, ist es mit einem IComparer<TKey> zu schaffen, die in der umgekehrten Reihenfolge zu normalen sortiert.

Hier ist ein Code von MiscUtil , die das für Sie leichter machen könnten:

using System.Collections.Generic;

namespace MiscUtil.Collections
{
    /// <summary>
    /// Implementation of IComparer{T} based on another one;
    /// this simply reverses the original comparison.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class ReverseComparer<T> : IComparer<T>
    {
        readonly IComparer<T> originalComparer;

        /// <summary>
        /// Returns the original comparer; this can be useful
        /// to avoid multiple reversals.
        /// </summary>
        public IComparer<T> OriginalComparer
        {
            get { return originalComparer; }
        }

        /// <summary>
        /// Creates a new reversing comparer.
        /// </summary>
        /// <param name="original">The original comparer to 
        /// use for comparisons.</param>
        public ReverseComparer(IComparer<T> original)
        {
            if (original == null)
            { 
                throw new ArgumentNullException("original");
            }
            this.originalComparer = original;
        }

        /// <summary>
        /// Returns the result of comparing the specified
        /// values using the original
        /// comparer, but reversing the order of comparison.
        /// </summary>
        public int Compare(T x, T y)
        {
            return originalComparer.Compare(y, x);
        }
    }
}

Sie würden dann verwenden:

var dict = new SortedDictionary<string, int>
     (new ReverseComparer<string>(StringComparer.InvariantCulture));

(oder welcher Art auch immer Sie verwendet).

Wenn Sie immer nur in eine Richtung durchlaufen wollen, wird dies effizienter sein als die Reihenfolge danach umgekehrt wird.

Answer 3

Es gibt auch einen sehr einfachen Ansatz, wenn Sie mit numerischen Werten als Schlüssel handeln, die ist sie einfach zu negieren, wenn Sie das Wörterbuch erstellen.

Answer 4

Kurz erstellen umgekehrt sortiert Wörterbuch in einer Zeile .

var dict = new SortedDictionary<int, int>(Comparer<int>.Create((x, y) => y.CompareTo(x)));

Es gibt eine Möglichkeit, eine IComparer<T> mit System.Collections.Generic.Comparer<T> zu erstellen. Übergeben Sie einfach einen IComparision<T> Delegierten seiner Create Methode eine IComparer<T> zu bauen.

var dict = new SortedDictionary<int, TValue>(
    Comparer<int>.Create(
        delegate(int x, int y)
        {
            return y.CompareTo(x);
        }
    )
);

Sie können einen Lambda-Ausdruck verwenden / lokale Funktion / Methode , um die Delegierten zu ersetzen, wenn ihre Bedeutung (TKey, TKey) => int ist.

Answer 5

Wenn Sie .NET 3.5 verwenden, können Sie die OrderByDescending Erweiterungsmethode verwenden:

        var dictionary = new SortedDictionary<int, string>();
        dictionary.Add(1, "One");
        dictionary.Add(3, "Three");
        dictionary.Add(2, "Two");
        dictionary.Add(4, "Four");



        var q = dictionary.OrderByDescending(kvp => kvp.Key);
        foreach (var item in q)
        {
            Console.WriteLine(item.Key + " , " + item.Value);
        }