Question

I’m not sure if it’s possible but it seems a little bit reasonable to me, I’m looking for a data structure which allows me to do these operations:

• insert an item with O(log n)
• remove an item with O(log n)
• find/edit the k’th-smallest element in O(1), for arbitrary k (O(1) indexing)

of course editing won’t result in any change in the order of elements. and what makes it somehow possible is I’m going to insert elements one by one in increasing order. So if for example I try inserting for the fifth time, I’m sure all four elements before this one are smaller than it and all the elements after this this are going to be larger.

Answer 1

I don’t know if the requested time complexities are possible for such a data container. But here is a couple of approaches, which almost achieve these complexities.

First one is tiered vector with O(1) insertion and indexing, but O(sqrt N) deletion. Since you expect only about 10000 elements in this container and sqrt(10000)/log(10000) = 7, you get almost the required performance here. Tiered vector is implemented as an array of ring-buffers, so deleting an element requires moving all elements, following it in the ring-buffer, and moving one element from each of the following ring-buffers to the one, preceding it; indexing in this container means indexing in the array of ring-buffers and then indexing inside the ring-buffer.

It is possible to create a different container, very similar to tiered vector, having exactly the same complexities, but working a little bit faster because it is more cache-friendly. Allocate a N-element array to store the values. And allocate a sqrt(N)-element array to store index corrections (initialized with zeros). I’ll show how it works on the example of 100-element container. To delete element with index 56, move elements 57..60 to positions 56..59, then in the array of index corrections add 1 to elements 6..9. To find 84-th element, look up eighth element in the array of index corrections (its value is 1), then add its value to the index (84+1=85), then take 85-th element from the main array. After about half of elements in main array are deleted, it is necessary to compact the whole container to attain contiguous storage. This gets only O(1) cumulative complexity. For real-time applications this operation may be performed in several smaller steps.

This approach may be extended to a Trie of depth M, taking O(M) time for indexing, O(M*N^1/M) time for deletion and O(1) time for insertion. Just allocate a N-element array to store the values, N^(M-1)/M, N^(M-2)/M, …, N^1/M-element arrays to store index corrections. To delete element 2345, move 4 elements in main array, increase 5 elements in the largest “corrections” array, increase 6 elements in the next one and 7 elements in the last one. To get element 5678 from this container, add to 5678 all corrections in elements 5, 56, 567 and use the result to index the main array. Choosing different values for ‘M’, you can balance the complexity between indexing and deletion operations. For example, for N=65000 you can choose M=4; so indexing requires only 4 memory accesses and deletion updates 4*16=64 memory locations.