看了自己的動態記錄，發現自己已經遺忘了曾經的自己，有一條動態，2013年的時候，我看了一篇關於尾遞迴的博文，那時候還只是一個初學者，胡亂評論了一下，作者希望我能寫一篇博文發表一下自己的看法，當時沒有寫，然而現在卻想寫點什麼總結一下，不保證說的沒問題，只希望如果有像我當年一樣的初學者看到，可以參考借鑑，或許能有些幫助，在此也感謝給我啟發，教會我知識的陌生朋友們。

1. 遞迴就是一個函式直接或間接的自己呼叫自己，間接就是f0 -> f1 -> f0 ->f1這種，但也就是一個名詞而已，並不神奇，它只是一個普普通通的函式呼叫，但由於自己呼叫自己這個特性，有一種自動化的力量，給它一個規則，它可以自動的持續執行下去，直到觸發停止條件。一個遞迴函式就像是一個簡單的計算機。

2. 所有的遞迴都可以用迴圈來替代，所有的迴圈也都可以用遞迴來替代，兩者是等價的。

3. 遞迴是人腦的直接思維方式，迴圈是當前多數(我所知道的所有的)cpu的直接思維方式。

4. 對於cpu來講，函式呼叫只是暫存器，記憶體，跳轉等操作，如果不涉及額外棧空間使用（極簡單函式的特殊情況），函式呼叫和迴圈的差別可能僅僅是使用的暫存器不同。

5. 遞迴可以把複雜的問題變得簡單，是一種處理問題的模型。比如漢諾塔，快速排序，二叉樹遍歷和查詢，如果學會使用遞迴這種思維方式思考問題，很多問題會變得很簡單，大事化小，小事化了，每一步都是很簡單的操作。

6. 正確的思維會使問題很簡單，錯誤的思維會讓人發懵，使用遞迴的思考方式是忘記呼叫的是自己，自己呼叫的是任意一個函式，那個函式有沒有實現，是否實現得正確不是我現在要關心的事，我只要保證，在那個函式正確實現的前提下，我現在寫的這個函式是沒問題的，當我寫完當前函式的時候，被呼叫的函式也就寫完了(副產物)，因為它們是同一個，這有點像數學歸納法。

7. 正確的實現一個遞迴函式，需要保證有退出的條件，除非你是在寫一個死迴圈，同時隨著遞迴層數變深，問題逐漸簡單化，規模逐漸縮小，或者是向退出條件逼近(收斂)。

8. 遞迴對棧空間的佔用分兩種，尾遞迴開啟相應的優化之後不會導致棧空間使用不停擴大，非尾遞迴對棧空間的呼叫要看遞迴的層數，遞迴層數是可預測的，一般二分的遞迴(理想的情況，極端的情況二叉樹會變成連結串列，這時候已經不是二分法了，但二叉樹是可以事先保證平衡的)層數大約為log2(n)，30層函式呼叫使用的棧空間很少(使用超級龐大的陣列區域性變數這樣的特殊情況除外)，但是n是10億級別，這個時候要關注的已經不是棧空間了，而是儲存資料的記憶體空間或cpu等資源，比如用遞迴方法計算Fibonacci數列，現在的個人電腦預設棧空間(M級別)，不可能棧溢位的，忙不過來的是cpu，多分的情況棧空間一般都不會過深，原因是一邊呼叫增加深度，一邊返回減少深度，用完全平衡二叉樹為例，畫一個圖看一下呼叫過程就一目瞭然。

下面就棧空間的使用，尾遞迴，遞迴迴圈的轉換等問題詳細分析。

除非是特殊的情況，編譯器能優化成不使用棧空間，否則遞迴是需要棧空間的，這和任何一個函式呼叫都是一樣的，對於解決實際問題的函式，一般沒有不需要棧空間的，在函式呼叫的時候，需要儲存cpu暫存器到棧空間（用於恢復函式的執行），區域性變數也有可能會導致棧空間的使用，每一個函式執行的時候區域性變數都會佔用一次棧空間，每一次函式呼叫也會觸發一次棧空間的使用，這就是每一次遞迴呼叫的棧空間代價，函式呼叫總是有呼叫就有返回的，最大代價就是最大遞迴層數，尾遞迴是一種特殊情況，考慮下面的函式。

int f(int n)
{
    if(n <= 0)
       return n;
    // body;
    return f(n-1);
}

return f(n-1);是函式f的最後一個語句。f(n-1)的返回值就是f(n)的返回值，也就是說對於當前函式f(n)已經沒有必要儲存現場了，它的棧空間不需要恢復了，f(n-1)返回到f(n)，f(n)再向上返回，那為什麼要留個中介呢，為什麼不直接向上返回呢，所以棧空間中儲存的返回地址等不動，進入f(n)時儲存的暫存器(callee-saved registers)不動，也就是f(n)的上層現場不動，他們直接繼承給f(n-1)，f(n-1)不再
儲存它的返回地址(f(n)的最後)，也不再儲存使用的暫存器(f(n)已經不需要恢復了)，f(n)的區域性變數使用的棧空間直接被f(n-1)的給覆蓋掉，同樣的邏輯再向上遞推，會發現，每一層函式呼叫引起的棧空間佔用都相當於沒有了，實際上上述程式碼就變成了

int f(int n)
{
    while( n > 0 )
    {
        //body;
        n--;
    }
    return n;
}

這種遞迴叫做尾遞迴，即遞迴呼叫之後不需要再有額外的操作，並且遞迴之前沒有其他遞迴呼叫，開啟優化之後（gcc, O2預設開啟）編譯器可以將尾遞迴優化成迴圈。

再考慮下面的函式

int f(int n)
{
    if(n <= 0)
       return n;
    // body;
    return n + f(n-1);
}

這種遞迴呼叫是無法 直接 變成迴圈的，這裡用直接，是因為這種情況太簡單了，編譯器不會那麼傻，gcc O1就會變成迴圈，為什麼不能直接變成迴圈呢，因為f(n-1)之後還有其他操作（返回值+n），為了繼續其他操作能夠繼續執行，呼叫f(n-1)之前需要儲存現場，需要用到棧空間，每一層呼叫都會儲存一次棧空間，這時候棧空間的佔用是O(n)的，因為不是二分，三分，n的數量稍大一點就會導致棧溢位。當然這裡實在是太簡單了！換個複雜的，編譯器就不會優化了（只是寫本文的時候用的gcc，不排除以後編譯器越來越智慧的可能）。

unsigned long fib(int n)
{
    if(n < 2)
       return 1;
    return fib(n-1) + fib(n-2);
}

fib(3) 呼叫 fib(2)和fib(1)，假定編譯器生成的指令是先呼叫fib(2)，那麼就要在棧空間中儲存現場，以便fib(2)返回的時候能夠繼續執行fib(1)和一個加法操作，fib(2)呼叫fib(1)和fib(0)，還是假定先呼叫左邊的，呼叫fib(1)的時候需要儲存現場，然後返回1, 恢復現場，儲存現場，呼叫fib(0)，然後恢復現場，加法運算，然後再返回上層，即fib(2)返回，恢復現場，fib(2)下面的所有呼叫佔用的棧空間都已釋放了(遞減棧棧頂暫存器數值增加)，然後儲存現場，呼叫fib(1)，返回1, 恢復現場，加法運算，返回，整個fib(3)就是這樣完成的，可見每次呼叫+左邊的分支的時候，遞迴層數會增加一層，每次呼叫+右面的分支的時候，左面增加的層數都已經恢復，這是一個動態增減的過程，遞迴層數是有限的。這種Fibonacci數列演算法慢的根源在於重複計算。不重複計算的方法如下：

unsigned long fib2(int n,  unsigned long left, unsigned long right)
{
    if( n < 2 )
        return right;
    return fib2(n - 1, right, left+right);
}

這裡是一個尾遞迴，相當於迴圈, 當然如果不優化，棧空間佔用是O(n)，n足夠大是會溢位的。

可見，迴圈和尾遞迴是直接互相轉換的，迴圈變數相當於函式中的引數，迴圈退出條件相當於函式退出的條件，迴圈變數的增減相當於引數傳遞時的增減計算，迴圈體相當於函式體，所以像scheme這樣的程式語言沒有迴圈但是並不影響表達能力。

