Come si ordina un dizionario per valore?

Spesso devo ordinare un dizionario, composto da chiavi e valori, per valore. Ad esempio, ho un hash di parole e rispettive frequenze, che voglio ordinare per frequenza.

C'è un SortedListvalore buono per un singolo valore (diciamo frequenza), che voglio mappare di nuovo sulla parola.

SortedDictionary ordina per chiave, non per valore. Alcuni ricorrono a una lezione personalizzata , ma esiste un modo più pulito?

Uso:

using System.Linq.Enumerable;
...
List<KeyValuePair<string, string>> myList = aDictionary.ToList();

myList.Sort(
    delegate(KeyValuePair<string, string> pair1,
    KeyValuePair<string, string> pair2)
    {
        return pair1.Value.CompareTo(pair2.Value);
    }
);

Dato che stai prendendo di mira .NET 2.0 o versioni successive, puoi semplificarlo nella sintassi lambda: è equivalente, ma più breve. Se si utilizza .NET 2.0 come destinazione, è possibile utilizzare questa sintassi solo se si utilizza il compilatore di Visual Studio 2008 (o versione successiva).

var myList = aDictionary.ToList();

myList.Sort((pair1,pair2) => pair1.Value.CompareTo(pair2.Value));

Usa LINQ:

Dictionary<string, int> myDict = new Dictionary<string, int>();
myDict.Add("one", 1);
myDict.Add("four", 4);
myDict.Add("two", 2);
myDict.Add("three", 3);

var sortedDict = from entry in myDict orderby entry.Value ascending select entry;

Ciò consentirebbe anche una grande flessibilità in quanto è possibile selezionare i primi 10, 20 10%, ecc. O se si utilizza l'indice di frequenza delle parole per type-ahead, è possibile includere anche la StartsWithclausola.

var ordered = dict.OrderBy(x => x.Value);

Guardandoci intorno e usando alcune funzionalità di C # 3.0 possiamo farlo:

foreach (KeyValuePair<string,int> item in keywordCounts.OrderBy(key=> key.Value))
{ 
    // do something with item.Key and item.Value
}

Questo è il modo più pulito che ho visto ed è simile al modo in cui Ruby gestisce gli hash.

Puoi ordinare un Dizionario in base al valore e salvarlo di nuovo su se stesso (in modo che, quando lo prevedi, i valori escano in ordine):

dict = dict.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value);

Certo, potrebbe non essere corretto, ma funziona.

A un livello elevato, non hai altra scelta che attraversare l'intero dizionario e guardare ogni valore.

Forse questo aiuta: http://bytes.com/forum/thread563638.html Copia / Incolla da John Timney:

Dictionary<string, string> s = new Dictionary<string, string>();
s.Add("1", "a Item");
s.Add("2", "c Item");
s.Add("3", "b Item");

List<KeyValuePair<string, string>> myList = new List<KeyValuePair<string, string>>(s);
myList.Sort(
    delegate(KeyValuePair<string, string> firstPair,
    KeyValuePair<string, string> nextPair)
    {
        return firstPair.Value.CompareTo(nextPair.Value);
    }
);

Non saresti mai in grado di ordinare un dizionario comunque. In realtà non sono ordinati. Le garanzie per un dizionario sono che le raccolte di chiavi e valori sono iterabili e che i valori possono essere recuperati per indice o chiave, ma non esiste alcuna garanzia per alcun ordine particolare. Quindi è necessario inserire la coppia valore-nome in un elenco.

Non ordinare le voci nel dizionario. La classe del dizionario in .NET è implementata come hashtable - questa struttura di dati non è ordinabile per definizione.

Se devi essere in grado di scorrere la tua raccolta (per chiave), devi utilizzare SortedDictionary, che viene implementato come albero di ricerca binario.

