Bir sözlüğü değere göre nasıl sıralarsınız?

Sık sık anahtar ve değerlerden oluşan bir sözlüğü değere göre sıralamak zorundayım. Örneğin, frekansa göre sipariş etmek istediğim bir kelime ve ilgili frekans karmalarım var.

Bir yoktur SortedListgeri kelimenin eşlemek istediğiniz, tek bir değer (diyelim frekans) için iyidir.

Sıralama değerlerini değil, anahtarla sıralama. Bazıları özel bir sınıfa başvurur , ancak daha temiz bir yol var mı?

kullanın:

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 veya üstünü hedeflediğiniz için bunu lambda sözdizimine sadeleştirebilirsiniz - eşdeğer, ancak daha kısa. .NET 2.0'ı hedefliyorsanız, bu sözdizimini yalnızca Visual Studio 2008 (veya üstü) derleyicisini kullanıyorsanız kullanabilirsiniz.

var myList = aDictionary.ToList();

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

LINQ kullanın:

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;

Bu aynı zamanda en yüksek 10, 20% 10, vs.'yi seçebilmeniz için büyük esneklik sağlar. Veya kelime sıklığı dizininizi kullanıyorsanız, yan tümcesi type-aheadde ekleyebilirsiniz StartsWith.

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

Etrafa bakın ve bazı C # 3.0 özelliklerini kullanarak bunu yapabiliriz:

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

Bu gördüğüm en temiz yoldur ve Ruby işlemlerini Ruby yöntemine benzer.

Bir Sözlüğü değere göre sıralayabilir ve kendisine geri kaydedebilirsiniz (böylece, üzerinde öngörüldüğünüzde değerler sırayla gelir):

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

Tabii, doğru olmayabilir, ama işe yarıyor.

Yüksek düzeyde, tüm Sözlüğü dolaşmak ve her bir değere bakmaktan başka seçeneğiniz yoktur.

Belki bu yardımcı olur: http://bytes.com/forum/thread563638.html John Timney'den Kopyalama / Yapıştırma:

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

Bir sözlüğü asla asla sıralayamazsınız. Aslında sıralı değiller. Bir sözlüğün garantileri, anahtar ve değer koleksiyonlarının yinelenebilir olması ve değerlerin dizin veya anahtarla alınabilmesidir, ancak belirli bir siparişin garantisi yoktur. Bu nedenle, ad değeri çiftini bir listeye almanız gerekir.

Sözlükteki girişleri sıralamazsınız. .NET'teki sözlük sınıfı karma olarak uygulanır - bu veri yapısı tanım gereği sıralanabilir değildir.

Koleksiyonunuz üzerinde yineleme yapabilmeniz gerekiyorsa (anahtar ile) - İkili Arama Ağacı olarak uygulanan SortedDictionary'yı kullanmanız gerekir.

Ancak sizin durumunuzda, kaynak yapı önemsizdir, çünkü farklı bir alana göre sıralanmıştır. Yine de frekansa göre sıralamanız ve ilgili alana (frekans) göre sıralanmış yeni bir koleksiyona koymanız gerekir. Yani bu koleksiyonda frekanslar anahtarlar ve kelimeler değerlerdir. Birçok kelime aynı frekansa sahip olabileceğinden (ve bunu anahtar olarak kullanacağınızdan) ne Dictionary ne de SortedDictionary kullanamazsınız (benzersiz anahtarlar gerektirir). Bu size bir SortedList bırakır.

Ana / ilk sözlüğünüzdeki orijinal öğeye bir bağlantıyı sürdürmek konusunda neden ısrar ettiğinizi anlamıyorum.

