Làm thế nào để bạn sắp xếp một từ điển theo giá trị?

Tôi thường phải sắp xếp một từ điển, bao gồm các khóa & giá trị, theo giá trị. Ví dụ, tôi có một hàm băm của các từ và tần số tương ứng, mà tôi muốn sắp xếp theo tần số.

Có một SortedListcái tốt cho một giá trị duy nhất (tần số nói), mà tôi muốn ánh xạ nó trở lại từ.

Sắp xếp thứ tự từ khóa theo khóa, không phải giá trị. Một số khu nghỉ mát cho một lớp tùy chỉnh , nhưng có một cách sạch hơn?

Sử dụng:

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

Vì bạn đang nhắm mục tiêu .NET 2.0 trở lên, bạn có thể đơn giản hóa điều này thành cú pháp lambda - tương đương, nhưng ngắn hơn. Nếu bạn đang nhắm mục tiêu .NET 2.0, bạn chỉ có thể sử dụng cú pháp này nếu bạn đang sử dụng trình biên dịch từ Visual Studio 2008 (hoặc cao hơn).

var myList = aDictionary.ToList();

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

Sử dụng 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;

Điều này cũng sẽ cho phép rất linh hoạt ở chỗ bạn có thể chọn 10, 20 10% hàng đầu, v.v. Hoặc nếu bạn đang sử dụng chỉ số tần số từ của mình type-ahead, bạn cũng có thể bao gồm StartsWithmệnh đề.

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

Nhìn xung quanh và sử dụng một số tính năng của C # 3.0, chúng tôi có thể thực hiện việc này:

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

Đây là cách sạch nhất tôi từng thấy và tương tự như cách xử lý băm của Ruby.

Bạn có thể sắp xếp một Từ điển theo giá trị và lưu nó trở lại chính nó (để khi bạn thảo luận về nó, các giá trị sẽ xuất hiện theo thứ tự):

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

Chắc chắn, nó có thể không chính xác, nhưng nó hoạt động.

Ở cấp độ cao, bạn không có lựa chọn nào khác ngoài việc đi qua toàn bộ Từ điển và xem xét từng giá trị.

Có lẽ điều này giúp: http://bytes.com/forum/thread563638.html Sao chép / Dán từ 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);
    }
);

Bạn sẽ không bao giờ có thể sắp xếp một từ điển nào. Họ không thực sự được ra lệnh. Các đảm bảo cho một từ điển là các bộ sưu tập khóa và giá trị có thể lặp lại được và các giá trị có thể được truy xuất theo chỉ mục hoặc khóa, nhưng không có đảm bảo cho bất kỳ thứ tự cụ thể nào. Do đó, bạn sẽ cần phải đưa cặp giá trị tên vào một danh sách.

Bạn không sắp xếp các mục trong Từ điển. Lớp từ điển trong .NET được triển khai dưới dạng hashtable - cấu trúc dữ liệu này không thể sắp xếp theo định nghĩa.

Nếu bạn cần có khả năng lặp lại bộ sưu tập của mình (bằng phím) - bạn cần sử dụng SortedDipedia, được triển khai như một Cây tìm kiếm nhị phân.

Tuy nhiên, trong trường hợp của bạn, cấu trúc nguồn không liên quan, bởi vì nó được sắp xếp theo một trường khác. Bạn vẫn sẽ cần sắp xếp nó theo tần số và đưa nó vào một bộ sưu tập mới được sắp xếp theo trường (tần số) có liên quan. Vì vậy, trong bộ sưu tập này, tần số là khóa và từ là giá trị. Vì nhiều từ có thể có cùng tần số (và bạn sẽ sử dụng nó làm khóa), bạn không thể sử dụng cả Từ điển cũng như SortedDipedia (chúng yêu cầu các khóa duy nhất). Điều này để lại cho bạn một SortedList.

Tôi không hiểu lý do tại sao bạn khăng khăng duy trì một liên kết đến mục gốc trong từ điển chính / đầu tiên của bạn.

Nếu các đối tượng trong bộ sưu tập của bạn có cấu trúc phức tạp hơn (nhiều trường hơn) và bạn cần có khả năng truy cập / sắp xếp chúng một cách hiệu quả bằng cách sử dụng một số trường khác nhau làm khóa - Bạn có thể sẽ cần một cấu trúc dữ liệu tùy chỉnh bao gồm bộ lưu trữ chính hỗ trợ chèn và loại bỏ O (1) (LinkedList) và một số cấu trúc lập chỉ mục - Từ điển / Sắp xếp từ điển / Sắp xếp theo thứ tự. Các chỉ mục này sẽ sử dụng một trong các trường từ lớp phức tạp của bạn làm khóa và con trỏ / tham chiếu đến LinkedListNode trong LinkedList làm giá trị.

