c# आप मूल्य से एक शब्दकोश को कैसे क्रमबद्ध करते हैं?




sorting dictionary (14)

मुझे अक्सर मूल्य के अनुसार कुंजी और मूल्यों सहित एक शब्दकोश को सॉर्ट करना होता है। उदाहरण के लिए, मेरे पास शब्दों और संबंधित आवृत्तियों का हैश है, कि मैं आवृत्ति के अनुसार आदेश देना चाहता हूं।

एक SortedList जो एकल मान (आवृत्ति कहें) के लिए अच्छा है, कि मैं इसे वापस शब्द में मैप करना चाहता हूं।

कुंजी द्वारा SortedDictionary किए गए 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);
}

सॉर्ट किए गए sections में sections का क्रमबद्ध संस्करण होगा


आप वैसे भी एक शब्दकोश को सॉर्ट करने में सक्षम नहीं होंगे। वे वास्तव में आदेश नहीं दिया जाता है। एक शब्दकोश के लिए गारंटी यह है कि कुंजी और मूल्य संग्रह पुन: प्रयोज्य हैं, और मूल्य सूचकांक या कुंजी द्वारा पुनर्प्राप्त किए जा सकते हैं, लेकिन यहां किसी विशेष आदेश की कोई गारंटी नहीं है। इसलिए आपको नाम मूल्य जोड़ी को एक सूची में प्राप्त करने की आवश्यकता होगी।


यह देखते हुए कि आपके पास एक शब्दकोश है, आप उन्हें नीचे एक लाइनर का उपयोग करके मूल्यों पर सीधे क्रमबद्ध कर सकते हैं:

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

आप मूल्य से शब्दकोश को सॉर्ट कर सकते हैं और परिणाम को नीचे दिए गए कोड का उपयोग करके शब्दकोश में प्राप्त कर सकते हैं:

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

उच्च स्तर पर, पूरे शब्दकोश के माध्यम से चलने के लिए आपके पास कोई अन्य विकल्प नहीं है और प्रत्येक मान को देखें।

शायद यह मदद करता है: 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);
    }
);

Dictionary<string, string> dic= new Dictionary<string, string>();
var ordered = dic.OrderBy(x => x.Value);
return ordered.ToDictionary(t => t.Key, t => t.Value);

आप शब्दकोश में प्रविष्टियों को सॉर्ट नहीं करते हैं। .NET में शब्दकोश वर्ग को हैशटेबल के रूप में कार्यान्वित किया गया है - यह डेटा संरचना परिभाषा द्वारा क्रमबद्ध नहीं है।

यदि आपको अपने संग्रह (कुंजी द्वारा) पर फिर से चलाने में सक्षम होना चाहिए - आपको सॉर्टेड डिक्शनरी का उपयोग करने की आवश्यकता है, जिसे बाइनरी सर्च ट्री के रूप में कार्यान्वित किया गया है।

आपके मामले में, हालांकि स्रोत संरचना अप्रासंगिक है, क्योंकि इसे एक अलग क्षेत्र द्वारा क्रमबद्ध किया जाता है। आपको अभी भी इसे आवृत्ति द्वारा क्रमबद्ध करने और प्रासंगिक फ़ील्ड (आवृत्ति) द्वारा क्रमबद्ध एक नए संग्रह में रखने की आवश्यकता होगी। तो इस संग्रह में आवृत्तियों कुंजी हैं और शब्द मूल्य हैं। चूंकि कई शब्दों में एक ही आवृत्ति हो सकती है (और आप इसे एक कुंजी के रूप में उपयोग करने जा रहे हैं) आप न तो शब्दकोश का उपयोग नहीं कर सकते हैं और न ही SortedDictionary (उन्हें अद्वितीय कुंजी की आवश्यकता है)। यह आपको सॉर्टेडलिस्ट के साथ छोड़ देता है।