Nel tuo caso, tuttavia, la struttura di origine è irrilevante, poiché è ordinata per un campo diverso. Dovresti comunque ordinarlo per frequenza e inserirlo in una nuova raccolta ordinata per il campo pertinente (frequenza). Quindi in questa raccolta le frequenze sono chiavi e le parole sono valori. Poiché molte parole possono avere la stessa frequenza (e la userete come chiave) non è possibile utilizzare né Dictionary né SortedDictionary (richiedono chiavi univoche). Questo ti lascia con un SortedList.

Non capisco perché insisti a mantenere un collegamento all'elemento originale nel tuo dizionario principale / primo.

Se gli oggetti nella tua raccolta avessero una struttura più complessa (più campi) e tu dovessi essere in grado di accedervi / ordinarli in modo efficiente usando diversi campi come chiavi - Probabilmente avresti bisogno di una struttura di dati personalizzata che consisterebbe nella memoria principale che supporta l'inserimento e la rimozione di O (1) (LinkedList) e diverse strutture di indicizzazione - Dictionaries / SortedDictionaries / SortedLists. Questi indici utilizzerebbero uno dei campi della tua classe complessa come chiave e un puntatore / riferimento a LinkedListNode in LinkedList come valore.

Dovresti coordinare inserimenti e rimozioni per mantenere i tuoi indici sincronizzati con la raccolta principale (LinkedList) e le rimozioni sarebbero piuttosto costose, penso. Questo è simile al modo in cui funzionano gli indici del database: sono fantastici per le ricerche ma diventano un peso quando è necessario eseguire molte eliminazioni ed eliminazioni.

Tutto quanto sopra è giustificato solo se hai intenzione di eseguire qualche elaborazione pesante di ricerca. Se hai bisogno di emetterli solo una volta ordinati per frequenza, potresti semplicemente produrre un elenco di tuple (anonime):

var dict = new SortedDictionary<string, int>();
// ToDo: populate dict

var output = dict.OrderBy(e => e.Value).Select(e => new {frequency = e.Value, word = e.Key}).ToList();

foreach (var entry in output)
{
    Console.WriteLine("frequency:{0}, word: {1}",entry.frequency,entry.word);
}

Dictionary<string, string> dic= new Dictionary<string, string>();
var ordered = dic.OrderBy(x => x.Value);
return ordered.ToDictionary(t => t.Key, t => t.Value);

O per divertimento potresti usare un po 'di estensione LINQ:

var dictionary = new Dictionary<string, int> { { "c", 3 }, { "a", 1 }, { "b", 2 } };
dictionary.OrderBy(x => x.Value)
  .ForEach(x => Console.WriteLine("{0}={1}", x.Key,x.Value));

Ordinamento di un SortedDictionaryelenco da associare a un ListViewcontrollo tramite VB.NET:

Dim MyDictionary As SortedDictionary(Of String, MyDictionaryEntry)

MyDictionaryListView.ItemsSource = MyDictionary.Values.OrderByDescending(Function(entry) entry.MyValue)

Public Class MyDictionaryEntry ' Need Property for GridViewColumn DisplayMemberBinding
    Public Property MyString As String
    Public Property MyValue As Integer
End Class

XAML:

<ListView Name="MyDictionaryListView">
    <ListView.View>
        <GridView>
            <GridViewColumn DisplayMemberBinding="{Binding Path=MyString}" Header="MyStringColumnName"></GridViewColumn>
            <GridViewColumn DisplayMemberBinding="{Binding Path=MyValue}" Header="MyValueColumnName"></GridViewColumn>
         </GridView>
    </ListView.View>
</ListView>

Il modo più semplice per ottenere un dizionario ordinato è utilizzare la SortedDictionaryclasse integrata :

//Sorts sections according to the key value stored on "sections" unsorted dictionary, which is passed as a constructor argument
System.Collections.Generic.SortedDictionary<int, string> sortedSections = null;
if (sections != null)
{
    sortedSections = new SortedDictionary<int, string>(sections);
}

sortedSections contiene la versione ordinata di sections

Le altre risposte sono buone, se tutto quello che vuoi è avere un elenco "temporaneo" ordinato per Valore. Tuttavia, se si vuole avere un dizionario ordinato secondo Keyche si sincronizza automaticamente con un altro dizionario che viene allineati secondo Value, è possibile utilizzare il Bijection<K1, K2>codice categoria .

Bijection<K1, K2> ti consente di inizializzare la raccolta con due dizionari esistenti, quindi se vuoi che uno di essi non sia ordinato e desideri che l'altro sia ordinato, puoi creare la tua biiezione con codice come

var dict = new Bijection<Key, Value>(new Dictionary<Key,Value>(), 
                               new SortedDictionary<Value,Key>());

È possibile utilizzare dictcome qualsiasi altro dizionario normale (implementa IDictionary<K, V>) e quindi chiamare dict.Inverseper ottenere il dizionario "inverso" che viene ordinato per Value.

Bijection<K1, K2>fa parte di Loyc.Collections.dll , ma se lo desideri, puoi semplicemente copiare il codice sorgente nel tuo progetto.

Nota : nel caso in cui vi siano più chiavi con lo stesso valore, non è possibile utilizzare Bijection, ma è possibile sincronizzare manualmente tra un normale Dictionary<Key,Value>e un BMultiMap<Value,Key>.

Supponiamo di avere un dizionario come

   Dictionary<int, int> dict = new Dictionary<int, int>();
   dict.Add(21,1041);
   dict.Add(213, 1021);
   dict.Add(45, 1081);
   dict.Add(54, 1091);
   dict.Add(3425, 1061);
   sict.Add(768, 1011);

1) puoi usare temporary dictionary to store values as:

        Dictionary<int, int> dctTemp = new Dictionary<int, int>();

        foreach (KeyValuePair<int, int> pair in dict.OrderBy(key => key.Value))
        {
            dctTemp .Add(pair.Key, pair.Value);
        }

In realtà in C #, i dizionari dint hanno metodi sort (), poiché sei più interessato all'ordinamento per valori, non puoi ottenere valori fino a quando non fornisci loro la chiave, in breve, devi iterarli attraverso, usando LINQ's Order By,

var items = new Dictionary<string, int>();
items.Add("cat", 0);
items.Add("dog", 20);
items.Add("bear", 100);
items.Add("lion", 50);

// Call OrderBy method here on each item and provide them the ids.
foreach (var item in items.OrderBy(k => k.Key))
{
    Console.WriteLine(item);// items are in sorted order
}

puoi fare un trucco,

var sortedDictByOrder = items.OrderBy(v => v.Value);

o

var sortedKeys = from pair in dictName
            orderby pair.Value ascending
            select pair;

dipende anche dal tipo di valori che stai memorizzando,
è singolo (come stringa, int) o multiplo (come Elenco, matrice, classe definita dall'utente),
se singolo puoi crearne un elenco e quindi applicare l'ordinamento.
se una classe definita dall'utente, quella classe deve implementare IComparable
ClassName: IComparable<ClassName>e sovrascrivere compareTo(ClassName c) poiché sono più veloci di LINQ e più orientati agli oggetti.

Spazio dei nomi richiesto: using System.Linq;

Dictionary<string, int> counts = new Dictionary<string, int>();
counts.Add("one", 1);
counts.Add("four", 4);
counts.Add("two", 2);
counts.Add("three", 3);

Ordina per descrizione:

foreach (KeyValuePair<string, int> kvp in counts.OrderByDescending(key => key.Value))
{
// some processing logic for each item if you want.
}

Ordina per Asc:

foreach (KeyValuePair<string, int> kvp in counts.OrderBy(key => key.Value))
{
// some processing logic for each item if you want.
}

Puoi ordinare il Dizionario per valore e ottenere il risultato nel dizionario usando il codice seguente:

Dictionary <<string, string>> ShareUserNewCopy = 
       ShareUserCopy.OrderBy(x => x.Value).ToDictionary(pair => pair.Key,
                                                        pair => pair.Value);                                          

Dato che hai un dizionario, puoi ordinarli direttamente sui valori usando sotto un liner:

var x = (from c in dict orderby c.Value.Order ascending select c).ToDictionary(c => c.Key, c=>c.Value);