¿Cómo se ordena un diccionario por valor?

A menudo tengo que ordenar un diccionario, que consta de claves y valores, por valor. Por ejemplo, tengo un hash de palabras y frecuencias respectivas, que quiero ordenar por frecuencia.

Hay una SortedListque es buena para un solo valor (por ejemplo, frecuencia), que quiero asignar de nuevo a la palabra.

Ordenes ordenadas por clave, no por valor. Algunos recurren a una clase personalizada , pero ¿hay una forma más limpia?

Utilizar:

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 está apuntando a .NET 2.0 o superior, puede simplificar esto en sintaxis lambda: es equivalente, pero más corto. Si está apuntando a .NET 2.0, solo puede usar esta sintaxis si está usando el compilador de Visual Studio 2008 (o 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;

Esto también permitiría una gran flexibilidad, ya que puede seleccionar los 10 mejores, 20 10%, etc. O si está utilizando su índice de frecuencia de palabras para type-ahead , también podría incluir una StartsWithcláusula.

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

Mirando a nuestro alrededor y usando algunas características de C # 3.0 podemos hacer esto:

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

Esta es la forma más limpia que he visto y es similar a la forma Ruby de manejar hashes.

Puede ordenar un Diccionario por valor y guardarlo de nuevo en sí mismo (de modo que cuando lo lea por encima los valores salgan en orden):

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

Claro, puede que no sea correcto, pero funciona.

En un nivel alto, no tiene otra opción que recorrer todo el Diccionario y observar cada valor.

Tal vez esto ayude: http://bytes.com/forum/thread563638.html Copiar / Pegar 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);
    }
);

Nunca podrías ordenar un diccionario de todos modos. En realidad no están ordenados. Las garantías para un diccionario son que las colecciones de clave y valor son iterables, y los valores se pueden recuperar por índice o clave, pero no hay garantía de ningún orden en particular. Por lo tanto, necesitaría obtener el par de valor de nombre en una lista.

No ordena entradas en el Diccionario. La clase de diccionario en .NET se implementa como una tabla hash: esta estructura de datos no se puede ordenar por definición.

Si necesita poder iterar sobre su colección (por clave), debe usar SortedDictionary, que se implementa como un árbol de búsqueda binario.

En su caso, sin embargo, la estructura fuente es irrelevante, ya que está ordenada por un campo diferente. Aún necesitaría ordenarlo por frecuencia y colocarlo en una nueva colección ordenada por el campo relevante (frecuencia). Entonces, en esta colección, las frecuencias son claves y las palabras son valores. Dado que muchas palabras pueden tener la misma frecuencia (y la va a usar como una clave), no puede usar ni Dictionary ni SortedDictionary (requieren claves únicas). Esto te deja con una SortedList.

No entiendo por qué insiste en mantener un enlace al elemento original en su diccionario principal / primer.

Si los objetos en su colección tuvieran una estructura más compleja (más campos) y necesitara poder acceder / ordenarlos eficientemente usando varios campos diferentes como claves, probablemente necesitaría una estructura de datos personalizada que consistiría en el almacenamiento principal que admite la inserción y eliminación de O (1) (LinkedList) y varias estructuras de indexación: Diccionarios / SortedDictionaries / SortedLists. Estos índices utilizarían uno de los campos de su clase compleja como clave y un puntero / referencia al LinkedListNode en LinkedList como valor.

Tendría que coordinar las inserciones y eliminaciones para mantener sus índices sincronizados con la colección principal (LinkedList) y las eliminaciones serían bastante caras, creo. Esto es similar a cómo funcionan los índices de base de datos: son fantásticos para las búsquedas, pero se convierten en una carga cuando necesita realizar muchas inserciones y eliminaciones.

Todo lo anterior solo se justifica si va a realizar un procesamiento pesado de búsqueda. Si solo necesita generarlos una vez ordenados por frecuencia, entonces podría producir una 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);

O por diversión, podría usar algunas bondades de extensión 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));

Ordenar una SortedDictionarylista para enlazar en un ListViewcontrol usando 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 forma más fácil de obtener un diccionario ordenado es usar la SortedDictionaryclase integrada :

//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 will contiene la versión ordenada de sections

Las otras respuestas son buenas, si todo lo que quiere es tener una lista "temporal" ordenada por Valor. Sin embargo, si desea ordenar un diccionario Keyque se sincronice automáticamente con otro diccionario ordenado Value, puede usar la Bijection<K1, K2>clase .

Bijection<K1, K2> le permite inicializar la colección con dos diccionarios existentes, por lo que si desea que uno de ellos no esté ordenado y desea que el otro esté ordenado, puede crear su biyección con un código como

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

Puede usarlo dictcomo cualquier diccionario normal (se implementa IDictionary<K, V>) y luego llamar dict.Inversepara obtener el diccionario "inverso" que se ordena porValue .

Bijection<K1, K2>es parte de Loyc.Collections.dll , pero si lo desea, simplemente puede copiar el código fuente en su propio proyecto.

Nota : En caso de que haya varias claves con el mismo valor, no puede usarlas Bijection, pero podría sincronizar manualmente entre una ordinaria Dictionary<Key,Value>y una BMultiMap<Value,Key>.

Supongamos que tenemos un diccionario 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) puedes 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);
        }

En realidad, en C #, los diccionarios no tienen métodos sort (), ya que está más interesado en ordenar por valores, no puede obtener valores hasta que les proporcione la clave, en resumen, necesita iterar a través de ellos, utilizando Ordenar por 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
}

puedes hacer un truco

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

o

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

también depende de qué tipo de valores esté almacenando,
ya sea individual (como string, int) o múltiple (como List, Array, clase definida por el usuario),
si solo puede hacer una lista, aplique el orden.
si es una clase definida por el usuario, entonces esa clase debe implementar IComparable
ClassName: IComparable<ClassName>y anular, compareTo(ClassName c) ya que son más rápidos que LINQ y están más orientados a objetos.

Espacio de nombres requerido: 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.
}

Ordenar por Asc:

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

Puede ordenar el Diccionario por valor y obtener el resultado en el diccionario usando el código a continuación:

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

Dado que tiene un diccionario, puede ordenarlos directamente en valores usando debajo de un trazador de líneas:

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