Question

有一些递归算法可以很快填满堆栈。一种解决方案是使堆栈显式化，从而将算法转换为迭代算法。

但我注意到有明确的堆栈会使算法慢一些（这可能不会让我感到惊讶）。是否有任何通用的C ++指南可以更快地制作显式堆栈？它们是否有可能比原始的递归算法运行得更快？

编辑：我编写了一个显式堆栈的函数如下。我还粘贴了迭代代码。出于某种原因，使用std::vector而不是std::stack更快，这是非常令人惊讶的。

// A(m, n) = n + 1                 if m = 0
//         = A(m - 1, 1)           if m > 0 and n = 0
//         = A(m - 1, A(m, n - 1)) if m, n > 0


int A(int m, int n, long& iterations,
    std::vector<std::pair<int, int> >& stack)
{
    stack.push_back(std::make_pair(m, n));
    long result = 0;
    bool result_available = false;

    while (stack.size() > 0)
    {
        iterations += 1;

        if (result_available) {
            stack.back().second = result;
            result_available = false;
        }

        m = stack.back().first;
        n = stack.back().second;
        stack.pop_back();

        if (m == 0) {
            result = n + 1;
            result_available = true;
        }
        else if (m > 0 && n == 0) {
            stack.push_back(std::make_pair(m - 1, 1));
        }
        else if (m > 0 && n > 0) {
            stack.push_back(std::make_pair(m - 1, n));
            stack.push_back(std::make_pair(m, n - 1));
        }
    }

    return result;
}

Answer 1

对于最近版本的gcc：-fsplit-stack的幸运用户，还有另一种解决方案。

拆分堆栈并不是一个新想法，Lisp当时有它...它只是意味着编译器创建了一个程序，它不需要预先设置其完整堆栈，而是可以根据需要扩展它。因此，堆栈变得不连续。

当然，这需要所有（或大多数）库适应这种新的堆栈机制（因此需要重新编译整个软件堆栈）。无视它的库可能仍会创建堆栈溢出异常，如果您避免在这些库中使用深度递归函数，这不是一个问题。

使用这种机制，只要你有可用的内存，堆栈就会增长以容纳你的程序。

Answer 2

尝试尽可能从堆中分配内存。这很慢。
消除尾递归 - 对于它们，您不需要递归调用。它看起来不像递归解决方案那么优雅，但速度更快。有关如何完成此操作的示例，请搜索Fibonacci实现。有2个递归变体和一个非递归变体。
使用显式堆栈作为函数调用＆amp;通过堆栈传递参数是一些最快的汇编程序指令，因为它们经常被使用。

更快地制作显式堆栈算法

2 个答案: