遞歸函數具有很好的可讀性和可維護性，但是大部分情況下程序效率不如非遞歸函數，所以在程序設計中一般喜歡先用遞歸解決問題，在保證方法正確的前提下再轉換為非遞歸函數以提高效率。
函數調用時，需要在棧中分配新的幀，將返回地址，調用參數和局部變量入棧。所以遞歸調用越深，占用的棧空間越多。如果層數過深，肯定會導致棧溢出，這也是消除遞歸的必要性之一。遞歸函數又可以分為尾遞歸和非尾遞歸函數，前者往往具有很好的優化效率，下面我們分別加以討論。
尾遞歸函數
尾遞歸函數是指函數的最后一個動作是調用函數本身的遞歸函數，是遞歸的一種特殊情形。尾遞歸具有兩個主要的特征：
1. 調用自身函數(Self-called)；
2. 計算僅占用常量棧空間(Stack Space)。
為什么尾遞歸可以做到常量棧空間，我們用著名的fibonacci數列作為例子來說明。
fibonacci數列實現方法一般是這樣的，
int FibonacciRecur(int n) { if (0==n) return 0; if (1==n) return 1; return FibonacciRecur(n-1)+FibonacciRecur(n-2); }
不過需要注意的是這種實現方法並不是尾遞歸，因為尾遞歸的最后一個動作必須是調用自身，這里最后的動作是加法運算，所以我們要修改一下，
int FibonacciTailRecur(int n, int acc1, int acc2) { if (0==n) return acc1; return FibonacciTailRecur(n-1, acc2, acc1+acc2); }
好了，現在符合尾遞歸的定義了，用gcc分別加-O和-O2選項編譯，下面是部分匯編代碼，
-O2匯編代碼
FibonacciTailRecur: .LFB12: testl %edi, %edi movl %esi, %eax movl %edx, %esi je .L4 .p2align 4,,7 .L7: leal (%rax,%rsi), %edx decl %edi movl %esi, %eax testl %edi, %edi movl %edx, %esi jne .L7 // use jne .L4: rep ; ret
-O匯編代碼
FibonacciTailRecur: .LFB2: pushq %rbp .LCFI0: movq %rsp, %rbp .LCFI1: subq $16, %rsp .LCFI2: movl %edi, -4(%rbp) movl %esi, -8(%rbp) movl %edx, -12(%rbp) cmpl $0, -4(%rbp) jne .L2 movl -8(%rbp), %eax movl %eax, -16(%rbp) jmp .L1 .L2: movl -12(%rbp), %eax movl -8(%rbp), %edx addl %eax, %edx movl -12(%rbp), %esi movl -4(%rbp), %edi decl %edi call FibonacciTailRecur //use call movl %eax, -16(%rbp) .L1: movl -16(%rbp), %eax leave ret
可以看到-O2時用了jne命令，每次調用下層遞歸並沒有申請新的棧空間，而是更新當前幀的局部數據，重復使用當前幀，所以不管有多少層尾遞歸調用都不會棧溢出，這也是使用尾遞歸的意義所在。
而-O使用的是call命令，這會申請新的棧空間，也就是說gcc默認狀態下並沒有優化尾遞歸，這么做的一個主要原因是有時候我們需要保留幀信息用於調試，而加-O2優化后，不管多少層尾遞歸調用，使用的都是第一層幀，是得不到當前幀的信息的，大家可以用gdb調試下就知道了。
除了尾遞歸，Fibonacci數列很容易推導出循環實現方式，
int fibonacciNonRecur(int n) { int acc1 = 0, acc2 = 1; for(int i=0; i<n; i++){ int t = acc1; acc1 = acc2; acc2 += t; } return acc1; }
在我的機器上，全部加-O2選項優化編譯，運行時間如下（單位微秒）
| n |
fibonacciNonRecur |
FibonacciTailRecur |
FibonacciRecur |
| 20 |
1 |
1 |
123 |
| 30 |
1 |
1 |
14144 |
將fibonacci函數的迭代，尾遞歸和遞歸函數性能比較，可以發現迭代和尾遞歸時間幾乎一致，n的大小對迭代和尾遞歸運行時間影響很小，因為只是多執行O（n）條機器指令而已。但是n對遞歸函數影響非常大，這是由於遞歸需要頻繁分配回收棧空間所致。正是由於尾遞歸的高效率，在一些語言如lua中就明確建議使用尾遞歸（參照《lua程序設計第二版》第6章）。
非尾遞歸函數
編譯器無法自動優化一般的遞歸函數，不過通過模擬遞歸函數的過程，我們可以借助於棧將任何遞歸函數轉換為迭代函數。直觀點，遞歸的過程其實是編譯器幫我們處理了壓棧和出棧的操作，轉換為迭代函數就需要手動地處理壓棧和出棧。
下面我們以經典的快速排序為例子。
int partition(int *array, int low, int high) { int val = array[low]; while(low < high) { while(low<high && array[high]>=val) --high; swap(&array[low], &array[high]); while(low<high && array[low]<=val) ++low; swap(&array[low], &array[high]); } return low; } void Quicksort(int *array, int b, int e) { if (b >= e) return; int p = partition(array, b, e); Quicksort(array, b, p-1); Quicksort(array, p+1, e); }
其實不難看出快速排序的遞歸算法就是一個二叉樹的先序遍歷過程，先處理當前根節點，然后依次處理左子樹和右子樹。將快速排序遞歸算法轉換為非遞歸相當於將二叉樹先序遍歷遞歸算法轉為非遞歸算法。
二叉樹先序遍歷遞歸算法偽碼
void PreorderRecursive(Bitree root){ if (root) { visit(root); PreorderRecursive(root->lchild); PreorderRecursive(root->rchild); } }
void PreorderNonRecursive(Bitree root){ stack stk; stk.push(root); while(!stk.empty()){ p = stk.top(); visit(p); stk.pop(); if(p.rchild) stk.push(stk.rchild); if(p.lchild) stk.push(stk.lchild); } }
每次處理完當前節點后將右子樹和左子樹分別入棧，類似地，我們也很容易得到快速排序的非遞歸算法實現。partition將數組分為左右兩部分，相當與處理當前節點，接下來要做的就是將左右子樹入棧，那么左右子樹需要保存什么信息呢？這個是處理非遞歸函數的關鍵，因為被調用函數信息需要壓入棧中。快速排序只需要保存子數組的邊界即可。
void QuicksortNonRecur(int *array, int b, int e) { if (b >= e) return; std::stack< std::pair<int, int> > stk; stk.push(std::make_pair(b, e)); while(!stk.empty()) { std::pair<int, int> pair = stk.top(); stk.pop(); if(pair.first >= pair.second) continue; int p = partition(array, pair.first, pair.second); if(p < pair.second) stk.push(std::make_pair(p+1, e)); if(p > pair.first) stk.push(std::make_pair(b, p-1)); } }
總結
雖然將遞歸函數轉換為迭代函數可以提高程序效率，但是轉換后的迭代函數往往可讀性差，難以理解，不易維護。所以只有在特殊情況下，比如對棧空間有嚴格要求的嵌入式系統，才需要轉換遞歸函數。大部分情況下，遞歸並不會成為系統的性能瓶頸，一個代碼簡單易讀的遞歸函數常常比迭代函數更易維護。
Reference：
http://en.wikipedia.org/wiki/Tail_Recursion
http://c2.com/cgi/wiki?TailRecursion
http://c2.com/cgi/wiki?RecursionVsLoop