Como você classifica um dicionário por valor?

Muitas vezes tenho que classificar um dicionário, composto por chaves e valores, por valor. Por exemplo, tenho um hash de palavras e respectivas frequências, que quero ordenar por frequência.

Há um SortedListque é bom para um único valor (digamos frequência), que eu quero mapeá-lo de volta à palavra.

SortedDictionary ordena por chave, não por valor. Alguns recorrem a uma classe personalizada , mas existe uma maneira mais limpa?

Usar:

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

Como você está direcionando o .NET 2.0 ou superior, você pode simplificar isso na sintaxe lambda - é equivalente, mas menor. Se você estiver direcionando o .NET 2.0, poderá usar essa sintaxe apenas se estiver usando o compilador do Visual Studio 2008 (ou superior).

var myList = aDictionary.ToList();

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

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

Isso também permitiria uma grande flexibilidade, pois você pode selecionar os 10, 20, 10% etc. etc. Ou, se estiver usando o índice de frequência de palavras type-ahead, também poderá incluir a StartsWithcláusula.

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

Olhando em volta e usando alguns recursos do C # 3.0, podemos fazer isso:

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

Esta é a maneira mais limpa que eu já vi e é semelhante à maneira Ruby de lidar com hashes.

Você pode classificar um dicionário por valor e salvá-lo novamente (para que, quando for pesquisá-lo, os valores sejam ordenados):

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

Claro, pode não estar correto, mas funciona.

Em um nível alto, você não tem outra escolha a não ser percorrer todo o dicionário e analisar cada valor.

Talvez isso ajude: http://bytes.com/forum/thread563638.html Copiar / colar 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);
    }
);

Você nunca seria capaz de classificar um dicionário de qualquer maneira. Eles não são realmente encomendados. As garantias para um dicionário são de que a coleção de chaves e valores é iterável e os valores podem ser recuperados por índice ou chave, mas não há garantia de nenhuma ordem específica. Portanto, você precisaria inserir o par de valor do nome em uma lista.

Você não classifica entradas no dicionário. A classe de dicionário no .NET é implementada como uma hashtable - essa estrutura de dados não pode ser classificada por definição.

Se você precisar interagir com sua coleção (por chave) - precisará usar o SortedDictionary, que é implementado como uma Árvore de Pesquisa Binária.

No seu caso, no entanto, a estrutura de origem é irrelevante, porque é classificada por um campo diferente. Você ainda precisará classificá-lo por frequência e colocá-lo em uma nova coleção classificada pelo campo relevante (frequência). Portanto, nesta coleção, as frequências são chaves e as palavras são valores. Como muitas palavras podem ter a mesma frequência (e você a usará como chave), você não pode usar nem o Dictionary nem o SortedDictionary (eles exigem chaves exclusivas). Isso deixa você com uma SortedList.

Não entendo por que você insiste em manter um link para o item original em seu dicionário principal / primeiro.

Se os objetos em sua coleção possuírem uma estrutura mais complexa (mais campos) e você precisar acessá-los / classificá-los com eficiência usando vários campos diferentes como chaves - Você provavelmente precisará de uma estrutura de dados personalizada que consistir no armazenamento principal que suporta inserção e remoção de O (1) (LinkedList) e várias estruturas de indexação - Dictionaries / SortedDictionaries / SortedLists. Esses índices usariam um dos campos da sua classe complexa como uma chave e um ponteiro / referência para o LinkedListNode no LinkedList como um valor.

Você precisaria coordenar inserções e remoções para manter seus índices sincronizados com a coleção principal (LinkedList) e as remoções seriam muito caras, eu acho. É semelhante à maneira como os índices de banco de dados funcionam - eles são fantásticos para pesquisas, mas se tornam um fardo quando você precisa executar várias inserções e exclusões.

Todas as opções acima só são justificadas se você deseja fazer algum processamento pesado de consulta. Se você precisar produzi-los apenas uma vez classificados por frequência, poderá produzir uma lista de tuplas (anônimas):

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, por diversão, você pode usar alguns benefícios da extensão 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));

Classificando uma SortedDictionarylista para vincular a um ListViewcontrole usando o 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>

A maneira mais fácil de obter um dicionário classificado é usar a SortedDictionaryclasse incorporada :

//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 vontade contém a versão classificada de sections

As outras respostas são boas, se tudo o que você deseja é ter uma lista "temporária" classificada por Valor. No entanto, se você quiser ter um dicionário classificado por Keyque sincroniza automaticamente com outro dicionário que é classificada por Value, você pode usar a Bijection<K1, K2>classe .

Bijection<K1, K2> permite que você inicialize a coleção com dois dicionários existentes; portanto, se você deseja que um deles não seja classificado e que o outro seja classificado, você pode criar sua bijeção com código como

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

Você pode usar dictcomo qualquer dicionário normal (implementado IDictionary<K, V>) e depois chamar dict.Inversepara obter o dicionário "inverso" que é classificado por Value.

Bijection<K1, K2>faz parte do Loyc.Collections.dll , mas se você quiser, poderá simplesmente copiar o código fonte em seu próprio projeto.

Nota : Caso haja várias chaves com o mesmo valor, você não poderá usá-lo Bijection, mas poderá sincronizar manualmente entre um comum Dictionary<Key,Value>e um BMultiMap<Value,Key>.

Suponha que tenhamos um dicionário como

   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) você pode usar 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);
        }

Na verdade, em C #, os dicionários têm métodos sort (); como você está mais interessado em classificar por valores, não é possível obter valores até fornecer a chave, resumindo, você precisa iterá-los usando o Order By do 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
}

você pode fazer um truque,

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

ou

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

também depende de que tipo de valores você está armazenando,
é único (como string, int) ou múltiplo (como List, Array, classe definida pelo usuário);
se único, você pode fazer uma lista e aplicar classificação.
se classe definida pelo usuário, essa classe deve implementar IComparable
ClassName: IComparable<ClassName>e substituir compareTo(ClassName c) , pois são mais rápidas que o LINQ e mais orientadas a objetos.

Namespace necessário: 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);

Ordenar por desc:

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

Ordem por Asc:

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

Você pode classificar o dicionário por valor e obter o resultado no dicionário usando o código abaixo:

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

Como você possui um dicionário, é possível classificá-los diretamente nos valores usando abaixo de um forro:

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