Question

I basically need a data structure that works just like a Set, but that not only maintains insert order as let’s me get them later by a get(index) method.

What is the data structure best suited to achieve this? I wouldn’t have a problem in having to implement one, if needed. In the worse case I could just use both an ArrayList and a HashSet, but I’m wondering whether there is a specialized data structure up to the task.

Performance is paramount (otherwise I could just do a O(n) search over a regular list!) and I’m not that worried about spatial complexity.

Answer 1

Something like this? Edit: As Jiddo noted, this structure can’t remove elements efficiently. ArrayList + Set is simpler if an efficient remove is not required, so this structure isn’t actually good for much.

import java.util.*;

public class ArraySet<T> {
    private final Map<Integer, T> indexToElem;
    private final Map<T, Integer> elemToIndex;

    public ArraySet() {
        indexToElem = new HashMap<Integer, T>();
        elemToIndex = new HashMap<T, Integer>();
    }

    public T get(int index) {
        if (index < 0 || index >= size())
            throw new IndexOutOfBoundsException();
        return indexToElem.get(index);
    }

    public void add(T elem) {
        if (!contains(elem)) {
            int index = indexToElem.size();
            indexToElem.put(index, elem);
            elemToIndex.put(elem, index);
        }
    }

    // Doesn't work; see comment.
    /*public void remove(T elem) {
        int index = elemToIndex.get(elem);
        indexToElem.remove(index);
        elemToIndex.remove(elem);
    }*/

    public boolean contains(T elem) {
        return elemToIndex.containsKey(elem);
    }

    public int size() {
        return indexToElem.size();
    }
}