泛化二叉树遍历的动作？

Question

我正在尝试找到一种方法，我可以采用二叉树类并遍历其节点，
在每个节点上执行 X 数量的内联操作，而无需重写相同的操作一遍又一遍的遍历代码。
我想如果 Java 允许函数指针，这对我来说会更容易弄清楚...

基本上，我需要的是以下内容：

public class BinaryTreeNode {

    //...

    public void inOrderTraversalFrom(BinaryTreeNode node, /* ??? */ actions) {
        if(node.left != null)
            inOrderTraversalFrom(node.left);

        /* do something with "actions" here */

        if(node.right != null)
            inOrderTraversalFrom(node.right);
    }
}

... actions 可以允许执行不同的方法，采用不同的参数集，具体取决于要在每个节点上执行的操作类型.

一个很好的例子是可以传递一个旨在绘制这些节点的类，接受一个 Graphics 对象作为它的参数之一，而一个旨在执行一些其他一系列动作的类不会需要一个 Graphics 对象作为参数，而是一组完全不同的参数。

这怎么可能？执行此操作的最动态方式是什么？

Answer 1

我找到了一个解决方案，虽然它可能不是最好的...

BinaryTreeNode.java：

public void inOrderTraversalFrom(BinaryTreeNode rootNode, BinaryTreeActions actions)
{
    if(rootNode.left != null)
        inOrderTraversalFrom(rootNode.left, actions);

    if(actions != null)
        actions.Perform(rootNode);

    if(rootNode.right != null)
        inOrderTraversalFrom(rootNode.right, actions);
}

BinaryTreeActions.java：

public interface BinaryTreeActions {
    public void Perform(BinaryTreeNode node);
}

BinaryTreeGraphicsActions.java：

public interface BinaryTreeGraphicsActions extends BinaryTreeActions {
    void DrawNode(BinaryTreeNode node, Graphics g);
}

BinaryTreeView.java：

private void DrawNodes(final Graphics graphics)
{
    BinaryTreeNode node = root;
    root.inOrderTraversalFrom(node, new BinaryTreeGraphicsActions() {
        @Override
        public void DrawNode(BinaryTreeNode node, Graphics g) {
            // draw the node
        }

        @Override
        public void Perform(BinaryTreeNode node) {
            DrawNode(node, graphics);
        }
    });
}

...并且任何时候您需要一组新的操作，您都可以为它创建一个新界面，遵循BinaryTreeGraphicsActions 和BinaryTreeView 中的相同想法。这允许您执行任何一组操作，具体取决于您为它们设计的界面。

---

#EDIT : 在发现不需要BinaryTreeGraphicsActions 后，我接受了类似的答案，因为您可以像这样简单地使用 BinaryTreeActions 来执行相同的内联代码：

private void DrawNodes(final Graphics graphics)
{
    BinaryTreeNode node = root;
    root.inOrderTraversalFrom(node, new BinaryTreeActions() {
        @Override
        public void Perform(BinaryTreeNode node) {
            /* draw the node, using any local vars (providing they are final) */
        }
    });
}

Answer 2

以下解决方案与此处建议的其他解决方案非常相似。但是，如果您喜欢这些东西，请使用一些设计模式糖霜。

这个想法不仅要隔离动作，还要隔离遍历。这可以通过以下 2 个抽象来完成。

• BinaryTreeNodeTraversalStrategy
• BinaryTreeNodeVisitor

public interface Visitable<T extends Visitor> {

  public void accept(T visitor);
}

public interface Visitor<T extends Visitable> {

  public void visit(T visitable);
}

public interface BinaryTreeNode implements Visitable<BinaryTreeNodeVisitor> {

  public void accept(BinaryTreeNodeVisitor visitor);
}

public interface BinaryTreeNodeVisitor implements Visitor<BinaryTreeNode> {

  public void visit(BinaryTreeNode visitable);
}

public interface BinaryTreeNodeTraversalStrategy {

  public void traverse(BinaryTreeNode root);
}

Answer 3

一种方法是：

action 可以是接收Node 并对其应用Action 的类的实例：

public interface Action{
  public void apply(Node node){
  // To be done in the classes that will implement 
  // this interface. If it's a graphic-display of the nodes, the apply 
  // method will call draw(node.value), for example
  }
}

行：

/* do something with "actions" here */

应该替换为

action.apply(node);

方法的签名应该改为：

public void inOrderTraversalFrom(BinaryTreeNode node, Action action)

递归调用应该是：

inOrderTraversalFrom(node.left, action);