Data structure that always keeps n-best elements

I need a data structure that always holds the n largest items inserted so far (in no particular order).

So, if n is 3, we could have the following session where I insert a few numbers and the content of the container changes:

[]  // now insert 1
[1] // now insert 0
[1,0] // now insert 4
[1,0,4] // now insert 3
[1,4,3] // now insert 0
[1,4,3] // now insert 3
[4,3,3]

You get the idea. What's the name of the data structure? What's the best way to implement this? Or is this in some library?

I am thinking to use a container that has a priority_queue for its elements (delegation), which uses the reverse comparison, so pop will remove the smallest element. So the insert function first checks if the new element to be inserted is greater than the smallest. If so, we throw that smallest out and push the new element.

(I have a C++ implementation in mind, but the question is language-agnostic nevertheless.)

The specific datastructure you want is probably the implicit heap. The raw datastructure is just an array; for convenience, say that it is N=2^n elements in size, and that you want to maintain the largest N-1 elements.

The idea is to treat the array (call it A) as a complete binary tree of depth n:

• ignore A[0]; treat A[1] as the root node
• for each node A[k], the children are A[2*k] and A[2*k+1]
• nodes A[N/2..N-1] are the leaves

To maintain the tree as a "heap", you need to ensure that each node is smaller than (or equal to) its children. This is called the "heap condition":

• A[k] <= A[2*k]
• A[k] <= A[2*k+1]

To use the heap to maintain the largest N elements:

• note that the root A[1] is the smallest element in the heap.
• compare each new element (x) to the root: if it is smaller (x<A[1]), reject it.
• otherwise, insert the new element into the heap, as follows:
  • remove the root (A[1], the smallest element) from the heap, and reject it
  • replace it with the new element (A[1]:= x)
  • now, restore the heap condition:
    • if x is less than or equal to both of its children, you're done
    • otherwise, swap x with the smallest child
    • repeat the test&swap at each new position until the heap condition is met

Basically, this will cause any replacement element to "filter up" the tree until it achieves its natural place. This will take at most n=log2(N) steps, which is as good as you can get. Also, the implicit form of the tree allows a very fast implementation; existing bounded-priority-queue libraries will most likely use an implicit heap.