Jak posortować słownik według wartości?

Użyj 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;

Pozwoliłoby to również na dużą elastyczność, ponieważ można wybrać top 10, 20 10%, itp. Lub jeśli używasz indeksu częstotliwości słów dla type-ahead, Możesz również dołączyć klauzulę StartsWith.

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

Rozglądając się dookoła i używając niektórych funkcji C# 3.0 możemy to zrobić:

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

Jest to najczystszy sposób, jaki widziałem i jest podobny do Ruby sposób obchodzenia się z hashami.

Możesz posortować Słownik według wartości i zapisać go z powrotem do siebie (tak, aby po przekroczeniu go wartości wyszły w kolejności):

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

Jasne, może to nie jest poprawne, ale działa.

Na wysokim poziomie, nie masz innego wyboru niż przejść przez cały słownik i spojrzeć na każdą wartość.

Może to pomoże: http://bytes.com/forum/thread563638.html Kopiowanie / wklejanie od Johna Timneya:

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

I tak nie będziesz w stanie posortować słownika. Nie są one faktycznie zamówione. Gwarancją dla słownika jest to, że zbiory klucza i wartości są iteracyjne, a wartości mogą być pobierane przez indeks lub klucz, ale nie ma gwarancji określonej kolejności. W związku z tym trzeba będzie uzyskać para wartość nazwa do listy.

Nie sortujesz wpisów w słowniku. Klasa słownika w. NET jest zaimplementowana jako hashtable - ta struktura danych nie jest z definicji sortowalna.

Jeśli chcesz mieć możliwość iteracji po swojej kolekcji (według klucza) - musisz użyć SortedDictionary, który jest zaimplementowany jako binarne drzewo wyszukiwania.

W Twoim przypadku struktura źródła nie ma znaczenia, ponieważ jest posortowana według innego pola. Nadal będziesz musiał posortować go według częstotliwości i umieścić w nowym kolekcja posortowana według odpowiedniego pola (częstotliwość). Więc w tym zbiorze częstotliwości są kluczami, a słowa są wartościami. Ponieważ wiele słów może mieć tę samą częstotliwość (i użyjesz jej jako klucza), nie możesz używać ani słownika, ani SortedDictionary (wymagają unikalnych kluczy). To pozostawia Ci sortowaną listę.

Nie rozumiem, dlaczego nalegasz na utrzymywanie linku do oryginalnej pozycji w głównym/pierwszym słowniku.

Jeśli obiekty w Twojej kolekcji miały bardziej złożona struktura (więcej pól) i trzeba było być w stanie efektywnie uzyskać dostęp/sortować je za pomocą kilku różnych pól jako kluczy - prawdopodobnie potrzebna byłaby niestandardowa struktura danych, która składałaby się z głównego magazynu, który obsługuje o(1) wstawianie i usuwanie (LinkedList) i kilka struktur indeksujących - Słowniki/SortedDictionaries/SortedLists. Indeksy te będą używać jednego z pól z Twojej złożonej klasy jako klucza i wskaźnika / odniesienia do LinkedListNode w LinkedList jako wartość.

Trzeba koordynować wstawiania i usuwania, aby utrzymać swoje indeksy w synchronizacji z główną kolekcją (LinkedList) i usuwania byłoby dość drogie, jak sądzę. Jest to podobne do tego, jak działają indeksy baz danych - są fantastyczne dla wyszukiwania, ale stają się ciężarem, gdy trzeba wykonać wiele wstawiania i usuwania.

Wszystkie powyższe jest uzasadnione tylko wtedy, gdy masz zamiar zrobić jakieś spojrzenie-up ciężkich przetwarzania. Jeśli musisz je wypisać tylko raz posortowane według częstotliwość, wtedy można po prostu stworzyć listę (anonimowych) krotek:

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

Albo dla Zabawy przydałoby się jakieś rozszerzenie 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));

Sortowanie listy SortedDictionary do połączenia w kontrolkę ListView za pomocą 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>

Inne odpowiedzi są dobre, jeśli wszystko, co chcesz, to mieć "tymczasową" listę posortowaną według wartości. Jeśli jednak chcesz mieć słownik posortowany według Key, który automatycznie synchronizuje z innym słownikiem posortowanym według Value, możesz użyć Bijection<K1, K2> Klasa .

Bijection<K1, K2> pozwala na zainicjowanie kolekcji za pomocą dwóch istniejących słowników, więc jeśli chcesz, aby jeden z nich był niesortowany, a drugi sortowany, możesz utworzyć swój bijection with code like

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

Możesz użyć dict Jak każdy zwykły słownik (implementuje IDictionary<K, V>), a następnie wywołać dict.Inverse, aby uzyskać "odwrotny" słownik, który jest sortowany według Value.

Bijection<K1, K2> jest częścią Loyc.Kolekcje.dll, Ale jeśli chcesz, możesz po prostu skopiować kod źródłowy do własnego projektu.

Uwaga: W przypadku, gdy istnieje wiele kluczy o tej samej wartości, nie można użyć Bijection, ale można ręcznie zsynchronizować między zwykłe Dictionary<Key,Value> i a BMultiMap<Value,Key>.

Najprostszym sposobem uzyskania posortowanego słownika jest użycie wbudowanej klasy SortedDictionary:

//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 będzie zawierać posortowaną wersję sections

W C# słowniki nie mają metod sort (). Ponieważ jesteś bardziej zainteresowany sortowaniem według wartości, nie możesz uzyskać wartości, dopóki nie podasz im klucza. W skrócie, musisz je iterować używając LINQ ' s OrderBy(),

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
}

Możesz zrobić jedną sztuczkę:

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

Lub:

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

Zależy również od tego, jakie wartości przechowujesz: single (jak string, int) lub multiple (jak List, Array, user defined class). Jeśli jest pojedynczy, możesz utworzyć jego listę, a następnie zastosować sortowanie.
Jeśli jest to klasa zdefiniowana przez użytkownika, wtedy ta klasa musi zaimplementować IComparable, ClassName: IComparable<ClassName> i nadpisać compareTo(ClassName c), ponieważ są one szybsze i bardziej zorientowane obiektowo niż LINQ.

Załóżmy, że mamy słownik jako

   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) możesz użyć 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);
        }

Wymagana przestrzeń nazw: 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);

Order by desc:

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

Order by Asc:

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

Sortowanie i drukowanie:

var items = from pair in players_Dic
                orderby pair.Value descending
                select pair;

// Display results.
foreach (KeyValuePair<string, int> pair in items)
{
    Debug.Log(pair.Key + " - " + pair.Value);
}

Zmień malejąco na acending aby zmienić kolejność sortowania

Możesz posortować Słownik według wartości i uzyskać wynik w słowniku używając poniższego kodu:

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

Jeśli masz słownik, możesz posortować je bezpośrednio po wartościach używając poniższej linijki:

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