TreeSet没有正确排序

Question

I need to keep a sorted list of nodes, starting from the first, which then gets us all the adjacent nodes. The first node, and all other nodes carry a seed value used to determine which node will be used next depending on the lowest seed value, once a node is used to get adjacent nodes it is marked as used, so it doesn't get expanded again even if it has the lowest seed.

My issue is that the used values seem to creep up to the top and halt the search entirely because after 3 iterations the top node will have been a used node that keeps expanding. here's my TreeSet code as well as an example of the numbers creeping up

private static TreeSet<Node> nodelist = new TreeSet<Node>(
        new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                if (o1.totalVal > o2.totalVal) {
                    if (o2.isValid)
                        return +1;
                    else
                        return -1;
                } else if (o1.totalVal < o2.totalVal)
                    return -1;
                else
                    return 0;
            }
        });

here's the iterations of TreeSet after every set of inserts, everything after the fourth is identical to the fourth, as no new elements can ever read.

first set
true, 37.24913792078372
true, 38.12142238654117
true, 38.57602191449718
true, 38.57658845611187
true, 39.427369179869515
false, 36.6742416417845

second set
true, 37.84689665786984
false, 37.24913792078372
true, 38.12142238654117
true, 38.57602191449718
true, 38.57658845611187
true, 39.18376618407356
true, 39.427369179869515
false, 36.6742416417845

third set
true, 38.4682957019364
false, 37.84689665786984
false, 37.24913792078372
true, 38.12142238654117
true, 38.57602191449718
true, 38.57658845611187
true, 39.18376618407356
true, 39.427369179869515
true, 39.814763008775685
false, 36.6742416417845

fourth set
false, 38.4682957019364
false, 37.84689665786984
false, 37.24913792078372
true, 38.12142238654117
true, 38.57602191449718
true, 38.57658845611187
true, 38.590228543643214
true, 39.11409973215888
true, 39.18376618407356
true, 39.427369179869515
true, 39.814763008775685
true, 40.469726317012984
false, 36.6742416417845

so far I reasoned that it has to do with the tree structure, but can't really understand why it's doing this. I have tried using a similar approach with a priorityqueue, and sorted arraylist implementation and both did the same, albeit they would get about 2 more iterations before grinding to a halt.

any help?

Answer 1

The contract for Comparator requires that comparison is stable - ie if compare(a,b) < 0 then compare(b,a) > 0 etc. It looks like you are not doing that. I suspect you should test o1.isvalid in your else block somehow but there isn't enough code to be sure.

You may be better off with something more like:

private static TreeSet<Node> nodelist = new TreeSet<Node>(
        new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                if ( o1.isValid == o2.isValid ) {
                    // Both valid/invalid - it's the totals that control the order.
                    return o1.totalVal - o2.totalVal;
                } else {
                    // One valid, one not, move all invalids to one end.
                    return o1.isValid ? -1 : 1;
                }
            }
        });

Answer 2

You should probably avoid trying to write your own compare method, because they can be hard to reason about. With Google Guava :

private static final TreeSet<Node> treeSet = new TreeSet<>(nodeOrdering);

Where nodeOrdering is defined as:

Comparator<Node> nodeOrdering = Ordering.natural()
    .onResultOf(isValidFunction)
    .compound(Ordering.natural().onResultOf(totalValueFunction));

isValidFunction is defined like this:

Function<Node, Boolean> isValidFunction = new Function<>() {
  @Override public Boolean apply(Node input) { return input.isValid; }
};

totalValueFunction is defined similarly:

Function<Node, Double> totalValueFunction = new Function<>() {
  @Override public Double apply(Node input) { return input.totalVal; }
};