that’s a common misconception, and often indicates an ignorance of asymptotic notation / algorithm analysis. recursive solutions, just like iterative solutions, are neither inherently efficient nor inherently inefficient. The real danger with recursion is duplication of work.

Consider this naive implementation of generating an array of the first n fibonacci numbers:


def nfib(n)
seq = []
(1..n).each do |nth|
seq << nfibr(nth)
end
seq
end

def nfibr(nth)
if nth <= 2
1
else
nfibr(nth-1) + nfibr(nth-2)
end
end


notice that nfibr(4) would first call nfibr(3) + nfibr(2), and nfibr(3) would call nfibr(2) + nfibr(1) – the problem being that nfibr(2) was already calculated from the nfibr(3) call. it’s not hard to see that this method runs on the order of O(n^n).

however, a linear recursive solution (that builds fibonacci numbers from the bottom up) is trivial to conceive:


def fib(times)
fibr([1,1], 1, 1, times-2)
end

def fibr(seq, n_min_2, n_min_1, times)
if times > 0
n = n_min_2 + n_min_1
seq << n
fibr(seq, n_min_1, n, times-1)
else
seq
end
end


Whereas nfib(40) will take something on the order of several millennium to compute, fib(40) returns instantly, since it’s running in O(n) time.

This is, of course, super ugly