适用于需要快速检索的分类数据的Collection类

Question

I am working in a scenario where I need to store a collection of KeyValuePair , having a DateTimeOffset as key. I am receiving a list of this data (via Http request) which I simply need to read and generate the collection from. It is required that the collection be maintained sorted, and it must be enumerable. Also, I may need to do a lot of lookups on this data by key.

Also note that the data I receive is already sorted in itself. I may repeat the operation of receiving data and generating the collection again, periodically. However, the existing collection is not modified, rather a new one is created each time I refresh the data.

Now, I have these methods in mind:

1. Use a SortedDictionary<,> (My current method).
2. Use a Dictionary<,> which is manually sorted after populating all items from the received data. (While this makes it very fast to look-up (O(1)), I need to now sort the data, since a Dictionary<,> does not maintain its items when added in an ordered manner.)
3. Use a simple array (or List ) which is directly populated from the data. The order of elements is maintained implicitly. Then, searching for items (ie look-ups) are done using Binary Search upon the keys.

Which method is appropriate for this scenario? Are there any other options or variations to the above methods I can use which will give me better overall performance?

Edit

I'm sorry, I've forgotten to mention that I am developing for the WinRT (specifically Windows Phone) platform. Hence I cannot use SortedList<,> (nor OrderedDictionary ), which would have been the best choice as pointed out by @lc.

Also, my collection will only have a few 100 items. Perhaps at this scale there may not be any significant difference, but I'd like to know an answer all the same.

Answer 1

Of the three options, I would certainly exclude 1 ( SortedDictionary ) because 3 (array or List ) outperforms it given your requirements (fast lookups, sorted, items provided in order, not modified).

Doing binary search on a sorted array runs in O(lg n) time. According to the documentation , look-ups in SortedDictionary also run in O(lg n) time, so no advantage in using it.

Since the data you get is already sorted, then the array is populated in O(n). Insertion in SortedDictionary runs in O(lg n) so populating it runs in O(n * lg n), which is worse.

Enumeration runs in O(n) time for both.

To answer your question, I think 2 and 3 are both viable options. Which one is best depends on the ration of insertions/lookups/enumerations you will get.

For instance, if you do one billion lookups per enumeration, then using Dictionary will probably pay off. If instead enumeration happens more often, a sorted array might be better in the end, because the data in the Dictionary will first have to be sorted and algorithms like QuickSort can do that in O(n * log n) time.

I suggest you try both in a typical use scenario for you application and see which one is best.

OR, If memory is not a concern, why not use a Dictionary AND a sorted array? If this is done properly, you could get the best of both worlds.