您如何按值对字典排序？

我经常必须按值对由键和值组成的字典进行排序。例如，我有一个单词和各个频率的哈希，我想按频率排序。

SortedList我想将其映射回单词，这对于单个值（例如频率）来说是一个很好的选择。

SortedDictionary订单按键而非值排序。有些使用自定义类，但是有没有更干净的方法？

采用：

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

由于您的目标是.NET 2.0或更高版本，因此可以将其简化为lambda语法-等效，但更短。如果目标是.NET 2.0，则只有在使用Visual Studio 2008（或更高版本）的编译器时，才能使用此语法。

var myList = aDictionary.ToList();

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

使用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;

这还可以提供极大的灵活性，因为您可以选择前10％，20％，10％等。或者如果您将词频索引用于 type-ahead，则还可以包含StartsWith子句。

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

环顾四周，并使用一些C＃3.0功能，我们可以这样做：

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

这是我所见过的最干净的方法，类似于Ruby处理哈希的方法。

您可以按值对字典进行排序，然后将其保存回自己（这样，当您遍历字典时，值将按顺序显示）：

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

当然，这可能不正确，但是可以。

在较高的层次上，您别无选择，只能遍历整个Dictionary并查看每个值。

也许有帮助：http : //bytes.com/forum/thread563638.html从约翰·蒂姆尼（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);
    }
);

无论如何，您永远都无法对字典进行排序。它们实际上没有订购。字典的保证是键和值的集合是可迭代的，并且可以通过索引或键来检索值，但是不保证任何特定的顺序。因此，您需要将名称值对放入列表中。

您不对字典中的条目进行排序。.NET中的字典类被实现为哈希表-此数据结构无法按定义排序。

如果您需要能够（按键）遍历集合-您需要使用SortedDictionary，它被实现为Binary Search Tree。

但是，在您的情况下，源结构无关紧要，因为它是按其他字段排序的。您仍然需要按频率对其进行排序，并将其放入按相关字段（频率）进行排序的新集合中。因此，在此集合中，频率是键，而单词是值。由于许多单词可以具有相同的频率（并且您将使用它作为键），因此您既不能使用Dictionary也不能使用SortedDictionary（它们需要唯一的键）。这给您留下了SortedList。

我不明白您为什么坚持在主/第一个词典中保持指向原始项目的链接。

如果您集合中的对象具有更复杂的结构（更多字段），并且您需要能够使用几个不同的字段作为键来有效地访问/排序它们-您可能需要一个由主存储组成的自定义数据结构支持O（1）插入和删除（LinkedList）以及几种索引结构-字典/ SortedDictionaries / SortedLists。这些索引将使用复杂类中的字段之一作为键，并使用LinkedList中LinkedListNode的指针/引用作为值。

您需要协调插入和删除操作，以使索引与主集合（LinkedList）保持同步，而删除操作会非常昂贵。这类似于数据库索引的工作方式-它们非常适合查找，但是当您需要执行许多插入和删除操作时，它们将成为负担。

仅当您要进行一些查找繁重的处理时，以上所有内容才是合理的。如果只需要输出一次按频率排序的字符串，则可以生成（匿名）元组的列表：

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

或者为了娱乐，您可以使用一些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));

使用VB.NET 对SortedDictionary列表进行排序以绑定到ListView控件中：

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>

获取排序的Dictionary的最简单方法是使用内置的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 将包含的排序版本 sections

如果您想要的是按“值”排序的“临时”列表，则其他答案也不错。但是，如果您希望字典排序依据Key能够自动与另一个字典排序依据同步，则Value可以使用Bijection<K1, K2>该类。

Bijection<K1, K2> 允许您使用两个现有字典来初始化集合，因此，如果您希望其中一个不被排序，而又另一个要被排序，则可以使用如下代码创建双射

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

您可以dict像使用任何普通词典（它实现IDictionary<K, V>）一样使用，然后调用dict.Inverse以获取由排序的“反向”词典Value。

Bijection<K1, K2>是Loyc.Collections.dll的一部分，但是如果需要，您可以将源代码直接复制到自己的项目中。

注意：如果有多个具有相同值的键，则不能使用Bijection，但是可以在普通Dictionary<Key,Value>和a 之间手动同步BMultiMap<Value,Key>。

假设我们有一个字典

   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）您可以使用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);
        }

实际上，在C＃中，Dictionary dint具有sort（）方法，因为您对按值排序更感兴趣，在提供键之前，您无法获取值，总之，您需要使用LINQ的Order By来遍历它们，

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
}

你可以做一招

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

要么

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

它也取决于您要存储哪种类型的值，
它是单个值（如字符串，int）还是多个（如List，Array，用户定义的类），
如果是单个值，则可以对其进行排序然后应用排序。
如果是用户定义的类，则该类必须实现IComparable，
ClassName: IComparable<ClassName>并进行覆盖，compareTo(ClassName c) 因为它们比LINQ更快，并且面向对象。

所需的名称空间： 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);

按desc排序：

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

按Asc排序：

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

您可以按值对字典进行排序，并使用以下代码在字典中获取结果：

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

有了字典，您可以使用以下划线将它们直接按值排序：

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