사전을 값별로 정렬하려면 어떻게 해야 합니까?

사전을 값별로 정렬하려면 어떻게 해야 합니까?

저는 종종 사전(키와 값으로 구성된)을 값별로 정렬해야 합니다.예를 들어, 빈도별로 정렬할 단어와 각 빈도의 해시가 있습니다.

이 .SortedList이 값은 단어에 다시 매핑하려는 단일 값(예: 빈도)에 적합합니다.

값이 아닌 키별로 정렬된 사전 순서입니다.일부는 맞춤 수업에 의지하지만, 더 깨끗한 방법이 있습니까?

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%, 2010% 등을 선택할 수 있다는 점에서 큰 유연성을 제공합니다. 단어 지수를 는단빈색사경우는용하인을에 .type-ahead당신은 또한 포함할 수 있습니다.StartsWith조항도 마찬가지입니다.

사용:

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 이상을 대상으로 하므로 람다 구문으로 단순화할 수 있습니다. 동일하지만 더 짧습니다..NET 2.0을 대상으로 하는 경우 Visual Studio 2008(또는 그 이상)의 컴파일러를 사용하는 경우에만 이 구문을 사용할 수 있습니다.

var myList = aDictionary.ToList();

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

다음을 사용할 수 있습니다.

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

값별로 사전을 정렬한 후 다시 사전에 저장할 수 있습니다(각 사전에 대한 값이 순서대로 표시되도록).

dict = dict.OrderBy(x => x.Value).ToDictionary(x => x.Key, 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
}

이것은 제가 본 것 중 가장 깨끗한 방법이며, 루비의 해시 처리 방법과 비슷합니다.

일반적으로 전체 사전을 살펴보고 각 값을 확인하는 것 외에는 선택의 여지가 없습니다.

이것이 도움이 될 수도 있습니다: 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의 사전 클래스는 해시 테이블로 구현됩니다. 이 데이터 구조는 정의상 정렬할 수 없습니다.

컬렉션을 키별로 반복할 수 있어야 하는 경우 이진 검색 트리로 구현된 정렬된 사전을 사용해야 합니다.

그러나 이 경우 원본 구조는 다른 필드별로 정렬되므로 관련이 없습니다.그래도 빈도별로 정렬하고 관련 필드(주파수)별로 정렬된 새 컬렉션에 넣어야 합니다.그래서 이 컬렉션에서 빈도는 키이고 단어는 값입니다.많은 단어가 동일한 빈도를 가질 수 있으므로(키로 사용할 경우) Dictionary 또는 SortedDictionary를 모두 사용할 수 없습니다(단, 고유한 키가 필요함).이렇게 하면 정렬된 목록이 나타납니다.

저는 당신이 왜 당신의 메인/첫 번째 사전에서 원본 항목에 대한 링크를 유지해야 하는지 이해할 수 없습니다.

컬렉션의 개체가 더 복잡한 구조(더 많은 필드)를 가지고 있고 여러 개의 다른 필드를 키로 사용하여 개체에 효율적으로 액세스/정렬할 수 있어야 하는 경우 O(1) 삽입/제거(LinkedList) 및 여러 인덱싱 구조를 지원하는 메인 스토리지로 구성된 사용자 지정 데이터 구조가 필요할 수 있습니다.사전/정렬된 사전/정렬된 목록.이러한 인덱스는 복합 클래스의 필드 중 하나를 키로 사용하고 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));

정렬SortedDictionary에 ListViewVB.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>

값별로 정렬된 "임시" 목록을 원하는 경우 다른 답변이 좋습니다.그러나 사전을 다음 기준으로 정렬하려면Key다음 기준으로 정렬된 다른 사전과 자동으로 동기화됩니다.Value당신은 수업을 이용할 수 있습니다.

Bijection<K1, K2>두 개의 기존 사전으로 컬렉션을 초기화할 수 있으므로 둘 중 하나를 정렬하지 않고 다른 하나를 정렬하려면 다음과 같은 코드를 사용하여 Bijection을 만들 수 있습니다.

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

사용할 수 있습니다.dict여느 일반 사전처럼 (그것은 구현IDictionary<K, V>), 그런 다음 전화합니다.dict.Inverse다음 기준으로 정렬된 "사전"을 가져오다Value.

Bijection<K1, K2>로익의 일부입니다.Collections.dll. 하지만 원한다면 소스 코드를 자신의 프로젝트에 복사할 수 있습니다.

참고: 동일한 값의 키가 여러 개 있는 경우 사용할 수 없습니다.Bijection하지만 수동으로 일반적인 것들 사이에서 동기화할 수 있습니다.Dictionary<Key,Value>그리고 a.

사실 C#에서는 사전에 sort() 메서드가 없습니다.값을 기준으로 정렬하는 데 더 관심이 있으므로 키를 제공하기 전에는 값을 수 있습니다.간단히 말해, LINQ를 사용하여 이를 반복해야 합니다.OrderBy(),

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) 또는 다중(예: 목록, 배열, 사용자 정의 클래스)에 따라 달라집니다.싱글인 경우 목록을 만든 다음 정렬을 적용할 수 있습니다.
만약 그것이 사용자 정의 클래스라면, 그 클래스는 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);

설명 순서:

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

As별 주문:

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

다음과 같은 사전이 있다고 가정합니다.

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);
dict.Add(768, 1011);

임시 사전을 사용하여 값을 다음과 같이 저장할 수 있습니다.

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

정렬된 사전을 얻는 가장 쉬운 방법은 내장된 사전을 사용하는 것입니다.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

정렬 및 인쇄:

var items = from pair in players_Dic
                orderby pair.Value descending
                select pair;

// Display results.
foreach (KeyValuePair<string, int> pair in items)
{
    Debug.Log(pair.Key + " - " + pair.Value);
}

내림차순에서 오름차순으로 변경하여 정렬 순서 변경

사전은 해시 가능한 방식으로 값과 키만 포함하는 순서가 지정되지 않은 연관 구조입니다.즉, 사전을 주문할 수 있는 사전적인 방법이 없습니다.

참고로 파이썬 언어에서 이 기사를 읽습니다.

Python 데이터 구조 연결

최선의 방법:

var list = dict.Values.OrderByDescending(x => x).ToList();
var sortedData = dict.OrderBy(x => list.IndexOf(x.Value));

다음 코드 조각은 값별로 사전을 정렬합니다.

코드는 먼저 사전을 만든 다음 사용합니다.OrderBy항목을 정렬하는 방법입니다.

public void SortDictionary()  
{  
  
    // Create a dictionary with string key and Int16 value pair  
    Dictionary<string, Int16> AuthorList = new Dictionary<string, Int16>();  
    AuthorList.Add("Mahesh Chand", 35);  
    AuthorList.Add("Mike Gold", 25);  
    AuthorList.Add("Praveen Kumar", 29);  
    AuthorList.Add("Raj Beniwal", 21);  
    AuthorList.Add("Dinesh Beniwal", 84);   
  
    // Sorted by Value  
  
    Console.WriteLine("Sorted by Value");  
    Console.WriteLine("=============");  
    foreach (KeyValuePair<string, Int16> author in AuthorList.OrderBy(key => key.Value))  
    {  
        Console.WriteLine("Key: {0}, Value: {1}", author.Key, author.Value);  
    }  
} 

값별로 사전을 정렬하고 아래 코드를 사용하여 사전에서 결과를 얻을 수 있습니다.

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

언급URL : https://stackoverflow.com/questions/289/how-do-you-sort-a-dictionary-by-value