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

I often have to sort a dictionary, consisting of keys & values, by value. For example, I have a hash of words and respective frequencies, that I want to order by frequency.

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

SortedDictionary orders by key, not value. Some resort to a custom class, but is there a cleaner way?

0
जोड़ा संपादित
विचारों: 1
शब्दकोश को सॉर्ट करने के अलावा (स्वीकार्य उत्तर में), आप बस एक IComparer भी बना सकते हैं जो चाल करता है (सच है कि यह तुलना करने के लिए एक कुंजी स्वीकार करता है, लेकिन एक कुंजी के साथ, आप प्राप्त कर सकते हैं एक कीमत)। ;-)
जोड़ा लेखक BrainSlugs83, स्रोत

17 उत्तर

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

शायद यह मदद करता है: http://bytes.com/forum/thread563638.html जॉन टिमनी से कॉपी / पेस्टिंग:

Dictionary s = new Dictionary();
s.Add("1", "a Item");
s.Add("2", "c Item");
s.Add("3", "b Item");

List> myList = new List>(s);
myList.Sort(
    delegate(KeyValuePair firstPair,
    KeyValuePair nextPair)
    {
        return firstPair.Value.CompareTo(nextPair.Value);
    }
);
0
जोड़ा
stringnextPair -> string> nextPair stringfirstPair -> string> firstPair
जोड़ा लेखक Art, स्रोत
बिल्कुल सही गैर-लिंक समाधान। यह मुझे आश्चर्यचकित नहीं करता कि कैसे लोगों को लिंक का उपयोग करने की आवश्यकता महसूस होती है, भले ही समस्या को हल करने की पूरी आवश्यकता नहीं होती है। सी # 3 के साथ, मेरा मानना ​​है कि आप केवल लैम्ब्डा का उपयोग करने के लिए सॉर्ट को सरल बना सकते हैं: myList.Sort ((x, y) => x.Value.CompareTo (y.Value));
जोड़ा लेखक RobinHood70, स्रोत

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

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

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

0
जोड़ा
यह आसान था। दूसरी तरफ जाने के लिए इसे कैसे बदला जा सकता है?
जोड़ा लेखक Dan Hastings, स्रोत
@AndriusNaru? Evi? Ius: यदि आप परिणामस्वरूप आइटम को वापस एक शब्दकोश में जोड़ते हैं, तो आप ऑर्डर को नष्ट कर देंगे, क्योंकि शब्दकोशों की गारंटी नहीं है किसी भी विशेष फैशन में आदेश दिया जा सकता है
जोड़ा लेखक O. R. Mapper, स्रोत
इस वाक्यविन्यास का उपयोग करते समय System.Linq नामस्थान जोड़ने के लिए मत भूलना।
जोड़ा लेखक M. Dudley, स्रोत
(KeyValuePair itemCounts.OrderBy (key => key.Value) आइटम में आइटम का चयन करें) .ooo (t => t.Key, t => t.Value) - बस आपके उत्तर में एक छोटा सा जोड़ा :) धन्यवाद, बीटीडब्ल्यू :)
जोड़ा लेखक Andrius Naruševičius, स्रोत
मैं KeyValuePairs को कॉम्बोबॉक्स में जोड़ने के दौरान एक शब्दकोश को सॉर्ट करने का प्रयास कर रहा था ... यह बहुत अच्छा काम करता था! धन्यवाद!
जोड़ा लेखक Jason Down, स्रोत

उपयोग:

using System.Linq.Enumerable;
...
List> myList = aDictionary.ToList();

myList.Sort(
    delegate(KeyValuePair pair1,
    KeyValuePair pair2)
    {
        return pair1.Value.CompareTo(pair2.Value);
    }
);

Since you're targeting .NET 2.0 or above, you can simplify this into lambda syntax -- it's equivalent, but shorter. If you're targeting .NET 2.0 you can only use this syntax if you're using the compiler from Visual Studio 2008 (or above).

var myList = aDictionary.ToList();

myList.Sort((pair1,pair2) => pair1.Value.CompareTo(pair2.Value));
0
जोड़ा
यह एक लाइनर है - आपको ब्रेसिज़ की आवश्यकता नहीं है। इसे myList.Sort ((x, y) => x.Value.CompareTo (y.Value)) के रूप में पुनः लिखा जा सकता है;
जोड़ा लेखक Arnis Lapsa, स्रोत
क्या मैं आपको स्कीट stackoverflow.com/a/2705623/41211 पर भेज सकता हूं
जोड़ा लेखक GONeale, स्रोत
क्षमा करें, लेकिन यह जवाब समझना मुश्किल था क्योंकि मैं प्रतिनिधि कीवर्ड (शायद वीबी में अलग) से परिचित नहीं हूं, n यह स्पष्ट नहीं है कि सॉर्टिंग कहां हो रही है क्योंकि आपको या तो आइटम की संख्या से गुणा आइटम की संख्या चलाने की आवश्यकता होगी (आइटमों में से कोई भी नहीं) प्रत्येक तत्व के लिए प्रत्येक तत्व को संपूर्ण शब्दकोश में खोज / तुलना करके तुलना, या यदि आप केवल वर्तमान एन के बीच तुलना कर रहे हैं तो आपको संग्रह पर एक से अधिक लूप में ऐसा करने की आवश्यकता होगी, जो कि यही कारण है कि मैंने इसे 'इसे प्राप्त नहीं किया' है। सॉर्टिंग एन रीडरिंग होने पर शायद अधिक जानकारी उपयोगी होगी!
जोड़ा लेखक Erx_VB.NExT.Coder, स्रोत
सॉर्टिंग विधि में यह प्रतिनिधि विवरण VB.NET में कैसे दिखाई देगा?
जोड़ा लेखक Jonas Axelsson, स्रोत
आप लोग इसे जटिल करने के लिए waaayay हैं - एक शब्दकोश पहले से ही IEnumerable लागू करता है, इसलिए आप इस तरह की एक क्रमबद्ध सूची प्राप्त कर सकते हैं: var mySortedList = myDictionary.OrderBy (d => d.Value)। ToList ();
जोड़ा लेखक BrainSlugs83, स्रोत
मैंने इस समाधान का उपयोग किया (धन्यवाद!) लेकिन जब तक मैंने माइकल स्टम की पोस्ट (और जॉन टिमनी से उसका कोड स्निपेट) पढ़ा, तब तक एक मिनट तक भ्रमित हो गया और महसूस किया कि मेरी सूची एक द्वितीयक वस्तु है, जो कि कुंजीवैलपेयर की एक सूची है, जो शब्दकोश से बनाई गई है, और फिर क्रमबद्ध।
जोड़ा लेखक Robin Bennett, स्रोत
मुझे पता है कि यह दो साल बाद है ... लेकिन मुझे यकीन है कि यह पिछली टिप्पणी के बदले में किसी की मदद कर सकता है: myList.Sort (फ़ंक्शन (KeyPaluePair (स्ट्रिंग, स्ट्रिंग का) के रूप में firstPair, अगली पीयर के रूप में KeyValuePair (स्ट्रिंग, स्ट्रिंग का )) firstPair.Value.CompareTo (nextPair.Value))
जोड़ा लेखक sacredfaith, स्रोत
तुलनात्मक रूप से x और y को तुलना करने के क्रम में सॉर्ट करने के लिए: myList.Sort ((x, y) => y.Value.CompareTo (x.Value));
जोड़ा लेखक Arturo, स्रोत
मुझे लगता है कि यह ध्यान देने योग्य है कि इसे ToList एक्सटेंशन विधि के लिए लिंक की आवश्यकता है।
जोड़ा लेखक Ben, स्रोत

LINQ का प्रयोग करें:

Dictionary myDict = new Dictionary();
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% इत्यादि का चयन कर सकते हैं या यदि आप टाइप-आगे के लिए अपनी शब्द आवृत्ति अनुक्रमणिका का उपयोग कर रहे हैं, तो आप साथ ही साथ खंड भी शुरू होता है।

