c# -如何按值对词典排序?

Translate

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

有一个SortedList我想将其映射回单词,这对于单个值(例如频率)来说是个好选择。

分类词典按键排序,而不是按值排序。有些诉诸习俗课,但是有没有一种更清洁的方法?

This question and all comments follow the "Attribution Required."

所有的回答

Translate

采用:

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));
来源
Translate

使用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条款。

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

环顾四周,并使用一些C#3.0功能,我们可以这样做:

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

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

来源
Translate

您可以按值对字典进行排序,然后将其保存回自己(这样,当您遍历字典时,值将按顺序显示):

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

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

来源
Translate

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

也许这会有所帮助:http://bytes.com/forum/thread563638.html从约翰·蒂姆尼复制/粘贴:

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);
    }
);
来源
Translate

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

来源
Translate

您不对字典中的条目进行排序。 .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);
}
来源
Translate
Dictionary<string, string> dic= new Dictionary<string, string>();
var ordered = dic.OrderBy(x => x.Value);
return ordered.ToDictionary(t => t.Key, t => t.Value);
来源
Translate

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

排序值

这显示了如何对字典中的值进行排序。我们看到可以在Visual Studio中编译并运行的控制台程序。它将关键字添加到字典,然后按其值对它们进行排序。请记住,字典实例最初并未以任何方式进行排序。我们在查询语句中使用LINQ orderby关键字。

对字典进行排序的OrderBy子句程序[C#]

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

class Program
{
    static void Main()
    {
        // Example dictionary.
        var dictionary = new Dictionary<string, int>(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<string, int> 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;
    }
}

输出量

dog: 0
cat: 1
programmer: 2
eel: 3
mouse: 5
来源
Translate

排序一个SortedDictionary列表绑定到ListView使用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>
来源
Translate

获得排序字典的最简单方法是使用内置的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

来源
Translate

如果您想要的是按“值”排序的“临时”列表,则其他答案也不错。但是,如果您要按顺序对字典进行排序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>和一个BMultiMap<Value,Key>.

来源
Translate

假设我们有一个字典

   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);
        }
来源
Translate

实际上,在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);

or

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

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

来源
Translate

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

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

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

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