मुझे अक्सर एक शब्द को क्रमबद्ध करना होता है, जिसमें मूल्य के आधार पर कुंजी और मान शामिल होते हैं। उदाहरण के लिए, मेरे पास शब्दों और संबंधित आवृत्तियों का एक हैश है, जिसे मैं आवृत्ति द्वारा ऑर्डर करना चाहता हूं।
एक ऐसा है SortedListजो एकल मान (आवृत्ति कहें) के लिए अच्छा है, कि मैं इसे शब्द में वापस मैप करना चाहता हूं।
कुंजी द्वारा क्रमबद्ध करें ऑर्डर, मूल्य नहीं। कुछ एक कस्टम वर्ग का सहारा लेते हैं , लेकिन क्या एक क्लीनर तरीका है?
जवाबों:
उपयोग:
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));
myList.Sort((x,y)=>x.Value.CompareTo(y.Value));
IEnumerable, इसलिए आप इस तरह की एक सूची प्राप्त कर सकते हैं:var mySortedList = myDictionary.OrderBy(d => d.Value).ToList();
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क्लॉज़ को भी शामिल कर सकते हैं ।
IEnumerable<KeyValuePair<TKey, TValue>>या ए OrderedDictionary<TKey, TValue>। या एक SortedDictionaryशुरू से ही उपयोग करना चाहिए । एक सादे DictionaryMSDN के लिए स्पष्ट रूप से कहा गया है "जिस क्रम में आइटम वापस किए गए हैं वह अपरिभाषित है।" ऐसा लगता है कि @ rythos42 का नवीनतम संपादन दोष देना है। :)
.ToDictionary- मानक शब्दकोश एक तरह के आदेश की गारंटी नहीं देते हैं
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
}
यह सबसे साफ तरीका है जो मैंने देखा है और हैश को संभालने के रूबी तरीके के समान है।
(for KeyValuePair<string, int> item in keywordCounts.OrderBy(key => key.Value) select item).ToDictionary(t => t.Key, t => t.Value)- आपके उत्तर के लिए बस एक छोटा सा जोड़ :) धन्यवाद, btw :)
आप किसी शब्दकोश को मान के आधार पर क्रमित कर सकते हैं और उसे अपने आप में सहेज सकते हैं (ताकि जब आप उस पर ध्यान दें तो मूल्य क्रम में बाहर आ जाएँ):
dict = dict.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.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);
}
);आप कभी भी किसी शब्दकोश को छाँटने में सक्षम नहीं होंगे। वे वास्तव में आदेशित नहीं हैं। शब्दकोश की गारंटी यह है कि कुंजी और मूल्य संग्रह पुनरावृत्ति योग्य हैं, और मूल्यों को सूचकांक या कुंजी द्वारा पुनर्प्राप्त किया जा सकता है, लेकिन किसी विशेष आदेश की कोई गारंटी नहीं है। इसलिए आपको एक सूची में नाम मूल्य जोड़ी प्राप्त करने की आवश्यकता होगी।
आप शब्दकोश में प्रविष्टियों को क्रमबद्ध नहीं करते हैं। .NET में डिक्शनरी क्लास को हैशटेबल के रूप में लागू किया गया है - यह डेटा संरचना परिभाषा के अनुसार क्रमबद्ध नहीं है।
यदि आपको अपने संग्रह (कुंजी द्वारा) को पुनरावृत्त करने में सक्षम होने की आवश्यकता है - आपको सॉर्टेडबेडर का उपयोग करने की आवश्यकता है, जिसे बाइनरी ट्री ट्री के रूप में कार्यान्वित किया जाता है।
आपके मामले में, हालांकि स्रोत संरचना अप्रासंगिक है, क्योंकि यह एक अलग क्षेत्र द्वारा सॉर्ट किया गया है। आपको अभी भी इसे आवृत्ति द्वारा सॉर्ट करना होगा और इसे संबंधित फ़ील्ड (फ़्रीक्वेंसी) द्वारा सॉर्ट किए गए नए संग्रह में रखना होगा। तो इस संग्रह में आवृत्तियाँ कुंजियाँ हैं और शब्द मान हैं। चूंकि कई शब्दों में समान आवृत्ति हो सकती है (और आप इसे एक कुंजी के रूप में उपयोग करने जा रहे हैं) आप न तो डिक्शनरी और न ही सॉर्टेडबॉडी (वे अद्वितीय कुंजी की आवश्यकता होती है) का उपयोग नहीं कर सकते हैं। यह आपको एक SortedList के साथ छोड़ देता है।
मुझे समझ में नहीं आता कि आप अपने मुख्य / पहले शब्दकोश में मूल आइटम के लिंक को बनाए रखने पर जोर क्यों देते हैं।
यदि आपके संग्रह की वस्तुओं में एक अधिक जटिल संरचना (अधिक क्षेत्र) थी और आपको कुंजी के रूप में कई अलग-अलग क्षेत्रों का उपयोग करके उन्हें कुशलतापूर्वक एक्सेस / सॉर्ट करने में सक्षम होना चाहिए - आपको संभवतः एक कस्टम डेटा संरचना की आवश्यकता होगी जिसमें मुख्य भंडारण शामिल होगा O (1) सम्मिलन और निष्कासन (लिंक्डलिस्ट) और कई अनुक्रमण संरचनाओं का समर्थन करता है - शब्दकोश / SortedD शब्दकोशों / SortedLists। ये इंडेक्स आपके कॉम्प्लेक्स क्लास से एक फ़ील्ड को एक कुंजी के रूप में और एक लिंक्डइन में लिंक्डइनिस्ट के लिए एक पॉइंटर / संदर्भ के रूप में एक मूल्य के रूप में उपयोग करेगा।
आपको अपने अनुक्रमणिका को मुख्य संग्रह (लिंक्डलिस्ट) के साथ सिंक में रखने के लिए सम्मिलन और हटाने के समन्वय की आवश्यकता होगी और निष्कासन मेरे विचार से बहुत महंगा होगा। यह उसी तरह है जैसे डेटाबेस अनुक्रमणिका कैसे काम करती है - वे लुकअप के लिए शानदार हैं लेकिन जब आप कई इंसेटिव और डिलीट करने की आवश्यकता होती है तो वे बोझ बन जाते हैं।
यदि आप कुछ लुक-अप हैवी प्रोसेसिंग करने जा रहे हैं, तो उपरोक्त सभी उचित है। यदि आपको केवल आवृत्ति द्वारा छांटे जाने के बाद उन्हें आउटपुट करने की आवश्यकता है तो आप (अनाम) टुपल्स की एक सूची तैयार कर सकते हैं:
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);
}VB.NET का उपयोग करके नियंत्रण SortedDictionaryमें बाँधने के लिए सूची को क्रमबद्ध करना 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 ClassXAML:
<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
SortedDictionaryचाबियाँ द्वारा छाँटें। ओपी मूल्य के अनुसार क्रमबद्ध करना चाहता है। SortedDictionaryइस मामले में मदद नहीं करता है।
sorteddictionary()हमेशा कम से कम 1 माइक्रोसेकंड द्वारा जीता, और इसे प्रबंधित करना बहुत आसान है (जैसा कि इसे आसानी से किसी चीज़ में परिवर्तित करने के लिए ओवरहेड किया गया है और एक शब्दकोश के समान प्रबंधित है 0 (यह पहले से ही एक है sorteddictionary)।
अन्य उत्तर अच्छे हैं, यदि आप चाहते हैं कि मूल्य के अनुसार "अस्थायी" सूची हो। हालाँकि, यदि आप चाहते हैं कि कोई ऐसा शब्दकोश छांटे Keyजो स्वचालित रूप से किसी अन्य शब्दकोश के साथ सिंक्रनाइज़Value हो जाए, तो आप Bijection<K1, K2>कक्षा का उपयोग कर सकते हैं ।
Bijection<K1, K2> आपको दो मौजूदा शब्दकोशों के साथ संग्रह को आरंभीकृत करने की अनुमति देता है, इसलिए यदि आप चाहते हैं कि उनमें से एक को अनसोल्ड किया जाए, और आप चाहते हैं कि दूसरे को सॉर्ट किया जाए, तो आप कोड के साथ अपनी जीवनी बना सकते हैं
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>और a के बीच तालमेल बिठा सकते हैं 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);
}वास्तव में सी # में, डिक्शन डिंट की तरह की () विधियां हैं, जैसा कि आप मानों के आधार पर अधिक रुचि रखते हैं, आपको तब तक मूल्य मिलते हैं जब तक आप उन्हें कुंजी प्रदान नहीं करते हैं, संक्षेप में, आपको लाइनक्यू के ऑर्डर का उपयोग करके, उनके माध्यम से पुनरावृत्त करने की आवश्यकता होती है,
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;यह इस बात पर भी निर्भर करता है कि आप किस प्रकार के मूल्यों का भंडारण कर रहे हैं,
क्या यह एकल (जैसे स्ट्रिंग, इंट) या एकाधिक (जैसे सूची, एरे, उपयोगकर्ता परिभाषित वर्ग) है,
यदि एकल आप इसकी सूची बना सकते हैं तो क्रमबद्ध करें।
यदि उपयोगकर्ता वर्ग को परिभाषित करता है, तो उस वर्ग को 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);Desc द्वारा आदेश:
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);
IComparerट्रिक भी बना सकते हैं (यह सच है कि यह तुलना करने के लिए एक कुंजी को स्वीकार करता है, लेकिन एक कुंजी के साथ, आप एक मान प्राप्त कर सकते हैं)। ;-)