0
जोड़ा
कृपया .ToDictionary के सभी सुझावों की उपेक्षा करें - मानक शब्दकोश सॉर्ट ऑर्डर की गारंटी नहीं देते हैं
जोड़ा लेखक AlexFoxGill, स्रोत
.NET 2.0 का उपयोग करने वालों के लिए - क्या आपने अंतराल को भरने के लिए LINQBridge का उपयोग करने का प्रयास किया है? albahari.com/nutshell/linqbridge.aspx
जोड़ा लेखक jocull, स्रोत
@BorisB। मैं संस्करण को सही करने के लिए वापस लुढ़का। आप भी कर सकते थे। कोई भी बेहतर स्थान बनाने के लिए संपादित कर सकता है। सभी के लिए, ToDictionary इस समस्या का सही उत्तर नहीं है और Caryden द्वारा मूल उत्तर में यह नहीं था। हैप्पी अपवॉटिंग और अन-डाउनवॉटिंग।
जोड़ा लेखक nawfal, स्रोत
बहुत बढ़िया जवाब। और, जैसा कि अन्य उत्तरों पर अन्य टिप्पणियों में उल्लिखित है, "System.Linq का उपयोग करके" शामिल करना सुनिश्चित करें। फ़ाइल के शीर्ष पर। अन्यथा आपको कुछ भ्रमित त्रुटि संदेश मिलते हैं और IntelliSense मदद नहीं करता है।
जोड़ा लेखक Mark Meuer, स्रोत
रिटर्न प्रकार IENumerable > या OrderedDictionary होना चाहिए। या किसी को शुरुआत से SortedDictionary का उपयोग करना चाहिए। एक सादा <�कोड> शब्दकोश के लिए एमएसडीएन स्पष्ट रूप से बताता है "जिस क्रम में वस्तुओं को वापस किया जाता है वह अनिर्धारित है।"। ऐसा लगता है कि @ rythos42 का नवीनतम संपादन दोष है। :)
जोड़ा लेखक Boris B., स्रोत
मैं सॉर्ट किए गए डिक्ट्री को वापस एक शब्दकोश में कैसे बदल सकता हूं? नया एसओ प्रश्न यहां पोस्ट किया गया: stackoverflow.com/questions/3066182/…
जोड़ा लेखक Kache, स्रोत
अफसोस की बात यह है कि यह .NET Framework 2.0 की वजह से VS2005 पर काम नहीं करता है (कोई LINQ नहीं)। बामब्रिक का जवाब भी अच्छा है।
जोड़ा लेखक Smalcat, स्रोत
मुझे यकीन नहीं है कि यह हमेशा काम करता है क्योंकि शब्दकोश पर पुनरावृत्ति करने से यह गारंटी नहीं मिलती है कि KeyValuePairs को उसी क्रम में "खींच लिया गया" है जिसे वे डाले गए हैं। Ergo, इससे कोई फर्क नहीं पड़ता कि आप LINQ में ऑर्डरबी का उपयोग करते हैं क्योंकि शब्दकोश डाले गए तत्वों का क्रम बदल सकता है। यह आम तौर पर अपेक्षित काम करता है लेकिन विशेष रूप से बड़े शब्दकोशों के लिए कोई गारंटी नहीं है।
जोड़ा लेखक Bozydar Sobczak, स्रोत
मैंने अभी अन्य शीर्ष रेटेड उत्तर ( Stopwatch() का उपयोग करके) के लिए समय के लिए एक सरल विधि का उपयोग किया, और LINQ का उपयोग कर लगभग 350% समय में वृद्धि के साथ बाहर आया । चार (!) सदस्य सूची अन्य विधि = 0.0039511 सेकंड का उपयोग करके क्रमबद्ध; (वही) चार सदस्य सूची LINQ विधि = 0.0130195 सेकंड का उपयोग करके क्रमबद्ध।
जोड़ा लेखक mbrownnyc, स्रोत
var ordered = dict.OrderBy(x => x.Value);
0
जोड़ा
जोड़ा लेखक AlexFoxGill, स्रोत
4.5 ढांचे का उपयोग करके, बस सत्यापित किया गया है कि यह नहीं को शब्दकोश में वापस कास्ट की आवश्यकता है।
जोड़ा लेखक Jagd, स्रोत
मुझे यकीन नहीं है कि यह समाधान अधिक लोकप्रिय क्यों नहीं है - शायद क्योंकि इसे .NET 3.5 की आवश्यकता है?
जोड़ा लेखक Contango, स्रोत
क्योंकि इसे एक शब्दकोश में वापस कास्ट की आवश्यकता होती है जो हमेशा सीधे आगे नहीं होती है ...
जोड़ा लेखक MoonKnight, स्रोत
सॉर्ट किए गए आइटम को वापस एक शब्दकोश में डालकर @theJerm ऑर्डर की गारंटी है? यह आज काम कर सकता है, लेकिन इसकी गारंटी नहीं है।
जोड़ा लेखक nawfal, स्रोत
यह एक अच्छा समाधान है, लेकिन इसे अंतिम अर्ध-कॉलन से पहले यह अधिकार होना चाहिए: .ToDictionary (pair => pair.Key, pair => pair.Value);
जोड़ा लेखक theJerm, स्रोत
मैं इसे साफ, सरल और सरल पसंद करता हूं। @ ग्रेविटास: मैं सहमत हूं, और ओपी में फ्रेमवर्क संस्करण का उल्लेख नहीं किया गया था।
जोड़ा लेखक Andreas, स्रोत
शब्दकोशकोष में वापस नहीं डाला जाना चाहिए क्योंकि शब्दकोशों का आदेश नहीं दिया जाता है। इस बात की कोई गारंटी नहीं है कि KeyValuePairs आपके इच्छित क्रम में रहेगा।
जोड़ा लेखक David DeMar, स्रोत

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

0
जोड़ा
@recursive किसी भी शब्दकोश को उपज चाहिए। यह ध्यान रखना दिलचस्प है कि मेरा उत्तर, जो सही है, लेकिन अधूरा (बेहतर उदाहरण क्या कर सकता था) एक अमान्य उत्तर के नीचे मतदान किया गया है जिसके परिणामस्वरूप मूल शब्दकोश में डुप्लिकेट मानों पर अपवाद होंगे (कुंजी अद्वितीय हैं, मूल्यों की गारंटी नहीं है होने के लिए)
जोड़ा लेखक Roger Willcocks, स्रोत
एक क्रमबद्ध शब्दकोश हालांकि कुंजी-मूल्य जोड़े की एक सूची उत्पन्न कर सकता है।
जोड़ा लेखक recursive, स्रोत
यह bes जवाब है, क्योंकि शब्दकोश क्रमबद्ध नहीं है। यह कुंजी हैश और आप इस पर एक बेहद तेजी से तलाश ऑपरेशन कर सकते हैं।
जोड़ा लेखक Paulius Zaliaduonis, स्रोत

आप किसी डिक्शनरी को वैल्यू से सॉर्ट कर सकते हैं और उसे वापस सहेज सकते हैं (ताकि जब आप इसके बारे में सोचें तो मान क्रम में आते हैं):

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

निश्चित रूप से, यह सही नहीं हो सकता है, लेकिन यह काम करता है।

0
जोड़ा
जोड़ा लेखक AlexFoxGill, स्रोत
मुझे लगता है कि यह काम करेगा, अगर आइटम एक ही समय में शब्दकोश में जोड़े जाते हैं और कुछ भी हटाया / संशोधित नहीं किया जाता है। क्या कोई सबूत है कि .NET शब्दकोश में आइटम को फिर से ऑर्डर करेगा?
जोड़ा लेखक AaA, स्रोत
शब्दकोश आउटपुट किसी विशेष सॉर्ट ऑर्डर के लिए गारंटी नहीं है।
जोड़ा लेखक Roger Willcocks, स्रोत
यह "कामकाजी" की गारंटी नहीं है। यह एक कार्यान्वयन विस्तार है। इसे अन्य समय काम करने की ज़रूरत नहीं है। गलत जवाब, downvoted।
जोड़ा लेखक nawfal, स्रोत
मैं उत्पादन कोड में इसे देखने के लिए काफी चिंतित होगा। यह गारंटी नहीं है और किसी भी समय बदल सकता है। ऐसा नहीं है कि मैं व्यावहारिक समाधान से दूर शर्मिंदा हूं, यह केवल डेटा संरचना आईएमओ की समझ की कमी दिखाता है।
जोड़ा लेखक jamespconnor, स्रोत
यदि आप अवरोही सूची में सॉर्ट करना चाहते हैं तो आप ऑर्डरबैडसेकिंग का भी उपयोग कर सकते हैं।
जोड़ा लेखक Mendokusai, स्रोत
मेरे लिए काम किया, हालांकि मुझे इसे थोड़ा बदलना पड़ा: शब्दकोश <�कुंजी, मूल्य> dict = dict.OrderBy (x => x.Value) .ooo (x => x.Key, x => x.Value);
जोड़ा लेखक Josh, स्रोत

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

var x = (from c in dict orderby c.Value.Order ascending select c).ToDictionary(c => c.Key, c=>c.Value);
0
जोड़ा
जोड़ा लेखक O. R. Mapper, स्रोत

VB.NET का उपयोग करके ListView नियंत्रण में बाध्य करने के लिए SortedDictionary सूची को सॉर्ट करना:

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:


    
        
            
            
         
    

0
जोड़ा

The other answers are good, if you all you want is to have a "temporary" list sorted by Value. However, if you want to have a dictionary sorted by Key that automatically synchronizes with another dictionary that is sorted by Value, you could use the Bijection class.

Bijection allows you to initialize the collection with two existing dictionaries, so if you want one of them to be unsorted, and you want the other one to be sorted, you could create your bijection with code like

var dict = new Bijection(new Dictionary(), 
                               new SortedDictionary());