मुझे समझ में नहीं आता कि आप अपने मुख्य / पहले शब्दकोश में मूल आइटम के लिंक को बनाए रखने का आग्रह क्यों करते हैं।

यदि आपके संग्रह में ऑब्जेक्ट्स में अधिक जटिल संरचना (अधिक फ़ील्ड) थीं और आपको चाबियों के रूप में कई अलग-अलग फ़ील्ड का उपयोग करके कुशलतापूर्वक एक्सेस / सॉर्ट करने में सक्षम होना आवश्यक था - आपको शायद एक कस्टम डेटा स्ट्रक्चर की आवश्यकता होगी जिसमें मुख्य स्टोरेज होगा ओ (1) सम्मिलन और हटाने (लिंक्डलिस्ट) और कई अनुक्रमण संरचनाओं का समर्थन करता है - शब्दकोश / सॉर्ट किए गए शब्दकोश / सॉर्ट किए गएसूची। ये इंडेक्स आपकी जटिल श्रेणी के फ़ील्ड में एक कुंजी के रूप में लिंक किए गए लिस्ट में लिंक्डलिस्ट नोड के लिए एक कुंजी और पॉइंटर / संदर्भ के रूप में उपयोग करेंगे।

आपको अपने इंडेक्स को मुख्य संग्रह (लिंक्डलिस्ट) के साथ समन्वयित रखने के लिए सम्मिलन और निष्कासन समन्वय करने की आवश्यकता होगी और निकालना बहुत महंगा होगा जो मुझे लगता है। यह डेटाबेस इंडेक्स कैसे काम करता है के समान है - वे लुकअप के लिए शानदार हैं लेकिन जब आप कई इन्सटेशन और हटाना चाहते हैं तो वे बोझ बन जाते हैं।

उपर्युक्त सभी केवल तभी उचित हैं जब आप कुछ लुक-अप भारी प्रसंस्करण करने जा रहे हैं। यदि आपको आवृत्ति द्वारा क्रमबद्ध करने के बाद केवल उन्हें आउटपुट करने की आवश्यकता है तो आप केवल (अनाम) tuples की एक सूची तैयार कर सकते हैं:

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

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

मान लें कि हमारे पास एक शब्दकोश है

   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 लिए 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);
        }

उपयोग:

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 को लक्षित कर रहे हैं तो आप केवल इस सिंटैक्स का उपयोग कर सकते हैं यदि आप विजुअल स्टूडियो 2008 (या ऊपर) से कंपाइलर का उपयोग कर रहे हैं।

var myList = aDictionary.ToList();

myList.Sort((pair1,pair2) => pair1.Value.CompareTo(pair2.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));

क्रमबद्ध करें

यह दिखाता है कि एक शब्दकोश में मूल्यों को कैसे क्रमबद्ध करें। हम एक कंसोल प्रोग्राम देखते हैं जिसे आप विजुअल स्टूडियो में संकलित कर सकते हैं और चला सकते हैं। यह एक शब्दकोश में कुंजी जोड़ता है और फिर उन्हें अपने मूल्यों से जोड़ता है। याद रखें कि शब्दकोश उदाहरणों को शुरू में किसी भी तरह से क्रमबद्ध नहीं किया जाता है। हम क्वेरी कथन में LINQ ऑर्डरबी कीवर्ड का उपयोग करते हैं।

ऑर्डरब क्लॉज प्रोग्राम जो शब्दकोश टाइप करता है [सी #]

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

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 लिए अपनी वर्ड फ्रीक्वेंसी इंडेक्स का उपयोग कर रहे हैं, तो आप StartsWith क्लॉज भी शामिल कर सकते हैं।


चारों ओर देख रहे हैं, और कुछ सी # 3.0 सुविधाओं का उपयोग करके हम यह कर सकते हैं:

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

यह मैंने देखा है कि सबसे साफ तरीका है और हैंशिंग हैंडलिंग के रूबी तरीके के समान है।





dictionary