I have a list that I want to be able to store 20 values. What would be a good approach to deleting older values. A better example would be, imagine a change history and I wan't to be able to store 20 latest changes, while older ones go away.
Is there a special thing in C# that will let me do that or do I have to either make my own or use the Remove function.
EDIT1: Alright, how about storing 4000 - 10000 values, suddenly a linked-list looks attractive.
EDIT2: Circular list is good BUT, I don't want to be able to开发者_JS百科 loop my older values.
EDIT3: For my problem, random access isn't too important, but sequential access is.
use a Queue. each time you enqueue into the queue check if size == 20. If so, dequeue/pop one element
Sounds like you're describing a ring buffer. How would you code an efficient Circular Buffer in Java or C# might be helpful.
You can make your own list class:
public class BoundedList<T> : Collection<T> {
public int MaxSize { get; private set; }
public BoundedList(int MaxSize) : base(new List<T>(maxSize)) {
MaxSize = maxSize;
}
protected override void InsertItem(T item, int index) {
base.InsertItem(item, index)
if (Count > MaxSize)
Remove(0);
}
}
There is no built in collection that handles that, but you could easily make one:
public class LimitedList<T> : List<T> {
public new void Add(T item) {
if (Count == 20) {
RemoveAt(0);
}
base.Add(item);
}
}
Note though that this currently only handles the limit when items are added using the Add
method, and not other methods like AddRange
and Insert
. Also, as SLask pointed out, the List<T>
class isn't specifically intended to be inherited (although it's not marked as final
), so a more robust implementation would encapsulate the list instead of inheriting from it.
Note also that it's inefficient to remove the first item in a large list, but with as few items as 20, there is no problem. A LinkedList would handle that better if you need a much larger collection.
Alright I finally got a chance to think about this problem myself and found a good compromise without going through too much effort. Why not just use a linked list.
- For a history type of implementation, just keep track of the pointer.
- It will still be linear time for sequencing operations.
- Removing the last value can be done in constant time.
I guess I failed to mention that random access wasn't too important...
精彩评论