使用什么数据结构

Question

I'm looking for a data structure that has the following properties.

• Stores a list of tuple<Double,Integer,Integer> . Order is only on double . Two tuples with the same double value are consider the same.
• Supports duplicates.
• Needs to be able to traverse in ascending order. If there are duplicates, the one added later should have higher order.
• Find/Insert fast
• Remove fast, note that remove always follows this pattern

Method contains remove:

for(int i=list.size()-1;i>=0;i--){// assume list is in ascending order
    if(list[j:i] can be merged){
        remove list[j:i-1];
        update list[i]'s two integers;
        i = j-1;
    }
}

I currently use ArrayList and keep it sorted. Finding is fast with binary search. However insertion and deletion will involve lots of copy in memory, eg insertion in the front of the list shifts all the elements.

Answer 1

One solution would be to have a sorted map to lists of tuples:

SortedMap<Double,List<Tuple<Integer,Integer>>>

The declaration line is bit ugly, but it will work. I've used maps to lists many times before. The nice thing about it is that you can then delete items from the lists and as long as your lists are each short, you have a smaller number of moves. To iterate over the entire structure, you'd need to create your own iterator, or adapt your original code.

Answer 2

If you decide to write your own Double comparator there are a few things to be aware of.

The first is that floating point equality is a very tricky area. By default Java does not ensure consisten floating point math when your code is running in different virtual machines although this can be done by using the strictfp keyword. This inconsistency in floating point arithmetic can cause issues in applications that are unaware of this and run on multiple virtual machines communicating with one another, such as servers and client communication.

The second tricky bit is that Comparators operate on Objects which means you will be working with Doubles not doubles. The following four operations cause Double to be unboxed into double: <, <=, >, and >=. The following two do not cause unboxing: == and !=. These two operators perform Object memory pointer comparisons. Bottom line, manually unbox the Doubles into doubles before performing comparisons; it will greatly reduce bugs.