Koleksiyonunuzdaki nesneler daha karmaşık bir yapıya sahipse (daha fazla alan) ve anahtar olarak birkaç farklı alanı kullanarak bunlara verimli bir şekilde erişebilmeniz / bunları sıralayabilmeniz gerekiyorsa - Büyük olasılıkla, O (1) ekleme ve kaldırma (LinkedList) ve çeşitli indeksleme yapılarını destekler - Sözlükler / SortedDictionaries / SortedLists. Bu dizinler, bir anahtar olarak karmaşık sınıfınızdaki alanlardan birini ve bir değer olarak LinkedList'teki LinkedListNode öğesine bir işaretçi / başvuru kullanır.

Ana koleksiyon (LinkedList) ile senkronize tutmak için eklemeler ve kaldırma koordine gerekir ve kaldırma sanırım oldukça pahalı olurdu. Bu, veritabanı dizinlerinin çalışma şekline benzer - aramalar için harikalar, ancak birçok insetion ve silme işlemi yapmanız gerektiğinde bir yük haline gelirler.

Yukarıdakilerin tümü, ancak bazı ağır arama işlemleri yapacaksanız haklıdır. Bunları yalnızca frekansa göre sıralandığında bir kez çıkarmanız gerekiyorsa, (anonim) grupların bir listesini üretebilirsiniz:

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

Veya eğlenmek için bazı LINQ uzantısı iyiliği kullanabilirsiniz:

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 kullanarak denetime SortedDictionarybağlanmak için bir listeyi sıralama 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>

Sıralı bir Sözlük almanın en kolay yolu yerleşik SortedDictionarysınıfı kullanmaktır:

//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ıralı sürümünü içerir sections

Diğer yanıtlar iyidir, eğer istediğiniz tek şey Değer'e göre sıralanmış "geçici" bir listeye sahip olmaksa. Eğer sıralama kriteri bir sözlük yapmak istiyorsanız Ancak, Keybu otomatik olarak senkronize göre sıralandı başka sözlükle Valuesen kullanabilirsiniz, Bijection<K1, K2>sınıf .

Bijection<K1, K2> koleksiyonun mevcut iki sözlükle başlatılmasını sağlar, bu nedenle bunlardan birinin ayrılmasını istemiyorsanız ve diğerinin sıralanmasını istiyorsanız, kodunuzu aşağıdaki gibi kullanarak oluşturabilirsiniz:

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

dictHerhangi bir normal sözlük gibi kullanır (uygular IDictionary<K, V>) ve sonra dict.Inversesıralanan "ters" sözlüğü almak için arayın Value.

Bijection<K1, K2>Loyc.Collections.dll'nin bir parçasıdır , ancak isterseniz kaynak kodunu kendi projenize kopyalayabilirsiniz .

Not : Aynı değere sahip birden fazla anahtar olması durumunda, kullanamazsınız Bijection, ancak normal Dictionary<Key,Value>ve a arasında manuel olarak senkronizasyon yapabilirsiniz BMultiMap<Value,Key>.

Diyelim ki bir sözlük var

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

Aslında C # 'da, Sözlükler dint sort () yöntemlerine sahiptir, değerlere göre sıralamakla daha fazla ilgileniyorsanız, onlara anahtar verene kadar değer alamazsınız, kısacası, LINQ's 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
}

bir numara yapabilirsin,

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

veya

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

aynı zamanda ne tür değerleri sakladığınıza bağlıdır,
tek (dize, int gibi) veya çoklu (Liste, Dizi, kullanıcı tanımlı sınıf gibi),
eğer teklerse listeyi yapabilir ve sıralama uygulayabilirsiniz.
kullanıcı tanımlı sınıf varsa, o sınıf IComparable'ı uygulamalı
ClassName: IComparable<ClassName>ve LINQ'dan compareTo(ClassName c) daha hızlı ve daha nesne yönelimli olduklarından geçersiz kılmalıdır .

Gerekli ad alanı: 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 tarafından sipariş:

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

Artan Sipariş:

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

Sözlüğü değere göre sıralayabilir ve sonucu aşağıdaki kodu kullanarak sözlüğe alabilirsiniz:

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

Sözlüğünüz varsa, bunları bir astarın altında kullanarak doğrudan değerler üzerinde sıralayabilirsiniz:

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