1. 程式人生 > >我對遞迴的理解和總結

我對遞迴的理解和總結

看了自己的動態記錄,發現自己已經遺忘了曾經的自己,有一條動態,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一定會優化的, 如果通過試驗測試,建議數字要足夠大,因為優化之後的程式可能佔用棧空間很小,而程序的棧空間可能又很大,所以沒有進行尾遞迴優化依然可能不會棧溢位。

 

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