为什么这个递归函数比迭代函数快 3 倍？

Question

我有一个简单的递归函数，可以构造一定深度的二叉树。

我认为带有 DFS 堆栈的迭代版本会达到类似的性能，但速度却惊人地慢了 3 倍！

更准确地说，在我的机器上，深度为 15 的递归版本大约需要 330_000 ns，而带有堆栈的迭代版本需要大约 950_000 ns。

能否将令人惊讶的性能归因于优越的缓存局部性（这对于递归函数来说显然更好）。

我用于性能基准测试的代码：

class Main {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        long runs;
        Tree t = null;
        for(runs=0; (System.nanoTime() - startTime)< 3_000_000_000L ; runs++) {
            t = createTree3(15);
        }
        System.out.println((System.nanoTime() - startTime) / runs + " ns/call");
    }

    static Tree createTree(int depth) {
        Tree t = new Tree();
        createTreeHlp(t, depth);
        return t;
    }

    static void createTreeHlp(Tree tree, int depth) {
        if (depth == 0)
            tree.init(0, null, null);
        else {
            tree.init(depth, new Tree(), new Tree());
            createTreeHlp(tree.leftChild, depth -1);
            createTreeHlp(tree.rghtChild, depth -1);
        }
    }


    static Tree createTree3(int depth_) {
        TreeStack stack = new TreeStack();
        Tree result = new Tree();
        stack.put(result, depth_);
        while (!stack.isEmpty()) {
            int depth = stack.depth[stack.stack][stack.index];
            Tree tree = stack.tree[stack.stack][stack.index];
            stack.dec();
            if (depth == 0)
                tree.init(0, null, null);
            else {
                tree.init(depth, new Tree(), new Tree());
                stack.put(tree.leftChild, depth -1);
                stack.put(tree.rghtChild, depth -1);
            }
        }
        return result;
    }
}

class Tree {
    int payload;
    Tree leftChild;
    Tree rghtChild;

    public Tree init(int payload, Tree leftChild, Tree rghtChild) {
        this.leftChild = leftChild;
        this.rghtChild = rghtChild;
        this.payload = payload;
        return this;
    }

    @Override
    public String toString() {
        return "Tree(" +payload+", "+ leftChild + ", " + rghtChild + ")";
    }
}
class TreeStack {

    Tree[][] tree;
    int[][] depth;

    int stack =  1;
    int index = -1;

    TreeStack() {
        this.tree = new Tree[100][];
        this.depth = new int[100][];

        alloc(100_000);
        --stack;
        alloc(0);
    }

    boolean isEmpty() {
        return index == -1;
    }

    void alloc(int size) {
        tree[stack] = new Tree[size];
        depth[stack] = new int[size];
    }

    void inc() {
        if (tree[stack].length == ++index) {
            if (tree[++stack] == null) alloc(2 * index);
            index = 0;
        }
    }
    void dec() {
        if (--index == -1)
            index = tree[--stack].length - 1;
    }

    void put(Tree tree, int depth) {
        inc();
        this.tree[stack][index] = tree;
        this.depth[stack][index] = depth;
    }
}

Answer 1

简答：因为你是这样编码的。

长答案：您创建一个堆栈，将内容放入其中，从中获取内容，并且非常复杂。让我们简单地为这种情况做。您想要一个具有一定深度的树，其中包含所有子级，值是深度，您首先想要最深的级别。这是一个简单的方法：

static Tree createTree3(int depth_) {
    Tree[] arr = new Tree[1 << depth_];

    int count = 1 << depth_;
    for (int i=0; i<count; i++)
        arr[i] = new Tree().init(0, null, null);

    int d = 1;
    count >>= 1;
    while (count > 0)
    {
        for (int i=0; i<count; i++)
        {
            Tree t = new Tree().init(d, arr[i * 2], arr[i * 2 + 1]);
            arr[i] = t;
        }
        count >>= 1;
        d++;
    }

  return arr[0];
}

它首先创建最低级别的节点，其中有 2^depth 的。然后它创建下一级节点并添加子节点。然后是下一个和下一个。没有堆栈，没有递归，只是简单的循环。

我通过运行 20000 次到深度 14 来对它进行基准测试，因此不需要花时间或其他任何东西，只需创建树即可。我的 i7 笔记本电脑上的结果：

您的递归需要 ~187µs/tree
我的迭代需要 ~177µs/tree

如果我运行深度 15，那么它是 311 与 340。

时间会发生变化，因为它检查的不是 CPU 时间而是系统时间，这取决于 JITter 的处理方式是否不同等等。

但简而言之：在这种情况下，即使进行了这个简单的更改，迭代也可以轻松实现与递归一样快，我相信还有更智能的方法。