इंडेक्स सूची पर बहुत धीमी है। तेज समाधान?

Question

मेरे पास सामान्य सूची है जो एक संरक्षित आदेश होना चाहिए ताकि मैं सूची में किसी ऑब्जेक्ट की अनुक्रमणिका पुनर्प्राप्त कर सकूं। समस्या इंडेक्सऑफ बहुत धीमी है। अगर मैं इंडेक्सऑफ पर टिप्पणी करता हूं, तो कोड जितना तेज़ हो सकता है। क्या कोई बेहतर तरीका है, जैसे संरक्षित सी # के लिए हैश सूची का आदेश दिया गया है?

धन्यवाद, नैट

• संपादित करें - जिस क्रम में आइटम जोड़े गए/सम्मिलित आदेश इसे होने की जरूरत है। उन पर कोई छंटनी जरूरी नहीं है। इसके अलावा इस सूची में अक्सर अद्यतन, जोड़ने, हटाने, डालने की क्षमता है। असल में मुझे ऑब्जेक्ट को ग्रिड कंट्रोल में प्रदर्शित होने के कारण इंडेक्स में अनुवाद करने की आवश्यकता है ताकि मैं इंडेक्स के आधार पर ग्रिड नियंत्रण पर संचालन कर सकूं।

Answer 1

अगर यह हल नहीं है, लेकिन आदेश संरक्षित किए जाने की जरूरत है, तो आप एक अलग Dictionary<YourClass, int> जो प्रत्येक तत्व के लिए सूचकांक होते हैं हो सकता था।

आप एक क्रमबद्ध सूची चाहते हैं, तो पिछले पोस्ट की जाँच - आप नेट 3.5 में SortedList<Tkey, TValue> उपयोग कर सकते हैं, या यह सॉर्ट और बड़े नेट संस्करणों में BinarySearch का उपयोग करें।

[संपादित करें] आप वेब पर समान उदाहरण पा सकते हैं, ई।जी .: OrderedList। यह आंतरिक रूप से एक ArrayList और हैशटेबल का उपयोग करता है, लेकिन आप आसानी से इसे सामान्य बना सकते हैं।

[EDIT2] ओह .. उदाहरण मैं तुम्हें indexOf तरह से मैं शुरुआत में वर्णित को लागू नहीं करता है ... लेकिन आप बात समझ दे दी है - एक सूची का आदेश दिया जाना चाहिए, एक दूसरे को त्वरित देखने के लिए इस्तेमाल किया।

Answer 2

वैसे कोई कारण नहीं है कि आपको कभी हैश सूची का ऑर्डर देना पड़े ... यह एक तरह का मुद्दा है। हालांकि, एक हैश सूची को चाल को काफी आसानी से करना चाहिए।

Answer 3

शायद आप SortedList<TKey, TValue> देख रहे हैं?

Answer 4

क्रमबद्ध यह List<T>.Sort का उपयोग कर, तो List<T>.BinarySearch विधि का उपयोग करें: "खोजों पूरे एक तत्व के लिए List(T) हल कर [...] इस विधि एक हे (लॉग एन) आपरेशन, जहां n में तत्वों की संख्या है रेंज। "

Answer 5

आप सूची वर्ग का उपयोग कर रहे हैं तो आप सॉर्ट करने के लिए यह करने के बाद शुरू में तो आबादी है BinarySearch विधि का उपयोग उचित तत्व को खोजने के लिए क्रमबद्ध विधि का उपयोग कर सकते हैं।

Answer 6

यदि आपको क्रमबद्ध वस्तुओं की आवश्यकता है तो SortedList<TKey, TValue> या SortedDictionary<TKey, TValue> कक्षा का उपयोग करने का सुझाव है। मतभेद निम्नलिखित हैं।

• SortedList<TKey, TValue>SortedDictionary<TKey, TValue> से कम स्मृति का उपयोग करता है। हे (लॉग एन) के रूप में SortedList<TKey, TValue> के लिए हे (एन) का विरोध किया:

• SortedDictionary<TKey, TValue> अवर्गीकृत डेटा के लिए तेजी से प्रविष्टि और हटाने कार्य किया है।

• सूची क्रमबद्ध डेटा से एक ही बार में सब से भर जाता है, तो SortedList<TKey, TValue> SortedDictionary<TKey, TValue> से तेज है।

तुम सिर्फ आदेश सुरक्षित रखना चाहते हैं, तो आप सिर्फ एक Dictionary<TKey, TValue> का उपयोग करें और कुंजी के रूप में आइटम और मूल्य के रूप में सूचकांक स्टोर कर सकते हैं। दोष यह है कि वस्तुओं, सम्मिलन, या हटाने के लिए काफी महंगा है।

Answer 7

मैं सी # में बारीकियों के बारे में यकीन नहीं है, लेकिन आप इसे सुलझाने के लिए सक्षम हो सकता है (quicksort?) और फिर उस पर एक द्विआधारी खोज का उपयोग करें (BinarySearch प्रदर्शन हे है (log2 (एन)), अनुक्रमिक बनाम, इस तरह के इंडेक्सऑफ के रूप में, जो ओ (एन) है)। (महत्वपूर्ण: एक बाइनरी खोज के लिए, आपकी संरचना को सॉर्ट किया जाना चाहिए)

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

केवल मुद्दा यह है कि प्रविष्टि धीमी हो जाएगा।

Answer 8

सूची में वस्तुओं के आदेश है तो संरक्षित करने का एकमात्र तरीका है मैं जहाँ आप सबसे तेजी से संभव पहुँच प्राप्त करने के लिए जा रहे हैं के बारे में सोच सकते हैं वस्तु जब बताने के लिए अपने सूचकांक स्थिति क्या है इसकी सूची में जोड़ा आदि। इस तरह आप सूची में अपनी अनुक्रमणिका प्राप्त करने के लिए ऑब्जेक्ट से पूछ सकते हैं। नकारात्मक, और यह मेरे विचार में एक बड़ा नकारात्मक पक्ष है, यह है कि सम्मिलित वस्तुओं की सूची में निर्भरता है।

Answer 9

this article here के नीचे देखें।

ऐसा लगता है कि अपनी खुद की विधि लेखन सूचकांक को पुनः प्राप्त करने indexOf पद्धति का उपयोग करके की तुलना में काफी तेज है, तथ्य यह है कि यह एक आभासी विधि प्रकार के आधार पर कॉल की वजह से।

कुछ इस तरह इसलिए अपने प्रदर्शन में सुधार कर सकते हैं। मैंने यह सत्यापित करने के लिए एक छोटा यूनिट टेस्ट लिखा था कि यह खोज के प्रदर्शन में सुधार करता है, और 10,000 वस्तुओं के साथ सूची में लगभग 15x तक।

static int GetIndex(IList<Item> list, Item value) 
{ 
    for (int index = 0; index < list.Count; index++) 
    { 
     if (list[index] == value) 
     { 
      return index; 
     } 
    } 
    return -1; 
}