You can use dict like any normal dictionary (it implements IDictionary<>), and then call dict.Inverse to get the "inverse" dictionary which is sorted by Value.

Bijection is part of Loyc.Collections.dll, but if you want, you could simply copy the source code into your own project.

Note: In case there are multiple keys with the same value, you can't use Bijection, but you could manually synchronize between an ordinary Dictionary and a BMultiMap.

0
जोड़ा
http://stackoverflow.com/questions/268321 के समान है लेकिन सॉर्टेड डिक्शनरी के साथ प्रत्येक शब्दकोश को प्रतिस्थापित कर सकता है। हालांकि उत्तर डुप्लिकेट मानों का समर्थन नहीं करते हैं (1 से 1 मानते हैं)।
जोड़ा लेखक crokusek, स्रोत

या मस्ती के लिए आप कुछ LINQ एक्सटेंशन भलाई का उपयोग कर सकते हैं:

var dictionary = new Dictionary { { "c", 3 }, { "a", 1 }, { "b", 2 } };
dictionary.OrderBy(x => x.Value)
  .ForEach(x => Console.WriteLine("{0}={1}", x.Key,x.Value));
0
जोड़ा

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

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

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

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // Example dictionary.
        var dictionary = new Dictionary(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 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
0
जोड़ा

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

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

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

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

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

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

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

var dict = new SortedDictionary();
// 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);
}
0
जोड़ा

सॉर्ट किए गए शब्दकोश को पाने का सबसे आसान तरीका SortedDictionary क्लास में निर्मित करना है:

//Sorts sections according to the key value stored on "sections" unsorted dictionary, which is passed as a constructor argument
System.Collections.Generic.SortedDictionary sortedSections = null;
if (sections != null)
{
    sortedSections = new SortedDictionary(sections);
}

sortedSections will contains the sorted version of sections

0
जोड़ा
@mbrownnyc - नहीं, ऐसा करने के लिए धारणा या पूर्व शर्त की आवश्यकता होती है कि VALUES अद्वितीय हैं, जिनकी गारंटी नहीं है।
जोड़ा लेखक Roger Willcocks, स्रोत
जैसा कि आप अपनी टिप्पणी में उल्लेख करते हैं, SortedDictionary कुंजी द्वारा प्रकार। ओपी मूल्य से क्रमबद्ध करना चाहता है। SortedDictionary इस मामले में सहायता नहीं करता है।
जोड़ा लेखक Marty Neal, स्रोत
खैर ... अगर वह (आप) कर सकता है, तो मानों को केवल चाबियाँ के रूप में सेट करें। मैंने ऑपरेशन का समय दिया और sorteddictionary() कम से कम 1 माइक्रोसॉन्ड द्वारा हमेशा जीता, और इसे प्रबंधित करना बहुत आसान है (जैसा कि इसे किसी भी तरह से आसानी से बातचीत और प्रबंधित करने के लिए प्रबंधित किया जाता है, 0 (यह पहले से ही एक sorteddictionary है))।
जोड़ा लेखक mbrownnyc, स्रोत

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

Dictionary <> ShareUserNewCopy = 
       ShareUserCopy.OrderBy(x => x.Value).ToDictionary(pair => pair.Key,
                                                        pair => pair.Value);                                          
0
जोड़ा
और जब आप पहले ही उत्तर दे चुके हैं तो आप यह जवाब क्यों जोड़ रहे हैं?
जोड़ा लेखक nawfal, स्रोत
सॉर्ट किए गए आइटम को वापस एक शब्दकोश में डालकर, जब आप नए शब्दकोश की गणना करते हैं तो उन्हें क्रमबद्ध करने की गारंटी नहीं दी जाती है।
जोड़ा लेखक Marty Neal, स्रोत

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

   Dictionary dict = new Dictionary();
   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) आप अस्थायी शब्दकोश का उपयोग मूल्यों को स्टोर करने के लिए के रूप में कर सकते हैं:

        Dictionary dctTemp = new Dictionary();

        foreach (KeyValuePair pair in dict.OrderBy(key => key.Value))
        {
            dctTemp .Add(pair.Key, pair.Value);
        }
0
जोड़ा
Dictionary dic= new Dictionary();
var ordered = dic.OrderBy(x => x.Value);
return ordered.ToDictionary(t => t.Key, t => t.Value);
0
जोड़ा
भी गलत है। यहां देखें: stackoverflow.com/a/4007787/463828
जोड़ा लेखक Philipp M, स्रोत