Question

我需要保留一个排序的节点列表，从第一个节点开始，然后获取所有相邻节点。第一个节点和所有其他节点携带一个种子值，用于确定接下来将使用哪个节点，具体取决于最低种子值，一旦使用一个节点获取它被标记为已使用的相邻节点，因此它不会被扩展即使它的种子最低也是如此。

我的问题是使用的值似乎爬到顶端并完全停止搜索，因为在3次迭代后，顶级节点将是一个不断扩展的已使用节点。这是我的TreeSet代码以及爬行数字的示例

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;
            }
        });

这是每组插入后TreeSet的迭代，第四组之后的所有内容都与第四组相同，因为没有新元素可以读取。

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

到目前为止，我推断它与树结构有关，但不能真正理解它为什么这样做。我尝试过使用类似的方法和一个优先级，并对arraylist实现进行排序，两者都做了同样的事情，尽管他们在停止之前会再进行2次迭代。

任何帮助？

Answer 1

Comparator的合同要求比较稳定 - 即compare(a,b) < 0然后compare(b,a) > 0等。看起来你没有这样做。我怀疑你应该以某种方式测试你的其他块中的o1.isvalid，但是没有足够的代码来确定。

你可能会更喜欢更喜欢的东西：

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

你应该避免尝试编写自己的比较方法，因为它们很难推理。使用Google Guava：

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

nodeOrdering定义为：

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

isValidFunction的定义如下：

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

totalValueFunction的定义类似：

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

TreeSet没有正确排序

2 个答案: