迭代演算法是用計算機處理問題的一種基本方法。它利用計算機運算速度快、適合做重複性操做的特點，讓計算機對一組指令(或一定步驟)進行重複執行，在每次執行這組指令(或這些步驟)時，都從變數的原值推出它的一個新值。
　　利用迭代演算法處理問題，需要做好以下三個方面的工做：
　　一、確定迭代變數。在能夠用迭代演算法處理的問題中，至少具有一個間接或間接地不斷由舊值遞推出新值的變數，這個變數就是迭代變數。
　　二、建立迭代關係式。所謂迭代關係式，指如何從變數的前一個值推出其下一個值的公式(或關係)。迭代關係式的建立是處理迭代問題的關鍵，通常能夠使用遞推或倒推的方法來完成。
　　三、對迭代過程進行控制。在什麼時候結束迭代過程?這是編寫迭代程式必須考慮的問題。不能讓迭代過程無休止地重複執行下去。迭代過程的控制通常可分為兩種情況：一種是所需的迭代次數是個確定的值，能夠計算出來;另一種是所需的迭代次數無法確定。對於前一種情況，能夠建立一個固定次數的迴圈來實現對迭代過程的控制;對於後一種情況，需要進一步分析出用來結束迭代過程的條件。
來源：www.va1314.com/bc
　　例 1 ： 一個豢養場引進一隻剛出生的新品種兔子，這種兔子從出生的下一個月開始，每月重生一隻兔子，重生的兔子也如此繁殖。如果所有的兔子都不死去，問到第 12 個月時，該豢養場共有兔子多少隻?
　　分析： 這是一個典型的遞推問題。我們不妨假設第 1 個月時兔子的只數為 u 1 ，第 2 個月時兔子的只數為 u 2 ，第 3 個月時兔子的只數為 u 3 ，……根據題意，“這種兔子從出生的下一個月開始，每月重生一隻兔子”，則有
以下是引用片段：
u1=1，u2=u1+u1×1=2，u3=u2+u2×1=4，……
　　根據這個規律，能夠歸納出下面的遞推公式：
以下是引用片段：
　　un=un-1×2(n≥2)
　　對應 u n 和 u n - 1 ，定義兩個迭代變數 y 和 x ，可將上面的遞推公式轉換成如下迭代關係：
以下是引用片段：
　　y=x*2
　　x=y
　　讓計算機對這個迭代關係重複執行 11 次，就能夠算出第 12 個月時的兔子數。參考程式如下：
以下是引用片段：
　　cls
　　x=1
　　fori=2to12
　　y=x*2
　　x=y
　　nexti
　　printy
　　end
　　例 2 ： 阿米巴用簡單分裂的方式繁殖，它每分裂一次要用 3 分鐘。將若干個阿米巴放在一個盛滿營養參液的容器內， 45 分鐘後容器內充滿了阿米巴。已知容器最多能夠裝阿米巴 2 20 個。試問，開始的時候往容器內放了多少個阿米巴?請程式設計序算出。
　　分析： 根據題意，阿米巴每 3 分鐘分裂一次，那麼從開始的時候將阿米巴放入容器裡面，到 45 分鐘後充滿容器，需要分裂 45/3=15 次。而“容器最多能夠裝阿米巴 2 20 個”，即阿米巴分裂 15 次以後得到的個數是 2 20 。題目要求我們計算分裂之前的阿米巴數，不妨使用倒推的方法，從第 15 次分裂之後的 2 20 個，倒推出第 15 次分裂之前(即第 14 次分裂之後)的個數，再進一步倒推出第 13 次分裂之後、第 12 次分裂之後、……第 1 次分裂之前的個數。
　　設第 1 次分裂之前的個數為 x 0 、第 1 次分裂之後的個數為 x 1 、第 2 次分裂之後的個數為 x 2 、……第 15 次分裂之後的個數為 x 15 ，則有
以下是引用片段：
　　x14=x15/2、x13=x14/2、……xn-1=xn/2(n≥1)
　　因為第 15 次分裂之後的個數 x 15 是已知的，如果定義迭代變數為 x ，則能夠將上面的倒推公式轉換成如下的迭代公式：
　　x=x/2 ( x 的初值為第 15 次分裂之後的個數 2 20 )
　　讓這個迭代公式重複執行 15 次，就能夠倒推出第 1 次分裂之前的阿米巴個數。因為所需的迭代次數是個確定的值，我們能夠使用一個固定次數的迴圈來實現對迭代過程的控制。參考程式如下：
以下是引用片段：
　　cls
　　x=2^20
　　fori=1to15
　　x=x/2
　　nexti
　　printx
　　end
　　例 3 ： 驗證谷角猜想。日本數學家谷角靜夫在研究天然數時發覺了一個奇怪現象：對於任意一個天然數 n ，若 n 為偶數，則將其除以 2 ;若 n 為奇數，則將其乘以 3 ，然後再加 1 。如此經過有限次運算後，分能夠得到天然數 1 。人們把谷角靜夫的這一發覺叫做“谷角猜想”。
　　要求：編寫一個程式，由鍵盤輸入一個天然數 n ，把 n 經過有限次運算後，最終變成天然數 1 的全過程打印出來。
　　分析： 定義迭代變數為 n ，按照谷角猜想的內容，能夠得到兩種情況下的迭代關係式：當 n 為偶數時， n=n/2 ;當 n 為奇數時， n=n*3+1 。用 QBASIC 語言把它描述出來就是：
以下是引用片段：
　　ifn為偶數then
　　n=n/2
　　else
　　n=n*3+1
　　endif
　　這就是需要計算機重複執行的迭代過程。這個迭代過程需要重複執行多少次，才能使迭代變數 n 最終變成天然數 1 ，這是我們無法計算出來的。因而，還需進一步確定用來結束迭代過程的條件。仔細分析題目要求，不難看出，對任意給定的一個天然數 n ，只需經過有限次運算後，能夠得到天然數 1 ，就已經完成了驗證工做。因而，用來結束迭代過程的條件能夠定義為： n=1 。參考程式如下：
以下是引用片段：
　　cls
　　input"Pleaseinputn=";n
　　dountiln=1
　　ifnmod2=0then
　　rem如果n為偶數，則呼叫迭代公式n=n/2
　　n=n/2
　　print"—";n;
　　else
　　n=n*3+1
　　print"—";n;
　　endif
　　loop
　　end
　　迭代法
　　迭代法是用於求方程或方程組近似根的一種常用的演算法設想方法。設方程為f(x)=0，用某種數學方法匯出等價的形式x=g(x)，然後按以下步驟執行：
　　(1) 選一個方程的近似根，賦給變數x0;
　　(2) 將x0的值保存於變數x1，然後計算g(x1)，並將結果存於變數x0;
　　(3) 當x0與x1的差的絕對值還小於指定的精度要求時，重複步驟(2)的計算。
　　若方程有根，並且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x0就認為是方程的根。上述演算法用C程式的形式表示為：
　　【演算法】迭代法求方程的根
以下是引用片段：
　　{x0=初始近似根;
　　do{
　　x1=x0;
　　x0=g(x1);/*按特定的方程計算新的近似根*/
　　}while(fabs(x0-x1)>Epsilon);
　　printf(“方程的近似根是%f
”，x0);
　　}
　　迭代演算法也常用於求方程組的根，令
　　X=(x0，x1，…，xn-1)
　　設方程組為：
　　xi=gi(X) (I=0，1，…，n-1)
　　則求方程組根的迭代演算法可描述如下：
　　【演算法】迭代法求方程組的根
以下是引用片段：
　　{for(i=0;i
　　x=初始近似根;
　　do{
　　for(i=0;i
　　y=x;
　　for(i=0;i
　　x=gi(X);
　　for(delta=0.0,i=0;i
　　if(fabs(y-x)>delta)delta=fabs(y-x);
　　}while(delta>Epsilon);
　　for(i=0;i
　　printf(“變數x[%d]的近似根是%f”，I，x);
　　printf(“
”);
　　}
　　具體使用迭代法求根時應注意以下兩種可能發生的情況：
　　(1) 如果方程無解，演算法求出的近似根序列就不會收斂，迭代過程會變成死迴圈，因而在使用迭代演算法前應先調查方程能否有解，並在程式中對迭代的次數給予限制;
　　(2) 方程雖然有解，但迭代公式選擇不當，或迭代的初始近似根選擇不合理，也會導致迭代失敗。
============
　　遞迴
　　遞迴是設想和描述演算法的一種有力的工具，由於它在複雜演算法的描述中被經常採用，為此在進一步引見其他演算法設想方法之前先討論它。
　　能採用遞迴描述的演算法通常有這樣的特徵：為求解規模為N的問題，設法將它分解成規模較小的問題，然後從這些小問題的解方便地構造出大問題的解，並且這些規模較小的問題也能採用同樣的分解和分析方法，分解成規模更小的問題，並從這些更小問題的解構造出規模較大問題的解。特別地，當規模N=1時，能間接得解。
　　【問題】 編寫計算斐波那契(Fibonacci)數列的第n項函式fib(n)。
　　斐波那契數列為：0、1、1、2、3、……，即：
以下是引用片段：
　　fib(0)=0;
　　fib(1)=1;
　　fib(n)=fib(n-1)+fib(n-2)(當n>1時)。
　　寫成遞迴函式有：
以下是引用片段：
　　intfib(intn)
　　{if(n==0)return0;
　　if(n==1)return1;
　　if(n>1)returnfib(n-1)+fib(n-2);
　　}
　　遞迴演算法的執行過程分遞推和迴歸兩個階段。在遞推階段，把較複雜的問題(規模為n)的求解推到比原問題簡單一些的問題(規模小於n)的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是說，為計算fib(n)，必須先計算fib(n-1)和fib(n- 2)，而計算fib(n-1)和fib(n-2)，又必須先計算fib(n-3)和fib(n-4)。依次類推，直至計算fib(1)和fib(0)，分別能立即得到結果1和0。在遞推階段，必須要有終止遞迴的情況。例如在函式fib中，當n為1和0的情況。
　　在迴歸階段，當獲得最簡單情況的解後，逐級前往，依次得到稍複雜問題的解，例如得到fib(1)和fib(0)後，前往得到fib(2)的結果，……，在得到了fib(n-1)和fib(n-2)的結果後，前往得到fib(n)的結果。
　　在編寫遞迴函式時要注意，函式中的區域性變數和引數學問侷限於當前呼叫層，當遞推進入“簡單問題”層時，原來層次上的引數和區域性變數便被隱蔽起來。在一系列“簡單問題”層，它們各有本人的引數和區域性變數。
　　由於遞迴引起一系列的函式呼叫，並且可能會有一系列的重複計算，遞迴演算法的執行效率相對較低。當某個遞迴演算法能較方便地轉換成遞推演算法時，通常按遞推演算法編寫程式。例如上例計算斐波那契數列的第n項的函式fib(n)應採用遞推演算法，即從斐波那契數列的前兩項出發，逐次由前兩項計算出下一項，直至計算出要求的第n項。
　　【問題】 組合問題
　　問題描述：找出從天然數1、2、……、n中任取r個數的所有組合。例如n=5，r=3的所有組合為： (1)5、4、3 (2)5、4、2 (3)5、4、1
　　(4)5、3、2 (5)5、3、1 (6)5、2、1
　　(7)4、3、2 (8)4、3、1 (9)4、2、1
　　(10)3、2、1
　　分析所列的10個組合，能夠採用這樣的遞迴思想來考慮求組合函式的演算法。設函式為void comb(int m,int k)為找出從天然數1、2、……、m中任取k個數的所有組合。當組合的第一個數字選定時，其後的數字是從餘下的m-1個數中取k-1數的組合。這就將求m 個數中取k個數的組合問題轉化成求m-1個數中取k-1個數的組合問題。設函式引入工做陣列a[ ]存放求出的組合的數字，約定函式將確定的k個數字組合的第一個數字放在a[k]中，當一個組合求出後，才將a[ ]中的一個組合輸出。第一個數能夠是m、m-1、……、k，函式將確定組合的第一個數字放入陣列後，有兩種可能的選擇，因還未去頂組合的其餘元素，繼續遞迴去確定;或因已確定了組合的全部元素，輸出這個組合。細節見以下程式中的函式comb。
　　【程式】
以下是引用片段：
　　#include
　　#defineMAXN100
　　inta[MAXN];
　　voidcomb(intm,intk)
　　{inti,j;
　　for(i=m;i>=k;i--)
　　{a[k]=i;
　　if(k>1)
　　comb(i-1,k-1);
　　else
　　{for(j=a[0];j>0;j--)
　　printf(“%4d”,a[j]);
　　printf(“
”);
　　}
　　}
　　}
　　voidmain()
　　{a[0]=3;
　　comb(5,3);
============
　　【問題】 揹包問題
　　問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的分重量不超過指定的限制重量，但選中物品的價值之和最大。
　　設n 件物品的重量分別為w0、w1、…、wn-1，物品的價值分別為v0、v1、…、vn-1。採用遞迴尋找物品的選擇方案。設前面已有了多種選擇的方案，並保留了其中分價值最大的方案於陣列option[ ]，該方案的分價值存於變數maxv。當前正在調查新方案，其物品選擇情況保存於陣列cop[ ]。假定當前方案已考慮了前i-1件物品，現在要考慮第i件物品;當前方案已包含的物品的重量之和為tw;至此，若其餘物品都選擇是可能的話，本方案能達到的分價值的期望值為tv。演算法引入tv是當一旦當前方案的分價值的期望值也小於前面方案的分價值maxv時，繼續調查當前方案變成無意義的工做，應終止當前方案，立即去調查下一個方案。因為當方案的分價值不比maxv大時，該方案不會被再調查，這同時保證函式後找到的方案一定會比前面的方案更好。
　　對於第i件物品的選擇考慮有兩種可能：
　　(1) 考慮物品i被選擇，這種可能性僅當包含它不會超過方案分重量限制時才是可行的。選中後，繼續遞迴去考慮其餘物品的選擇。
　　(2) 考慮物品i不被選擇，這種可能性僅當不包含物品i也有可能會找到價值更大的方案的情況。
　　按以上思想寫出遞迴演算法如下：
以下是引用片段：
　　try(物品i，當前選擇已達到的重量和，本方案可能達到的分價值tv)
　　{/*考慮物品i包含在當前方案中的可能性*/
　　if(包含物品i是能夠接受的)
　　{將物品i包含在當前方案中;
　　if(i
　　try(i+1,tw+物品i的重量,tv);
　　else
　　/*又一個完整方案，因為它比前面的方案好，以它做為最佳方案*/
　　以當前方案做為臨時最佳方案儲存;
　　恢復物品i不包含狀態;
　　}
　　/*考慮物品i不包含在當前方案中的可能性*/
　　if(不包含物品i僅是可男考慮的)
　　if(i
　　try(i+1,tw,tv-物品i的價值);
　　else
　　/*又一個完整方案，因它比前面的方案好，以它做為最佳方案*/
　　以當前方案做為臨時最佳方案儲存;
　　}
　　為了理解上述演算法，特舉以下例項。設有4件物品，它們的重量和價值見表：
　　物品 0 1 2 3
　　重量 5 3 2 1
　　價值 4 4 3 1
　　並設限制重量為7。則按以上演算法，下圖表示找解過程。由圖知，一旦找到一個解，演算法就進一步找更好的佳。如能判定某個查詢分支不會找到更好的解，演算法不會在該分支繼續查詢，而是立即終止該分支，並去調查下一個分支。
　　按上述演算法編寫函式和程式如下：
　　【程式】
以下是引用片段：
　　#include
　　#defineN100
　　doublelimitW,totV,maxV;
　　intoption[N],cop[N];
　　struct{doubleweight;
　　doublevalue;
　　}a[N];
　　intn;
　　voidfind(inti,doubletw,doubletv)
　　{intk;
　　/*考慮物品i包含在當前方案中的可能性*/
　　if(tw+a.weight<=limitW)
　　{cop=1;
　　if(i
　　else
　　{for(k=0;k
　　option[k]=cop[k];
　　maxv=tv;
　　}
　　cop=0;
　　}
　　/*考慮物品i不包含在當前方案中的可能性*/
　　if(tv-a.value>maxV)
　　if(i
　　else
　　{for(k=0;k
　　option[k]=cop[k];
　　maxv=tv-a.value;
　　}
　　}
　　voidmain()
　　{intk;
　　doublew,v;
　　printf(“輸入物品種數
”);
　　scanf((“%d”,&n);
　　printf(“輸入各物品的重量和價值
”);
　　for(totv=0.0,k=0;k
　　{scanf(“%1f%1f”,&w,&v);
　　a[k].weight=w;
　　a[k].value=v;
　　totV+=V;
　　}
　　printf(“輸入限制重量
”);
　　scanf(“%1f”,&limitV);
　　maxv=0.0;
　　for(k=0;kfind(0,0.0,totV);
　　for(k=0;k
　　if(option[k])printf(“%4d”,k+1);
　　printf(“
分價值為%.2f
”,maxv);
============
　　做為對比，下面以同樣的解題思想，考慮非遞迴的程式解。為了提高找解速度，程式不是簡單地逐一生成所有候選解，而是從每個物品對候選解的影響來形成值得進一步考慮的候選解，一個候選解是通過依次調查每個物品形成的。對物品i的調查有這樣幾種情況：當該物品被包含在候選解中依舊滿腳解的分重量的限制，該物品被包含在候選解中是應該繼續考慮的;反之，該物品不應該包括在當前正在形成的候選解中。同樣地，僅當物品不被包括在候選解中，還是有可能找到比目前臨時最佳解更好的候選解時，才去考慮該物品不被包括在候選解中;反之，該物品不包括在當前候選解中的方案也不應繼續考慮。對於任一值得繼續考慮的方案，程式就去進一步考慮下一個物品。
　　【程式】
以下是引用片段：
　　#include
　　#defineN100
　　doublelimitW;
　　intcop[N];
　　structele{doubleweight;
　　doublevalue;
　　}a[N];
　　intk,n;
　　struct{int;
　　doubletw;
　　doubletv;
　　}twv[N];
　　voidnext(inti,doubletw,doubletv)
　　{twv.=1;
　　twv.tw=tw;
　　twv.tv=tv;
　　}
　　doublefind(structele*a,intn)
　　{inti,k,f;
　　doublemaxv,tw,tv,totv;
　　maxv=0;
　　for(totv=0.0,k=0;k
　　totv+=a[k].value;
　　next(0,0.0,totv);
　　i=0;
　　While(i>=0)
　　{f=twv.;
　　tw=twv.tw;
　　tv=twv.tv;
　　switch(f)
　　{case1:twv.++;
　　if(tw+a.weight<=limitW)
　　if(i
　　{next(i+1,tw+a.weight,tv);
　　i++;
　　}
　　else
　　{maxv=tv;
　　for(k=0;k
　　cop[k]=twv[k].!=0;
　　}
　　break;
　　case0:i--;
　　break;
　　default:twv.=0;
　　if(tv-a.value>maxv)
　　if(i
　　{next(i+1,tw,tv-a.value);
　　i++;
　　}
　　else
　　{maxv=tv-a.value;
　　for(k=0;k
　　cop[k]=twv[k].!=0;
　　}
　　break;
　　}
　　}
　　returnmaxv;
　　}
　　voidmain()
　　{doublemaxv;
　　printf(“輸入物品種數
”);
　　scanf((“%d”,&n);
　　printf(“輸入限制重量
”);
　　scanf(“%1f”,&limitW);
　　printf(“輸入各物品的重量和價值
”);
　　for(k=0;k
　　scanf(“%1f%1f”,&a[k].weight,&a[k].value);
　　maxv=find(a,n);
　　printf(“
選中的物品為
”);
　　for(k=0;k
　　if(option[k])printf(“%4d”,k+1);
　　printf(“
分價值為%.2f
”,maxv);
　　}
　　遞迴的基本概念和特點

　　程式呼叫本身的程式設計技巧稱為遞迴( recursion)。
　　一個過程或函式在其定義或說明中又間接或間接呼叫本身的一種方法，它通常把一個大型複雜的問題層層轉化為一個與原問題類似的規模較小的問題來求解，遞迴策略只需少量的程式就可描述出解題過程所需要的多次重複計算，大大地減少了程式的程式碼量。遞迴的能力在於用有限的語句來定義物件的無限集合。用遞迴思想寫出的程式往往十分簡潔易懂。
　　一般來說，遞迴需要有邊界條件、遞迴前進段和遞迴前往段。當邊界條件不滿腳時，遞迴前進;當邊界條件滿腳時，遞迴前往。
　　注意：
　　(1) 遞迴就是在過程或函式裡呼叫本身;
　　2) 在使用遞增歸策略時，必須有一個明確的遞迴結束條件，稱為遞迴出口。

迭代（iterative）和遞迴(recursive)可以相互轉化。常常要求把遞迴轉化為迭代。因為遞迴得耗費大量時間。

例：求最大公因數程式：(以下程式是偽碼描述）
遞迴法：
procedure GCD(a,b)//假設a>b>=0//
   if b==0 then return(a)
          else return(GCD(b,a mod b))//mod運算為模運算，在此式中意為求a與b的模//
   endif
end GCD

轉化為迭代：
procedure GCD2(a,b)
   while b!=0 do
      t=b; b=(a mod b); a=t;
   repeat
   return(a)
end GCD2

迭代的另外一個example：
 for(;;)
 {
   a[2] = a[0] + a[1];
   a[0] = a[1];
   a[1] = a[2];
 }
就是反覆套用一個公式

一個討論:

    看過這樣一道題，問，“程式結構化設計的三種基礎結構，順序、選擇、迴圈是不是必須的？”當然，你知道這樣一個論斷，只要有這三種就足夠了；但是能不能更少呢？答案是“可以”，原因就是遞迴能取代迴圈的作用，例如下面的對一個數組裡面元素求和的函式：

float rsum (float a[], const int n)
{
if (n <= 0) return 0;
else return rsum(a, n – 1) + a[n – 1];
}

實際上就是：

sum = 0;
for (int i = 0; i < n; i++) sum += a[i];

　　但實際的情況是，任何的一種語言裡面都有迴圈結構，但不是任何的語言都支援遞迴；套用一句話，遞迴是萬能的，但沒有遞迴不是萬萬不能的。然而，我看到現在的某些人，不管什麼問題都要遞迴，明明迴圈是第一個想到的方法，偏偏費盡腦筋去尋找遞迴演算法。

    經常的看到“遞迴演算法”、“非遞迴演算法”，這種提法沒有語義上的問題，並且我自己也這樣用——遞迴的演算法。但這也正說明了，遞迴不是演算法，他是一種思想，正是因為某個演算法的指導思想是遞迴的，所以才被稱為遞迴演算法；而一個有遞迴演算法的問題，當你不使用遞迴作為指導思想，這樣得到的演算法就是非遞迴演算法。——而對於迴圈能處理的問題，都有遞迴解法，在這個意義上說，迴圈演算法都可以稱為非遞迴演算法。

    我在這咬文嚼字沒什麼別的意思，只是想讓大家知道，能寫出什麼樣的演算法，關鍵是看你編寫演算法時的指導思想。如果一開始就想到了迴圈、迭代的方法，你再費心耗神去找什麼遞迴演算法——即使找到了一種看似“簡潔”的演算法，由於他的低效實際上還是廢物——你還在做這種無用功幹什麼？典型的學究陋習。如果你僅僅想到了遞迴的方法，現在你想用棧來消解掉遞迴，你做的工作僅僅是把系統做的事自己做了，你又能把效率提高多少？盲目的迷信消解遞迴就一定能提高效率是無根據的——你做的工作的方法如果不得當的話，甚至還不如系統原來的做法。

　　從學排列組合那天開始，我所知道的階乘就是這個樣子n! = 1×2×……n。如果讓我來寫階乘的演算法，我也只會想到從1乘到n。再如，斐波那契數列，如果有人用自然語言描述的話，一定是這樣的，開始兩項是0、1，以後的每項都是前面兩項的和。所以讓我寫也只會得到“儲存前兩項，然後相加得到結果”的迭代解法。——現在只要是講到遞迴幾乎就有他們的登場，美其名曰：“定義是遞迴的，所以我們寫遞迴演算法”。我想問的是，定義的遞迴抽象是從哪裡來的？顯然階乘的定義是從一個迴圈過程抽象來的，斐波那契數列的定義是個迭代的抽象。於是，我們先從一個本不是遞迴的事實抽象出一個遞迴的定義，然後我們說，“因為問題的定義是遞迴的，因此我們很容易寫出遞迴演算法”，接著說，“我們也能將這個遞迴演算法轉化為迴圈、迭代演算法”，給人的感覺就像是1÷3＝0.33……，0.33……×3＝0.99……，然後我們花了好大的心智才明白1＝0.99……。

　　還是有那麼些人樂此不疲，是凡講到遞迴就要提到這兩個，結果，沒有一個學生看到階乘那樣定義沒有疑問的，沒有一個對於那個遞迴的階乘函式抱有欽佩之情的——瞎折騰什麼呢？所以，如果要講遞迴，就要一個令人信服的例子，而這個例子非漢諾塔莫屬。