Cum sortezi un dicționar după valoare?

La un nivel înalt, nu ai altă posibilitate decât să mergi prin întregul dicționar și să privești fiecare valoare.

Poate că acest lucru vă ajută: http://bytes.com/forum/thread563638.html Copierea / lipirea de la John Timney:

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

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

Privind în jur și folosind câteva funcții C# 3.0, putem face acest lucru:

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

Acesta este cel mai curat mod pe care l-am văzut și este similar cu modul ruby de manipulare hashes.

Utilizare:

using System.Linq.Enumerable;
...
List> myList = aDictionary.ToList();

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

Since you're targeting .NET 2.0 or above, you can simplify this into lambda syntax -- it's equivalent, but shorter. If you're targeting .NET 2.0 you can only use this syntax if you're using the compiler from Visual Studio 2008 (or above).

var myList = aDictionary.ToList();

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

Utilizați LINQ:

Dictionary myDict = new Dictionary();
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;

Acest lucru ar permite, de asemenea, o mare flexibilitate în faptul că puteți selecta topul 10, 20 10% etc. De asemenea, dacă utilizați indexul de frecvență pentru codul type-ahead , puteți include și Începe și cu clauza .

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

Niciodată nu ai putea să sortezi un dicționar oricum. Ele nu sunt de fapt ordonate. Garanțiile pentru un dictionar sunt că colecțiile cheie și valori sunt iterabile, iar valorile pot fi extrase prin index sau cheie, dar aici nu există nicio garanție a unei anumite ordini. Prin urmare, va trebui să obțineți o pereche de valori de nume într-o listă.

Puteți să sortați un Dicționar după valoare și să îl salvați înapoi la el însuși (astfel încât atunci când precizați peste acesta valorile să iasă în ordine):

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

Sigur, poate că nu este corect, dar funcționează.

Având în vedere că aveți un dicționar, puteți să le sortați direct pe valori utilizând mai jos un singur liner:

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

Sortarea unei liste SortedDictionary pentru a se lega într-un control ListView folosind 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:

The other answers are good, if you all you want is to have a "temporary" list sorted by Value. However, if you want to have a dictionary sorted by Key that automatically synchronizes with another dictionary that is sorted by Value, you could use the Bijection class.

Bijection allows you to initialize the collection with two existing dictionaries, so if you want one of them to be unsorted, and you want the other one to be sorted, you could create your bijection with code like

var dict = new Bijection(new Dictionary(), 
                               new SortedDictionary());

You can use dict like any normal dictionary (it implements IDictionary<>), and then call dict.Inverse to get the "inverse" dictionary which is sorted by Value.

Bijection is part of Loyc.Collections.dll, but if you want, you could simply copy the source code into your own project.

Note: In case there are multiple keys with the same value, you can't use Bijection, but you could manually synchronize between an ordinary Dictionary and a BMultiMap.

Sau pentru distracție ai putea folosi o bunătate a extensiei LINQ:

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

Valorile de sortare

Aceasta arată modul de sortare a valorilor într-un Dicționar. Vom vedea un program de consola pe care îl puteți compila în Visual Studio și rulați. Se adaugă cheile unui Dicționar și apoi le sortează după valorile lor. Amintiți-vă că instanțele de dicționar nu sunt sortate inițial în nici un fel. Folosim cuvântul cheie LINQ orderby într-o instrucțiune de interogare.

Clauza de comandă Program care sortează Dicționar [C #]

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // Example dictionary.
        var dictionary = new Dictionary(5);
        dictionary.Add("cat", 1);
        dictionary.Add("dog", 0);
        dictionary.Add("mouse", 5);
        dictionary.Add("eel", 3);
        dictionary.Add("programmer", 2);

        // Order by values.
        // ... Use LINQ to specify sorting by value.
        var items = from pair in dictionary
                orderby pair.Value ascending
                select pair;

        // Display results.
        foreach (KeyValuePair pair in items)
        {
            Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
        }

        // Reverse sort.
        // ... Can be looped over in the same way as above.
        items = from pair in dictionary
        orderby pair.Value descending
        select pair;
    }
}

producție

dog: 0
cat: 1
programmer: 2
eel: 3
mouse: 5

Nu sortați înscrierile în dicționar. Dicționarul de clasă în .NET este implementat ca un hashtable - această structură de date nu este definită prin definiție.

Dacă trebuie să puteți relua colecția dvs. (cu cheie) - trebuie să utilizați SortedDictionary, care este implementat ca arbore de căutare binară.

În cazul tău, structura sursă este irelevantă, deoarece este sortată de un alt câmp. Încă mai trebuie să o sortați după frecvență și să o puneți într-o nouă colecție sortată după câmpul relevant (frecvență). Deci, în această colecție frecvențele sunt chei, iar cuvintele sunt valori. Deoarece multe cuvinte pot avea aceeași frecvență (și o veți folosi ca o cheie), nu puteți utiliza nici dicționarul, nici SortedDictionary (acestea necesită chei unice). Acest lucru vă va lăsa cu un SortedList.

Nu înțeleg de ce insistă să mențineți o legătură cu elementul original din dicționarul dvs. principal / primul.

Dacă obiectele din colecția dvs. aveau o structură mai complexă (mai multe câmpuri) și aveați nevoie să le puteți accesa / sorta eficient utilizând mai multe câmpuri ca chei - Probabil că veți avea nevoie de o structură personalizată de date care să compune din spațiul de stocare principal sprijină inserarea și eliminarea O (1) (LinkedList) și mai multe structuri de indexare - Dicționare / SortedDictionaries / SortedLists. Acești indici ar folosi unul din câmpurile din clasa complexă ca cheie și un pointer / referință la LinkedListNode din LinkedList ca valoare.

Va trebui să coordonați inserțiile și eliminările pentru a vă menține indexurile în sincronizare cu colecția principală (LinkedList), iar eliminările ar fi destul de costisitoare. Acest lucru este similar cu modul în care funcționează indexurile bazei de date - sunt fantastice pentru căutări, dar devin o povară atunci când trebuie să efectuați multe insecte și ștergeri.

Toate cele de mai sus sunt justificate doar dacă intenționați să faceți unele prelucrări grele. Dacă aveți nevoie doar să le trimiteți după o sortare după frecvență, atunci puteți să produceți o listă de piese (anonime):

var dict = new SortedDictionary();
// 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);
}

Cea mai ușoară modalitate de a obține un Dicționar sortit este de a folosi clasa SortedDictionary construită:

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

sortedSections will contains the sorted version of sections

Puteți sorta Dicționarul după valoare și puteți obține rezultatul în dicționar utilizând codul de mai jos:

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

Să presupunem că avem un dicționar ca

   Dictionary dict = new Dictionary();
   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) puteți utiliza dicționarul temporar pentru a stoca valori ca :

        Dictionary dctTemp = new Dictionary();

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

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