คุณเรียงลำดับพจนานุกรมตามค่าอย่างไร

ฉันมักจะต้องเรียงลำดับพจนานุกรมประกอบด้วยปุ่ม & ค่าตามค่า ตัวอย่างเช่นฉันมีคำและความถี่ที่เกี่ยวข้องซึ่งฉันต้องการเรียงลำดับตามความถี่

มีค่า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 หรือสูงกว่าคุณสามารถทำให้สิ่งนี้ง่ายขึ้นในรูปแบบแลมบ์ดา - ซึ่งเทียบเท่า แต่สั้นกว่า หากคุณกำหนดเป้าหมายเป็น. 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);

แน่นอนว่ามันอาจไม่ถูกต้อง แต่ใช้งานได้

ในระดับสูงคุณไม่มีทางเลือกอื่นนอกจากเดินดูทั้งพจนานุกรมและดูแต่ละค่า

อาจช่วยได้: 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 ถูกนำมาใช้เป็น hashtable - โครงสร้างข้อมูลนี้ไม่สามารถจัดเรียงตามนิยาม

หากคุณจำเป็นต้องสามารถวนซ้ำคอลเลกชันของคุณ (โดยคีย์) - คุณต้องใช้ SortedDictionary ซึ่งถูกนำมาใช้เป็นแผนผังการค้นหาแบบไบนารี

ในกรณีของคุณอย่างไรก็ตามโครงสร้างของแหล่งข้อมูลนั้นไม่เกี่ยวข้องเนื่องจากถูกจัดเรียงตามเขตข้อมูลอื่น คุณจะต้องเรียงลำดับตามความถี่และเก็บไว้ในคอลเล็กชันใหม่เรียงตามฟิลด์ที่เกี่ยวข้อง (ความถี่) ดังนั้นในคอลเล็กชั่นนี้ความถี่จึงเป็นกุญแจและคำเป็นค่า เนื่องจากคำหลายคำสามารถมีความถี่เท่ากัน (และคุณจะใช้เป็นคีย์) คุณจึงไม่สามารถใช้ทั้งพจนานุกรมและ SortedDictionary (ต้องใช้คีย์ที่ไม่ซ้ำกัน) สิ่งนี้ทำให้คุณมี SortedList

ฉันไม่เข้าใจว่าทำไมคุณยืนยันในการรักษาลิงก์ไปยังรายการต้นฉบับในพจนานุกรมหลัก / แรกของคุณ

หากวัตถุในคอลเลกชันของคุณมีโครงสร้างที่ซับซ้อนมากขึ้น (เขตข้อมูลเพิ่มเติม) และคุณจำเป็นต้องสามารถเข้าถึง / จัดเรียงได้อย่างมีประสิทธิภาพโดยใช้เขตข้อมูลที่แตกต่างกันเป็นคีย์ - คุณอาจต้องใช้โครงสร้างข้อมูลแบบกำหนดเองที่ประกอบด้วยหน่วยเก็บข้อมูลหลัก รองรับการแทรกและกำจัด O (1) (LinkedList) และโครงสร้างการจัดทำดัชนีหลายรายการ - พจนานุกรม / SortedDictionaries / SortedLists ดัชนีเหล่านี้จะใช้หนึ่งในฟิลด์จากคลาสที่ซับซ้อนของคุณเป็นคีย์และตัวชี้ / การอ้างอิงถึง LinkedListNode ใน LinkedList เป็นค่า

คุณจะต้องประสานงานการแทรกและการลบเพื่อให้ดัชนีของคุณตรงกับคอลเลกชันหลัก (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รายการเพื่อผูกเข้ากับ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>

วิธีที่ง่ายที่สุดในการรับพจนานุกรมที่เรียงลำดับคือการใช้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> ช่วยให้คุณสามารถเริ่มต้นการรวบรวมด้วยพจนานุกรมที่มีอยู่สองฉบับได้ดังนั้นหากคุณต้องการให้เรียงลำดับอย่างใดอย่างหนึ่งและคุณต้องการให้อีกอันเรียงลำดับคุณสามารถสร้าง biject ด้วยรหัสเช่น

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>

สมมติว่าเรามีพจนานุกรมเป็น

   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 #, พจนานุกรมอาศัยวิธีการจัดเรียง () เนื่องจากคุณสนใจเรียงลำดับตามค่ามากขึ้นคุณไม่สามารถรับค่าได้จนกว่าคุณจะให้คีย์ในระยะสั้นคุณต้องวนซ้ำโดยใช้คำสั่งของ 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
}

คุณสามารถทำหนึ่งเคล็ดลับ

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

หรือ

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

มันยังขึ้นอยู่กับชนิดของค่าที่คุณเก็บ
ไว้มันเป็นโสด (เช่นสตริง, int) หรือหลาย ๆ (เช่น List, Array, class ที่ผู้ใช้กำหนด)
ถ้าคุณสามารถสร้างรายการของมันแล้วใช้การเรียงลำดับ
ถ้าผู้ใช้กำหนดคลาสคลาสนั้นจะต้องใช้ 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.
}

เรียงลำดับโดย 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);