Question

我必须实现这个方法：

public int GetAverage(Node root){
   //TODO implement
}

此方法应获取根树的所有节点的平均值。其中：

public interface Node {
   int getValue();

   List<Node> getNodes();
}

您对如何实施此方法有任何想法吗？

谢谢

我的尝试：

public static double value;
public static int count;
 public static double getAverage(Node root) {
 count++;
 value += root.getValue();
 for (Node node : root.getNodes()) {
 getAverage(node);
 }
 return value / count;
 }

但是如果没有方法之外的静态字段怎么做呢？

Answer 1

public static double getAverage(Node root) {
    Pair p = new Pair(0,0);
    algo(root, p);
    return ((double) p.element1) / ((double) p.element2);
}

private static void algo(Node root, Pair acc) {
    for(Node child : root.getNodes()) {
        algo(child, acc);
    }
    acc.sum += root.getValue();
    acc.nbNodes++;
}

With Pair定义如下：

public class Pair {

    public int sum;
    public int nbNodes;

    public Pair(int elt1, int elt2) {
        this.sum = elt1;
        this.nbNodes = elt2;
    }

}

Answer 2

只需遍历所有节点并记住所有值的计数和总和。然后计算平均值。这是用Java编写的一个例子。

public interface INode {
    int getValue();

    List<INode> getNodes();
}

public class Node implements INode {
    private List<INode> children = new ArrayList<INode>();
    private int value;

    @Override
    public int getValue() {
        return value;
    }

    @Override
    public List<INode> getNodes() {
        return children;
    }

    public static int getAverage(INode root) {
        if (root == null)
            return 0;

        Counter c = new Counter();
        calculateAverage(root, c);

        return c.sum / c.count;
    }

    class Counter {
        public int sum;
        public int count;
    }

    private static void calculateAverage(INode root, Counter counter) {
        if (root == null)
            return;

        counter.sum += root.getValue();
        counter.count++;

        // recursively through all children
        for (INode child : root.getNodes())
            calculateAverage(child, counter);
    }
}

从节点树中获取平均值

2 个答案: