一、背景

斐波那契數的定義：

二、程式碼

C++語言版

int fib_iter(int a, int b, int count)
{
    if (count == 0)
        return b;
    else
        return fib_iter(a + b, a, count - 1);
}

int fib(int n)
{
    return fib_iter(1, 0, n);
}

Common Lisp語言版

(defun fib (n)
    (fib-iter 1
 
 0 n))
(defun fib-iter (a b count)
    (if (= count 0)
        b
        (fib-iter (+ a b) a (- count 1))))

更正

以上的程式碼部分是後面新增的（2015/12/02），以下部分當時寫串了，其實是關於階層的。不過不影響大家學習，思路是一樣的。我主要也是在展示遞迴和迭代的區別，以上的斐波那契的兩個程式碼就是迭代的。

二、分析

我引用兩張表，大家一看便懂。

1.遞迴

(factorial 6)
(* 6 (factorial 5))
(* 6 (* 5 (factorial 4)))
(*
 
 6 (* 5 (* 4 (factorial 3))))
(* 6 (* 5 (* 4 (* 3 (factorial 2)))))
(* 6 (* 5 (* 4 (* 3 (2 (factorial 1))))))
(* 6 (* 5 (* 4 (* 3 (* 2 1)))))
(* 6 (* 5 (* 4 （* 3 2))))
(* 6 (* 5 (* 4 6)))
(* 6 (* 5 24))
(* 6 120)
720

2.迭代

(factorial 6)
(factorial 1 1 6)
(factorial 1 2 6)
(factorial 2 3 6)
(factorial
 
 6 4 6)
(factorial 24 5 6)
(factorial 120 6 6)
(factorial 720 7 6)
720

遞迴的核心在於：不斷地回到起點。
迭代的核心在於：不斷地更新引數。

在下面的程式碼中，遞迴的核心是sum的運算，sum不斷的累乘，雖然運算的數值不同，但形式和意義一樣。

而迭代的核心是product和counter的不斷更新。如上表中，product就是factorial的前2個引數不斷的累乘更新成第一個引數；而第二個引數則是counter，其不斷的加1來更新自己。

product <- counter * product
counter < - counter + 1

三、程式碼

C語言版

#include <stdio.h>
#include <stdlib.h>

int factorialRecursive(int n);
int factorialIteration(int product, int counter, int max_count);

int main()
{
    int n;
    printf("Enter an integer: \n");
    scanf("%d",&n);

    printf("%d\n",factorialRecursive(n));
    printf("%d\n",factorialIteration(1,1,n));

    return 0;
}

int factorialRecursive(int n)
{
    int sum=1;
    if(n==1)
        sum*=1;
    else
        sum=n*factorialRecursive(n-1);
    return sum;
}

int factorialIteration(int product, int counter, int max_count)
{
    int sum=1;
    if(counter>max_count)
        sum*=product;
    else
        factorialIteration((counter*product),(counter+1),max_count);
}

C++語言版

#include <iostream>

using namespace std;

int factorialRecursive(int n);
int factorialIteration(int product, int counter, int max_count);

int main()
{
    int n;
    cout<<"Enter an integer:"<<endl;
    cin>>n;
    cout<<factorialRecursive(n)<<endl;
    cout<<factorialIteration(1,1,n)<<endl;

    return 0;
}

int factorialRecursive(int n)
{
    int sum=1;
    if(n==1)
        sum*=1;
    else
        sum=n*factorialRecursive(n-1);
    return sum;
}

int factorialIteration(int product, int counter, int max_count)
{
    int sum=1;
    if(counter>max_count)
        sum*=product;
    else
        factorialIteration((counter*product),(counter+1),max_count);
}

四、進階

Scheme語言版

(define (factorial n)
    (if (= n 1)
        1
        (* n (factorial (- n 1)))))

(define (factorial n)
    (fact-iter 1 1 n))
(define (fact-iter product counter max-count)
    (if (> counter max-count)
        product
        (fact-iter (* counter product)
                   (+ counter 1)
                   max-counter)))