Fibonacci數列迴圈的演算法是從數列的左邊開始，不符合直觀定義，需要知道原理才能想到，直觀的定義是從右到左，然而左邊又沒有準備好，所以需要借用棧。

考慮一個更明顯的例子，單向非迴圈連結串列的正向遍歷和逆向遍歷，前者是尾遞迴(迴圈)，後者非尾遞迴(使用迴圈需要藉助棧)，正向遍歷不需要額外的棧空間，但是如何實現逆向遍歷呢？首先要拿到最後一個節點，但是訪問完最後一個節點了，到哪裡去找上一個節點呢，單向連結串列並沒有prev指標，很明顯，需要在記憶體中儲存，由於訪問的順序是後進先出，用的應該是棧這種模型，而函式呼叫本來就是棧的模型的，所以如果使用函式呼叫的方式是很自然的，很符合人的思維邏輯的，用遞迴的方式都不用考慮棧的問題，因為這是一種很自然的符合人的邏輯的思考模型，程式碼如下：

struct list{
    int c;
    struct list *next;
};

#define print_list(list) (void)list
void visit(const struct list *cur)
{
    if(cur == NULL)
        return;
    print_list(cur);
    visit(cur->next);
}
void visit_reverse(const struct list *cur)
{
    if(cur == NULL)
        return;
    // 訪問後面的，怎麼訪問的不用管，會有人保證它的逆序
    visit_reverse(cur->next);
    // 後面的全都訪問完了，訪問當前的
    print_list(cur);
}

#define list_append(tail_p, cur) ((*tail_p)->next = cur, (*tail_p) = cur)
struct list * _list_reverse(struct list *cur, struct list **tail_after_reverse)
{
    // 最後一個
    if(cur->next == NULL)
    {
        // 記錄末尾，方便list_append
        *tail_after_reverse = cur;
        return cur;
    }
    struct list *head = _list_reverse(cur->next, tail_after_reverse);
    list_append(tail_after_reverse, cur);
    return head;
}
// 逆序單向連結串列
struct list * list_reverse(struct list *cur)
{
    struct list *tail_after_reverse;
    if(cur == NULL)
        return cur;
    struct list *head = _list_reverse(cur, &tail_after_reverse);
    list_append(&tail_after_reverse, NULL);
    return head;
}

尾遞迴和迴圈可以互相轉換，這是很明顯的，那麼非尾遞迴如何和迴圈互相轉換呢，理論上是一定可以完成的，因為對於cpu來講遞迴就是用棧來實現的，下面以二叉樹的先序，中序，後序的遍歷方式來舉例說明，不過能夠實現不代表應該這樣做，程式碼的可讀性和見解性非常重要，並且轉變成迴圈也未必就能感受到效能的變化。

#include <assert.h>
#include <stdio.h>


struct tree{
    int n;
    struct tree *left;
    struct tree *right;
};

static const void *stack[128];
static char stack_flag[128];
static int stack_i;
#define visit(t) printf("%d\t", t->n)
#define push(x) do{if(x) stack[stack_i++] = x;}while(0)
#define pop() (stack_i == 0 ? NULL : stack[--stack_i])
#define push2(x, flag) do{if(x) {stack[stack_i] = x; stack_flag[stack_i++] = flag;}}while(0)
#define pop2(flag) (stack_i == 0 ? NULL : ((flag=stack_flag[--stack_i]), (stack_flag[stack_i] = 0), stack[stack_i]))

// 二叉樹的先序遍歷
//
// 遞迴版本
void preorder(const struct tree *t){
    if(t == NULL)
        return;
    visit(t);
    preorder(t->left);
    preorder(t->right);
}

