Comment triez-vous un dictionnaire par valeur?

Je dois souvent trier un dictionnaire, composé de clés et de valeurs, par valeur. Par exemple, j'ai un hachage de mots et de fréquences respectives, que je veux classer par fréquence.

Il y en a un SortedListqui est bon pour une seule valeur (disons la fréquence), que je veux mettre en correspondance avec le mot.

SortedDictionary ordonne par clé, pas par valeur. Certains ont recours à une classe personnalisée , mais existe-t-il une méthode plus propre?

Utilisation:

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

Comme vous ciblez .NET 2.0 ou supérieur, vous pouvez simplifier cela en syntaxe lambda - c'est équivalent, mais plus court. Si vous ciblez .NET 2.0, vous ne pouvez utiliser cette syntaxe que si vous utilisez le compilateur de Visual Studio 2008 (ou supérieur).

var myList = aDictionary.ToList();

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

Utilisez 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;

Cela permettrait également une grande flexibilité dans la mesure où vous pouvez sélectionner le top 10, 20 10%, etc. Ou si vous utilisez votre indice de fréquence de mot pour type-ahead, vous pouvez également inclure une StartsWithclause.

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

En regardant autour de nous et en utilisant certaines fonctionnalités C # 3.0, nous pouvons le faire:

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

C'est la façon la plus propre que j'ai vue et elle est similaire à la manière Ruby de gérer les hachages.

Vous pouvez trier un dictionnaire par valeur et le sauvegarder sur lui-même (de sorte que lorsque vous l'avez consulté, les valeurs sortent dans l'ordre):

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

Bien sûr, ce n'est peut-être pas correct, mais cela fonctionne.

À un niveau élevé, vous n'avez pas d'autre choix que de parcourir l'ensemble du dictionnaire et d'examiner chaque valeur.

Peut-être que cela aide: http://bytes.com/forum/thread563638.html Copier / Coller de 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);
    }
);

De toute façon, vous ne pourrez jamais trier un dictionnaire. Ils ne sont pas réellement commandés. Les garanties pour un dictionnaire sont que les collections de clés et de valeurs sont itérables, et les valeurs peuvent être récupérées par index ou clé, mais il n'y a aucune garantie d'un ordre particulier. Par conséquent, vous auriez besoin d'obtenir la paire valeur-nom dans une liste.

Vous ne triez pas les entrées du dictionnaire. La classe de dictionnaire dans .NET est implémentée comme une table de hachage - cette structure de données n'est pas triable par définition.

Si vous devez pouvoir parcourir votre collection (par clé) - vous devez utiliser SortedDictionary, qui est implémenté comme un arbre de recherche binaire.

Dans votre cas, cependant, la structure source n'est pas pertinente, car elle est triée par un champ différent. Vous auriez encore besoin de le trier par fréquence et de le mettre dans une nouvelle collection triée par le champ pertinent (fréquence). Ainsi, dans cette collection, les fréquences sont des clés et les mots sont des valeurs. Étant donné que de nombreux mots peuvent avoir la même fréquence (et que vous allez l'utiliser comme clé), vous ne pouvez pas utiliser ni Dictionary ni SortedDictionary (ils nécessitent des clés uniques). Cela vous laisse avec une SortedList.

Je ne comprends pas pourquoi vous insistez pour maintenir un lien vers l'élément d'origine dans votre dictionnaire principal / premier.

Si les objets de votre collection avaient une structure plus complexe (plus de champs) et que vous deviez pouvoir y accéder / trier efficacement en utilisant plusieurs champs différents comme clés - Vous auriez probablement besoin d'une structure de données personnalisée qui consisterait en le stockage principal qui prend en charge l'insertion et la suppression de O (1) (LinkedList) et plusieurs structures d'indexation - Dictionnaires / SortedDictionaries / SortedLists. Ces index utiliseraient l'un des champs de votre classe complexe comme clé et un pointeur / référence vers LinkedListNode dans LinkedList comme valeur.

Vous auriez besoin de coordonner les insertions et les suppressions pour garder vos index synchronisés avec la collection principale (LinkedList) et les suppressions seraient assez chères, je pense. Ceci est similaire au fonctionnement des index de base de données - ils sont fantastiques pour les recherches mais ils deviennent un fardeau lorsque vous devez effectuer de nombreuses insertions et suppressions.

Tout ce qui précède n'est justifié que si vous allez effectuer un traitement lourd de recherche. Si vous n'avez besoin de les sortir qu'une fois triés par fréquence, vous pouvez simplement produire une liste de tuples (anonymes):

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);

Ou pour le plaisir, vous pouvez utiliser certains avantages de l'extension 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));

Tri d'une SortedDictionaryliste à lier dans un ListViewcontrôle à l'aide de 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>

La façon la plus simple d'obtenir un dictionnaire trié est d'utiliser la SortedDictionaryclasse intégrée :

//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 testament contient la version triée de sections

Les autres réponses sont bonnes, si tout ce que vous voulez, c'est d'avoir une liste "temporaire" triée par valeur. Cependant, si vous souhaitez avoir un dictionnaire trié par Keyqui se synchronise automatiquement avec un autre dictionnaire trié par Value, vous pouvez utiliser la Bijection<K1, K2>classe .

Bijection<K1, K2> vous permet d'initialiser la collection avec deux dictionnaires existants, donc si vous voulez que l'un d'eux ne soit pas trié et que l'autre soit trié, vous pouvez créer votre bijection avec du code comme

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

Vous pouvez utiliser dictcomme n'importe quel dictionnaire normal (il implémente IDictionary<K, V>), puis appeler dict.Inversepour obtenir le dictionnaire "inverse" qui est trié par Value.

Bijection<K1, K2>fait partie de Loyc.Collections.dll , mais si vous le souhaitez, vous pouvez simplement copier le code source dans votre propre projet.

Remarque : dans le cas où plusieurs clés ont la même valeur, vous ne pouvez pas les utiliser Bijection, mais vous pouvez synchroniser manuellement entre un ordinaire Dictionary<Key,Value>et un BMultiMap<Value,Key>.

Supposons que nous ayons un dictionnaire comme

   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) vous pouvez utiliser 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);
        }

En fait, en C #, les dictionnaires ont des méthodes sort (), car vous êtes plus intéressé par le tri par valeurs, vous ne pouvez pas obtenir de valeurs jusqu'à ce que vous leur fournissiez la clé, bref, vous devez les parcourir, en utilisant Order By de LINQ,

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
}

vous pouvez faire un tour,

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

ou

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

Cela dépend également du type de valeurs que vous stockez, est-il unique (comme chaîne, entier) ou multiple (comme Liste, Tableau, classe définie par l'utilisateur),
si unique, vous pouvez en faire une liste puis appliquer le tri.
si la classe est définie par l'utilisateur, cette classe doit implémenter IComparable
ClassName: IComparable<ClassName>et remplacer compareTo(ClassName c) car elles sont plus rapides que LINQ et plus orientées objet.

Espace de noms requis: 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);

Trier par desc:

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

Ordre par Asc:

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

Vous pouvez trier le dictionnaire par valeur et obtenir le résultat dans le dictionnaire en utilisant le code ci-dessous:

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

Étant donné que vous avez un dictionnaire, vous pouvez les trier directement sur les valeurs en utilisant ci-dessous une ligne:

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