java - 循环树

因此，我想知道哪种最佳方法是根据员工与雇主之间的关系来创建结构，例如，可能存在周期

id: 1 boss: 2
id: 2 boss: 3
id: 3 boss: 1
Id: 4 boss: 1
id: 10 boss: 11
id: 11 boss: null

然后能够找到ID为1的老板

我一直在考虑具有反向关系的简单树，但是如何为周期做准备？

public class Tree<T> {
 private Node<T> root;

 public Tree(T rootData) {
    root = new Node<T>();
    root.data = rootData;
    root.employees = new ArrayList<Node<T>>();
 }

 public static class Node<T> {
    private T data;
    private List<Node<T>> employees ;
 }
}

最佳答案

我已经用设计模式解决了这个问题。

我使用了两种模式，因此模式composite和模式visitor

我用这段代码写结构

所有节点的接口

public interface INode{
    //for appli visitor
    public void accept(IVisitor visitor);
}

用于实现您的叶子节点

public class INodeLeaf implements INode{

    public String getFoo();
}

为了为中介节点实现抽象类，可以拥有更多类型的节点中介

    public abstract class AbstractNode implements INode{

    private INode left;
    private INode right;

    public AbstractNode(INode left, INode right) {
        this.left = left;
        this.right = right;
    }

    public INode getLeft() {
        return left;
    }

    public INode getRight() {
        return right;
    }

}

您必须至少是AbstractNode中的一个具体节点

对于访问结构，您可以按照以下方式实现模式访问者

public interface IVisitor {

    void visitNodeLeaf(NodeLeaf node);

    void visitYorConcreateNode(YourConcreateNode node);

}

一个实现可以是

public class VisitorFoo implements IVisitor {

    private String foo;

    @Override
    public void visitNodeLeaf(INodeFoglia node) {
        foo += node.getFoo();
    }

    @Override
    public void visitYorConcreateNode(NodeDivisione node) {
        node.getLeft().accept(this);
        node.getRight().accept(this);
    }
}

关于你的问题

对于您的示例，Tree结构是我的一般实现，您可能需要List<INode>和访问者内部的方法visitYorConcreateNode(..)应该访问列表，但实现不会改变。

对于结构复杂的操作
对于结构上的复杂操作，我认为最好也使用修补程序Strategy。

按照此

public class StrategyFoo implement IStrategy{

   private IVisitor setTheVisitor;

//other
   public void runOperation(){//do nothind for moment}
}

关于java - 循环树，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/59125669/