// 迴圈版本
// 如何變成迴圈呢，方法就是遞迴怎麼來，我們就怎麼來，
// 1. 呼叫visit，但是呼叫之後要恢復兩個函式呼叫，為了恢復現場，需要在棧空間中儲存後續要做的事，我們這裡顯然不需要儲存cpu暫存器等，只需要儲存t->left和t->right就可以了，由於是先呼叫t->left，後呼叫t->right，所以入棧就要反過來。
//push(t->right);
//push(t->left);
//能不能直接push(t)呢，答案是不能，除非標記t已經訪問過了，否則就迴圈訪問t了，但是標記t訪問過了還是要把t->right和t->left入棧，不如就直接來，更直接。
// 2. t訪問完了，遞迴程式就恢復現場，返回到visit的下一個地址執行，恢復現場就對應我們的出棧，繼續執行同樣的preorder邏輯就相當於我們重複一次迴圈，
// 3. 遞迴程式繼續這個過程，直到函式棧上的最底層，也就是最後一個函式呼叫返回，對應我們的繼續這個過程，直到棧裡面沒有資料了為止。
// 程式碼如下
void preorder_loop0(const struct tree *in)
{
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        visit(t);
        push(t->right);
        push(t->left);
    }while((t = pop()) != NULL);
}
//這個程式是最原始的貼近遞迴的版本，還可以繼續優化，visit(t)之後pop出來的一定是t->left，那麼下次一定是visit(t->left)，往下遞推，每一次都是visit(t->left)，也就是說按照一直向左的方向遍歷就可以了，需要入棧的只是右子樹，但是右子樹誰先誰後呢，從遞迴程式可以看出，所有的左子樹成員都在右子樹的前面遍歷，也就是說最接近樹根的大叉是優先順序最低的，遠離樹根的在左子樹上的右子樹更優先，也就是說，入棧的順序和訪問的順序相同，即
//

void preorder_loop1(const struct tree *in)
{
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        while(t)
        {
            visit(t);
            push(t->right);
            t = t->left;
        }
    }while((t = pop()) != NULL);
}
// 將上面兩種版本對比，想象一下preorder_loop0的執行過程，也可以直接優化為preorder_loop1

//中序遍歷
// 遞迴版本
void inorder(const struct tree *t){
    if(t == NULL)
        return;
    inorder(t->left);
    visit(t);
    inorder(t->right);
}

// 第一步還是按照和遞迴一一對應的方式來轉換成迴圈，這個地方有點複雜，因為第一個函式不是visit，本身就是個遞迴的，這時候的處理方式不唯一，可以直接把遞迴版本函式中最上面的那個inorder展開，也可以按照通用的迴圈中的邏輯來處理那個inorder，前者直接就是優化之後的了。另外由於inorder和visit是兩種操作，為了區分是哪一種操作，還需要在入棧的時候加標記等。
void inorder_loop0(const struct tree *in)
{
    int is_visit = 0;
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        if(is_visit)
            visit(t);
        else
        {
            push2(t->right, 0);
            push2(t, 1);
            push2(t->left, 0);
        }
    }while((t = pop2(is_visit)) != NULL);
}
// 簡化push(t->left); 同preorder的方法
void inorder_loop1(const struct tree *in)
{
    int is_visit = 0;
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        if(is_visit)
            visit(t);
        else
        {
            while(t)
            {
                push2(t->right, 0);
                push2(t, 1);
                t = t->left;
            }
        }
    }while((t = pop2(is_visit)) != NULL);
}
// 繼續優化，每次pop出來的一定是先visit的，然後接著就是它的right，那麼兩者可以合成一個整體，這樣也不用標記是否是is_visit了
void inorder_loop2(const struct tree *in)
{
    const struct tree *t = in;
    if(t == NULL)
        return;

    while(t)
    {
        push(t);
        t = t->left;
    }
    while((t = pop()) != NULL)
    {
        visit(t); // pop -> t
        if(t->right) // pop -> t->right
        {
            t = t->right;
            while(t)
            {
                push(t);
                t = t->left;
            }
        }
    }
}

// 後續遍歷
// 遞迴版本
void postorder(const struct tree *t){
    if(t == NULL)
        return;
    postorder(t->left);
    postorder(t->right);
    visit(t);
}
// 和中序遍歷相同的方式，唯一一個區別就是 visit(t) 和postorder(t->right)的順序換了一下，也就是入棧的順序換了一下。程式碼如下：
void postorder_loop0(const struct tree *in)
{
    int is_visit = 0;
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        if(is_visit)
            visit(t);
        else
        {
            push2(t, 1);
            push2(t->right, 0);
            push2(t->left, 0);
        }
    }while((t = pop2(is_visit)) != NULL);
}

// 前面已經用過這種思路，去掉push t->left(附帶的pop也一起去掉了)
void postorder_loop1(const struct tree *in)
{
    int is_visit = 0;
    const struct tree *t = in;
    if(t == NULL)
        return;
    do{
        if(is_visit)
            visit(t);
        else
        {
            while(t)
            {
                push2(t, 1);
                push2(t->right, 0);
                t = t->left;
            }
        }
    }while((t = pop2(is_visit)) != NULL);
}

// t->right 先出棧，處理完整棵樹才能繼續處理t(即visit(t))，所以t和t->right不能當成一個整體來優化
// 但仍然可以繼續優化，t->right的處理過程是先push 它自己，也就是說visit(t)的時候上一次pop一定是
// t->right，並且pop -> t->right 然後pop -> t 的時候一定是訪問t的時候，這是後序遍歷的定義的必然
// 即 t->right == NULL 或last_pop/visit == t->right就是visit(t)的時刻，這樣可以去掉is_visit的標記
// 使用更簡單的push 和 pop
void postorder_loop2(const struct tree *in)
{
    const struct tree *t = in, *last_visit = NULL;
    if(t == NULL)
        return;

    while(t)
    {
        push(t);
        push(t->right);
        t = t->left;
    }
    while((t = pop()) != NULL)
    {
        if(t->right == NULL || last_visit == t->right)
        {
            visit(t);
            last_visit = t;
        }
        else
        {
            while(t)
            {
                push(t);
                push(t->right);
                t = t->left;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    /*
     *
     *                        4
     *                     /    \
     *                   2        6
     *                 /  \      /   \
     *                1    3    5      8
     *                                / \
     *                               7   9
     *
     *
     */
    struct tree t[9] = {
        {1, NULL,NULL},
        {2, &t[0],&t[2]},
        {3, NULL,NULL},
        {4, &t[1],&t[5]},
        {5, NULL,NULL},
        {6, &t[4],&t[7]},
        {7, NULL,NULL},
        {8, &t[6],&t[8]},
        {9, NULL,NULL},
    };
    preorder(&t[3]);
    puts("");
    assert(stack_i == 0);
    preorder_loop0(&t[3]);
    assert(stack_i == 0);
    puts("");
    preorder_loop1(&t[3]);
    assert(stack_i == 0);
    puts("");
    inorder(&t[3]);
    assert(stack_i == 0);
    puts("");
    inorder_loop0(&t[3]);
    assert(stack_i == 0);
    puts("");
    inorder_loop1(&t[3]);
    assert(stack_i == 0);
    puts("");
    inorder_loop2(&t[3]);
    puts("");
    postorder(&t[3]);
    puts("");
    assert(stack_i == 0);
    postorder_loop0(&t[3]);
    assert(stack_i == 0);
    puts("");
    postorder_loop1(&t[3]);
    assert(stack_i == 0);
    puts("");
    postorder_loop2(&t[3]);
    assert(stack_i == 0);
    return 0;
}

尾遞迴和非尾遞迴是否能轉換呢，對於Fibonacci數列這樣的特殊情況當然可以，但有些問題就是遞迴模型，比如快速排序，所以是無法直接轉換的，如果非要轉換的話，也是可以的，藉助額外實現的棧，因為迴圈和尾遞迴是等價的，迴圈加額外的棧能實現的，尾遞迴加額外的棧也能實現，但是這樣做是否有意義呢，人工精心優化的迴圈/尾遞迴程式和非尾遞迴相比，有時候也許能獲得少量效能提升，但是程式碼的可讀性卻很差，而非尾遞迴程式卻是非常直觀。

補充一點，看編譯器是否進行了尾遞迴優化，可以通過gdb或objdump看彙編，看尾遞迴發生的時候後面是否有其他操作，或者是否還有遞迴的呼叫，gcc O2一定會優化的， 如果通過試驗測試，建議數字要足夠大，因為優化之後的程式可能佔用棧空間很小，而程序的棧空間可能又很大，所以沒有進行尾遞迴優化依然可能不會棧溢位。

總之，遞迴是一種非常好的模型，棧空間一般可預測，尾遞迴因為利用函式實現，區域性變數隔離，也會增加安全性，但是記得開優化，儘量不用棧和迴圈替代遞迴，增加程式碼可讀