具有随机访问元素删除的类似队列的数据结构

Question

Is there a data structure like a queue which also supports removal of elements at arbitrary points? Enqueueing and dequeueing occur most frequently, but mid-queue element removal must be similar in speed terms since there may be periods where that is the most common operation. Consistency of performance is more important than absolute speed. Time is more important than memory. Queue length is small, under 1,000 elements at absolute peak load.In case it's not obvious I'll state it explicitly: random insertion is not required.

Have tagged C++ since that is my implementation language, but I'm not using (and don't want to use) any STL or Boost. Pure C or C++ only (I will convert C solutions to a C++ class.)

Edit: I think what I want is a kind of dictionary that also has a queue interface (or a queue that also has a dictionary interface) so that I can do things like this:

Container.enqueue(myObjPtr1);
MyObj *myObjPtr2 = Container.dequeue();
Container.remove(myObjPtr3);

Answer 1

I think that double-link list is exactly what you want (assuming you do not want a priority queue):

1. Easy and fast adding elements to both ends
2. Easy and fast removal of elements from anywhere

You can use std::list container, but (in your case) it is difficult to remove an element from the middle of the list if you only have a pointer (or reference) to the element (wrapped in STL's list element), but you do not have an iterator. If using iterators (eg storing them) is not an option - then implementing a double linked list (even with element counter) should be pretty easy. If you implement your own list - you can directly operate on pointers to elements (each of them contains pointers to both of its neighbours). If you do not want to use Boost or STL this is probably the best option (and the simplest), and you have control of everything (you can even write your own block allocator for list elements to speed up things).

Answer 2

One option is to use an order statistic tree , an augmented tree structure that supports O(log n) random access to each element, along with O(log n) insertion and deletion at arbitrary points. Internally, the order statistic tree is implemented as a balanced binary search treewith extra information associated with it. As a result, lookups are a slower than in a standard dynamic array, but the insertions are much faster.

Hope this helps!

Answer 3

You can use a combination of a linked list and a hash table. In java it is called a LinkedHashSet .

The idea is simple, have a linked list of elements, and also maintain a hash map of (key,nodes) , where node is a pointer to the relevant node in the linked list, and key is the key representing this node.

Note that the basic implementation is a set , and some extra work will be needed to make this data structure allow dupes.

This data structure allows you both O(1) head/tail access, and both O(1) access to any element in the list. [all on average armotorized]