Bạn sẽ cần phối hợp các phần chèn và xóa để giữ cho các chỉ mục của bạn được đồng bộ hóa với bộ sưu tập chính (LinkedList) và các phần xóa sẽ khá tốn kém. Điều này tương tự như cách các chỉ mục cơ sở dữ liệu hoạt động - chúng rất tuyệt vời cho việc tra cứu nhưng chúng trở thành gánh nặng khi bạn cần thực hiện nhiều thao tác chèn và xóa.

Tất cả những điều trên chỉ hợp lý nếu bạn định thực hiện một số xử lý nặng. Nếu bạn chỉ cần xuất chúng một khi được sắp xếp theo tần suất thì bạn có thể chỉ cần tạo một danh sách các bộ dữ liệu (ẩn danh):

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

Hoặc để giải trí, bạn có thể sử dụng một số ưu điểm của tiện ích mở rộng 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));

Sắp xếp SortedDictionarydanh sách để liên kết vào một ListViewđiều khiển bằng 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>

Cách dễ nhất để có được một Từ điển được sắp xếp là sử dụng lớp dựng sẵn 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 sẽ chứa phiên bản đã sắp xếp của sections

Các câu trả lời khác là tốt, nếu tất cả những gì bạn muốn là có một danh sách "tạm thời" được sắp xếp theo Giá trị. Tuy nhiên, nếu bạn muốn có một từ điển được sắp xếp theo Keyđó sẽ tự động đồng bộ hóa với một từ điển khác được sắp xếp theo Value, bạn có thể sử dụng Bijection<K1, K2>lớp .

Bijection<K1, K2> cho phép bạn khởi tạo bộ sưu tập với hai từ điển hiện có, vì vậy nếu bạn muốn một trong số chúng được sắp xếp và bạn muốn sắp xếp một bộ khác, bạn có thể tạo bộ sưu tập của mình bằng mã như

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

Bạn có thể sử dụng dictnhư bất kỳ từ điển thông thường nào (nó thực hiện IDictionary<K, V>), sau đó gọi dict.Inverseđể lấy từ điển "nghịch đảo" được sắp xếp theo Value.

Bijection<K1, K2>là một phần của Loyc.Collections.dll , nhưng nếu bạn muốn, bạn chỉ cần sao chép mã nguồn vào dự án của riêng bạn.

Lưu ý : Trong trường hợp có nhiều khóa có cùng giá trị, bạn không thể sử dụng Bijection, nhưng bạn có thể đồng bộ hóa thủ công giữa thông thường Dictionary<Key,Value>và a BMultiMap<Value,Key>.

Giả sử chúng ta có một từ điển như

   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) bạn có thể sử dụng 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);
        }

Trên thực tế, trong C #, từ điển dintaries có các phương thức sort (), vì bạn quan tâm hơn đến việc sắp xếp theo các giá trị, bạn không thể nhận được các giá trị cho đến khi bạn cung cấp khóa cho chúng, tóm lại, bạn cần lặp lại chúng, sử dụng Order By của 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
}

bạn có thể làm một mẹo

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

hoặc là

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

nó cũng phụ thuộc vào loại giá trị bạn đang lưu trữ,
nó là đơn (như chuỗi, int) hoặc nhiều (như List, Array, lớp do người dùng xác định),
nếu bạn có thể tạo danh sách của nó sau đó áp dụng sắp xếp.
nếu người dùng định nghĩa lớp, thì lớp đó phải triển khai IComparable
ClassName: IComparable<ClassName>và ghi đè compareTo(ClassName c) vì chúng nhanh hơn LINQ và hướng đối tượng nhiều hơn.

Không gian tên bắt buộc: 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);

Đặt hàng theo desc:

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

Đặt hàng bởi Asc:

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

Bạn có thể sắp xếp Từ điển theo giá trị và nhận kết quả trong từ điển bằng mã bên dưới:

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

Cho bạn có một từ điển, bạn có thể sắp xếp chúng trực tiếp trên các giá trị bằng cách sử dụng bên dưới một lớp lót:

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