Question

I have a large amount of data that is retrieved from a database. They are ordered by timestamp (which each item has) and I wish to quickly scroll smoothly through this data as well as being able to retrieve the next/previous record given a specific time.

Is there any data structure that will help me do this? At the moment I do a kind of binary search through the data to retrieve the next items.

Inserts, deletions and edits are rare (but occasionally necessary) so seek time is the most critical.

Any ideas?

A simple example:

public class TimedDataItem
{
    DateTime Timestamp { get; set; }
}

// Large populated timestamped data set    
IList<TimedDataItem> timedDataItemsList = new Last<TimedDataItem>();

// Get a 'random' time
DateTime myTime = DateTime.Now;

// Find items around that 'random' time
TimedDataItem next = timedDataItemsList.FirstOrDefault(t=>t.Timestamp > myTime);
TimedDataItem previous = timedDataItemsList.LastOrDefault(t=>t.Timestamp < myTime);

// Also foreach over the collection in time order if required
foreach (TimedDataItem item in timedDataItemsList)
    DoStuff(item);

// Inserts, deletions, edits are extremely rare

Thanks.

Answer 1

Edited answer

Preferred solution – SortedSet

plus: sorted collection, allows logic use of elements within a certain range

minus: not sure what search algorithm, no previous and next

public class TimedDataItem   
{
    public DateTime Timestamp { get; set; }
}
class TimedDataItemComparer : IComparer<TimedDataItem>
{
    public int Compare(TimedDataItem x, TimedDataItem y)
    {
        return x.Timestamp.CompareTo(y.Timestamp);
    }
}
class Program
{
    static void Main(string[] args)
    {
        SortedSet<TimedDataItem> ss = 
            new SortedSet<TimedDataItem>(new TimedDataItemComparer());

        // example data
        ss.Add(new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-5) });
        TimedDataItem min = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-3) };
        ss.Add(min);
        ss.Add(new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-1) });
        ss.Add(new TimedDataItem() { Timestamp = DateTime.Now });
        ss.Add(new TimedDataItem() { Timestamp = DateTime.Now.AddDays(1) });
        TimedDataItem max = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(3) };
        ss.Add(max);
        ss.Add(new TimedDataItem() { Timestamp = DateTime.Now.AddDays(5) });

        // get elements in range
        SortedSet<TimedDataItem> view = ss.GetViewBetween(min, max);

        foreach (TimedDataItem item in view)
        {
            Console.WriteLine(item.Timestamp);
        }
    }    
}

Solution SortedList

plus: sorted, typeSafe, allows next and prev

minus: linear search

 SortedList<TimedDataItem, TimedDataItem> sl =
            new SortedList<TimedDataItem, TimedDataItem>(new TimedDataItemComparer());

 TimedDataItem first = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-5) };
 TimedDataItem second = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-3) };
 TimedDataItem third = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(-1) };
 TimedDataItem fourth = new TimedDataItem() { Timestamp = DateTime.Now };
 TimedDataItem fifth = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(1) };
 TimedDataItem sixth = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(3) };
 TimedDataItem seventh = new TimedDataItem() { Timestamp = DateTime.Now.AddDays(5) };

 sl.Add(first, first);
 sl.Add(second, second);
 sl.Add(third, third);
 sl.Add(fourth, fourth);
 sl.Add(fifth, fifth);
 sl.Add(sixth, sixth);
 sl.Add(seventh, seventh);

 // unfortunatelly according to MSDN: 
 //   This method uses a linear search; therefore, this method is 
 //   an O(n) operation, where n is Count.
 int index = sl.IndexOfKey(third);
 TimedDataItem prev = sl.ElementAt(index - 1).Value;
 TimedDataItem next = sl.ElementAt(index + 1).Value;

Solution ArrayList

plus: allows use of an index, binarySearch (!)

minus: what should you do with an index in an unordered collection …

ArrayList al = new ArrayList();
al.Add(first);
al.Add(second);
al.Add(third);
al.Add(fourth);
al.Add(fifth);
al.Add(seventh);
al.Add(seventh);

int index2 = al.BinarySearch(third, new TimedDataItemComparer2());
// al[index2] does not make sense
// as there is no guarantee, that al[index2-1] is the element
// with previous DateTime ...

class TimedDataItemComparer2 : IComparer
{
    public int Compare(object x, object y)
    {
        if (x is TimedDataItem && y is TimedDataItem)
            return ((TimedDataItem)x).Timestamp.
                       CompareTo(((TimedDataItem)y).Timestamp);
        else
            return -1;
    }
}