递归可能会更昂贵，这取决于递归函数是否是尾部递归(最后一行是递归调用)。尾递归应该被编译器识别，并优化为迭代的对应部分(同时保持代码中简洁、清晰的实现)。

我将以最有意义的方式编写算法，并且对那些不得不在几个月或几年内维护代码的可怜的傻瓜(无论是你自己还是其他人)来说是最清楚的。如果你遇到了性能问题，那就分析你的代码，然后，只有在那之后，你才能通过迭代实现来进行优化。您可能需要研究一下内存和动态编程。

如果你只是在一个列表上迭代，那么当然，迭代出去。

其他几个答案提到了(深度优先)树遍历。这真的是一个很好的例子，因为这是对一个非常普通的数据结构所做的非常普通的事情。对于这个问题，递归是非常直观的。

点击这里查看“查找”方法: http://penguin.ewu.edu/cscd300/Topic/BSTintro/index.html

If the iterations are atomic and orders of magnitude more expensive than pushing a new stack frame and creating a new thread and you have multiple cores and your runtime environment can use all of them, then a recursive approach could yield a huge performance boost when combined with multithreading. If the average number of iterations is not predictable then it might be a good idea to use a thread pool which will control thread allocation and prevent your process from creating too many threads and hogging the system.

例如，在某些语言中，存在递归多线程归并排序实现。

但同样，多线程可以与循环而不是递归一起使用，因此这种组合的工作效果取决于更多因素，包括操作系统及其线程分配机制。

对于可以分解成多个更小的部分的问题，递归比迭代更好。

例如，要制作一个递归斐波那契算法，您将fib(n)分解为fib(n-1)和fib(n-2)，并计算这两部分。迭代只允许你一遍又一遍地重复一个函数。

然而，Fibonacci实际上是一个坏例子，我认为迭代实际上更有效。注意fib(n) = fib(n-1) + fib(n-2)和fib(n-1) = fib(n-2) + fib(n-3)。Fib (n-1)被计算了两次!

一个更好的例子是树的递归算法。分析父节点的问题可以分解为分析每个子节点的多个更小的问题。与斐波那契例子不同，较小的问题是相互独立的。

所以，对于那些可以分解成多个、更小、独立、相似问题的问题，递归比迭代更好。

我将通过“归纳”设计一个Haskell数据结构来回答你的问题，这是递归的一种“对偶”。然后我会展示这种对偶性是如何带来好的结果的。

我们为简单树引入一个类型:

data Tree a = Branch (Tree a) (Tree a)
            | Leaf a
            deriving (Eq)

我们可以把这个定义理解为“一棵树是一个分支(包含两棵树)或一个叶子(包含一个数据值)”。叶结点是一种最小的情况。如果树不是叶子，那么它一定是包含两棵树的复合树。这些是唯一的例子。

让我们做一个树:

example :: Tree Int
example = Branch (Leaf 1) 
                 (Branch (Leaf 2) 
                         (Leaf 3))

现在，让我们假设我们想给树中的每个值加1。我们可以通过调用:

addOne :: Tree Int -> Tree Int
addOne (Branch a b) = Branch (addOne a) (addOne b)
addOne (Leaf a)     = Leaf (a + 1)

首先，请注意这实际上是一个递归定义。它将数据构造函数Branch和Leaf作为case(因为Leaf是最小值的，这是唯一可能的case)，我们可以确定函数将终止。

用迭代风格编写addOne需要什么?循环进入任意数量的分支会是什么样子?

此外，这种递归通常可以用“函子”来分解。我们可以通过定义将树变成函子:

instance Functor Tree where fmap f (Leaf a)     = Leaf (f a)
                            fmap f (Branch a b) = Branch (fmap f a) (fmap f b)

和定义:

addOne' = fmap (+1)

我们可以提出其他递归方案，例如代数数据类型的变形(或折叠)。使用变形法，我们可以这样写:

addOne'' = cata go where
           go (Leaf a) = Leaf (a + 1)
           go (Branch a b) = Branch a b

递归的内存开销更大，因为每次递归调用通常都需要将一个内存地址推入堆栈，以便稍后程序可以返回到那个地址。

尽管如此，在许多情况下，递归比循环更自然、更可读——比如在处理树的时候。在这些情况下，我建议坚持使用递归。