树结构算法

Question

我的程序有问题。例如，我有 5 个字段。这些字段的值是 true 或 false。 False 字段可以被删除。所以我想找到这些字段的所有可能组合。

我的想法是：例如，我有一个包含这些字段的 XML

• 字段 1，正确
• 字段 2，正确
• 字段3，错误
• 字段 4，错误
• 字段5，错误

结果应该是：

{Field1, Field2, Field3, Field4, Field5}
{Field1, Field2,       , Field4, Field5}
{Field1, Field2,       ,       , Field5}
{Field1, Field2,       ,       ,       }
{Field1, Field2, Field3,       , Field5}
{Field1, Field2, Field3,       ,       }
{Field1, Field2, Field3, Field4,       }
{Field1, Field2,       , Field4,       }

8 种组合。

我的想法是，它可以用树结构来解决。我将检查当前字段是“真”还是“假”。如果“真”那么我将向前移动一个字段。如果该字段为“false”，我将复制 XML 并在列表中添加一次与当前“false”字段并没有它的一次。 就像这里的图片一样。

public List<List<Fieldmatrix>> permut(List<Fieldmatrix> matrix, int j) {

    while (felderLaenge != j) {

        if (!matrix.get(j).isTrue()) {
            tmpL = iterateLeft(matrix, j);

            tmpR = iterateRight(matrix, j);


        } else {
            tmpL = iterateRight(matrix, j);

        }
        j++;
        return permut(tmpL, j);
    }
    return sammlung;
}

iterateLeft 表示删除，iterateRight 表示不删除。

我无法实现重复功能。所以我只有 4 个 Xmls 结果：
{1,2,3,4,5}, {1,2,4,5}, {1,2,3,5}, {1,2,3,4}

有人可以帮我吗？

---

首先感谢您的支持。

Fieldmatrix-Class 看起来像：

public class Fieldmatrix {

private String feld;
private boolean pflicht;

public Fieldmatrix(String feld, boolean pflicht){
    this.feld = feld;
    this.pflicht = pflicht;
}

public String getFeld() {
    return feld;
}

public void setFeld(String feld) {
    this.feld = feld;
}

public boolean isPflicht() {
    return pflicht;
}

public void setPflicht(boolean pflicht) {
    this.pflicht = pflicht;
}

}

如何更改这部分“prefixWithField.add(?)” 您可以使用 String 处理它，这是因为 List 也是 String 类型。 但我和 List 一起工作 .

iterateRight() 仅使用控制台打印。 ieterateLeft() 删除当前字段并使用控制台打印。

Answer 1

问题

有多个问题：

• 如果您当前的树节点有两个子节点，您必须下降到两个子节点，而不仅仅是左边的节点。
• 最后，您返回了sammlung（英语。collection），但从未添加任何元素（至少在提供的代码中没有）。
• while 循环与递归相结合似乎有些奇怪。但是如果不看iterateLeft 和iterateRight，我就不能说太多了。

实施

实现该功能的快速方法如下。 为简单起见，Fieldmatrix 类已替换为 String。

public static List<List<String>> combine(List<String> fields) {
    return combine(fields, 0, new ArrayList<>());
}

public static List<List<String>> combine(List<String> fields,
                                         int start, List<String> prefix) {
    List<List<String>> combinations = new ArrayList<>();
    if (start >= fields.size()) {
        combinations.add(prefix);
        return combinations;
    }
    String field = fields.get(start);
    if (field.contains("false")) {
        combinations.addAll(combine(fields, start + 1, prefix));
    }
    List<String> prefixWithField = new ArrayList<>(prefix);
    prefixWithField.add(field);
    combinations.addAll(combine(fields, start + 1, prefixWithField));
    return combinations;
}

这种实现不是很有效。很多中间结果被一遍又一遍地复制。

示例

List<String> fields = new ArrayList<>();
fields.add("1:true");
fields.add("2:true");
fields.add("3:false");
fields.add("4:false");
fields.add("5:false");
combine(fields).forEach(c -> System.out.println(c));

打印

[1：真，2：真] [1：真，2：真，5：假] [1：真，2：真，4：假] [1：真，2：真，4：假，5：假] [1：真，2：真，3：假] [1：真，2：真，3：假，5：假] [1：真，2：真，3：假，4：假] [1：真，2：真，3：假，4：假，5：假]