之前在總結函數的時候，有介紹過遞歸。參看：C語言再學習 -- 函數?正在看數據結構與算法分析，開篇就講到遞歸，那現在就詳細講解下它吧。

參看：遞歸函數理解

一、什么是遞歸函數

（1）遞歸函數即自調用函數，在函數內部直接或間接地自己調用自己，即函數的嵌套調用是函數本身。

從字面上來看遞歸，遞即遞推，采用循環的思路來描述復雜問題的方法。在遞推階段每一個遞歸調用通過進一步調用自己來記住這次遞歸過程，當其中調用滿足終止條件時，遞推結束。歸即回歸，函數調用已逆序的方式回歸，知道最初調用的函數返回為止，此時遞歸過程結束。舉個例子：

//示例一 #include <stdio.h> void show (int); int main (void) { show (1); return 0; } void show (int n) { printf ("Level %d: n location %p\n", n, &n); if (n < 4) show (n + 1); printf ("Level %d: n location %p\n", n, &n); } 執行結果如下： Level 1: n location 0xbf8bf680 Level 2: n location 0xbf8bf660 Level 3: n location 0xbf8bf640 Level 4: n location 0xbf8bf620 Level 4: n location 0xbf8bf620 Level 3: n location 0xbf8bf640 Level 2: n location 0xbf8bf660 Level 1: n location 0xbf8bf680

//示例二 /*6*5*4*3*2*1=？的階乘*/#include <stdio.h> int func(int num) //整數類型 {if(num==1){return 1;}return num*func(num-1); } int main() {int num=func(6);printf("6的階乘為%d\n",num);return 0; } 輸出結果： 6的階乘為720

（2）遞歸的基本原理

第一：每一級的函數調用都有自己的變量。

第二：每一次函數調用都會有一次返回。

第三：遞歸函數中，位于遞歸調用前的語句和各級被調用函數具有相同的執行順序。

第四：遞歸函數中，位于遞歸調用后的語句的執行順序和各個被調用函數的順序相反。

第五：雖然每一級遞歸都有自己的變量，但是函數代碼并不會得到復制。

最后：遞歸函數中必須包含可以終止遞歸調用的語句。

（3）遞歸的優缺點

其優點在于為某些變成問題提供了最簡單的解決方法，簡化了程序設計。而缺點是一些遞歸算法會很快耗盡計算機的內存資源。同時，使用遞歸的程序難于閱讀和維護。

二、函數調用機制的說明

任何函數之間不能嵌套定義，調用函數與被調用函數之間相互獨立遞歸函數的概念用法與實例（彼此可以調用）。發生函數調用時，被調用函數中保護了調用函數的運行環境和返回地址，使得調用函數的狀態可以被調用函數運行返回完全恢復，而且該狀態與被調用函數無關。

被調用函數運行的代碼雖然是同一個函數的代碼體，但由于調用點，調用時狀態，返回點的不同，可以看作是函數的一個副本，與調用函數的代碼無關，所以函數的代碼是獨立的。被調用函數運行的棧空間獨立于調用函數的棧空間，所以與調用函數之間的數據也是無關的。函數之間考參數傳遞和返回值來聯系，函數看作為黑盒。

這種機制決定了 C/C++ 允許函數遞歸調用。

上面這段話的意思可以理解為，遞歸函數調用自身函數的時候，可以看作調用的是調用別的函數。

再有，被調用函數運行的棧空間獨立于調用函數的棧空間 這句話如何理解？

首先，我們先說一下棧的概念：

參看：遞歸函數的概念用法與實例
參看：C語言再學習 -- 內存管理

棧是一個后進先出(LIFO)的壓入（push）和彈出（pop）式的數據結構。在程序運行時，系統每次向棧中壓入一個對象，然后棧指針向下移動一個位置。當系統從棧中彈出一個對象時，最近進棧的對象將被彈出。然后棧指針向上移動一個位置。程序員經常利用棧這種數據結構來處理那些最適合用后進先出邏輯來描述的編程問題。這里討論的程序中的棧每個程序中都是存在的，它不需要程序員編寫代碼去維護，而是由運行時系統自動處理。所謂系統自動維護，實際上就是編譯器所產生的程序代碼。盡管在程序中看不到他們，但是程序員應該對此有所了解。

再看看程序中的棧是如何工作的。當一個函數（調用者）調用另一個函數（被調用者）時，運行系統將把調用者的所有實參和返回地址壓入棧中，棧指針將移到合適的位置來容納這些數據。最后進棧的是調用者的返回地址。當被調用這開始執行時，系統把被調用者的自變量壓入棧中，并把棧指針再向下移，以保證有足夠的空間存儲被調用這聲明的所有自變量。當調用這把實參壓入棧后，被調用者就在棧中以自變量的形式建立形參。被調用這內部的其他自變量也是存放在棧中的。由于這些進棧操作，棧指針已經移動所有這些局部變量之下。但是被調用者記錄了它剛開始執行時的初始棧指針，以它為參考，用正或負的偏移量來訪問棧中的變量。當被調用者準備返回時，系統彈出棧中所有的自變量，這是棧指針移動了被調用者剛開始執行時的位置。接著被調用者返回，系統從棧中彈出返回地址，調用者就可以繼續執行了。當調用者繼續執行時，系統還將從棧中彈出調用者的實參，于是棧指針回到了調用發生前的位置。

想深入了解棧和遞歸的關系，參看：C語言數據結構----棧與遞歸

現在接著說遞歸：

上面有提到了函數調用機制。遞歸之所以能實現，是因為函數的每個執行過程都在棧中有自己的形參和局部變量的拷貝，這些拷貝和函數的其他執行過程毫不相干。這種機制是當代大多數程序設計語言實現子程序結構的基礎，是使得遞歸成為可能。假定某個調用函數調用了一個被調用函數，再假定被調用函數又反過來調用了調用函數。這第二個調用就被稱為調用函數的遞歸，因為它發生在調用函數的當前執行過程運行完畢之前。而且，因為這個原先的調用函數、現在的被調用函數在棧中較低的位置有它獨立的一組參數和自變量，原先的參數和變量將不受影響，所以遞歸能正常工作。程序遍歷執行這些函數的過程就被稱為遞歸下降。
程序員需保證遞歸函數不會隨意改變靜態變量和全局變量的值，以避免在遞歸下降過程中的上層函數出錯。程序員還必須確保有一個終止條件來結束遞歸下降過程，并且返回到頂層。看下面的例子：

/*實現 1+2+3+4+5 = ？*/ //使用 static int num = 0; #include <stdio.h>int add (int);int main (void) {add (1); }int add (int num) {static int sum = 0;sum += num;printf ("sum = %d, num = %d\n", sum, num);if (num == 5) return ;add (++num); } 輸出結果： sum = 1, num = 1 sum = 3, num = 2 sum = 6, num = 3 sum = 10, num = 4 sum = 15, num = 5

這里有一個問題一定要注意，就是static int sum = 0;
有些人就不明白，為什么要使用 static 類型修飾符，為什么不使用 int sum=0;？如果使用 int sum=0; 這樣的語句，在每次調用函數add()的時候，sum的值都是賦值為0，也就是第一步雖然加了1上來，可是第二次調用的時候，sum又回到了0。我們前面說了，static能保證本次初始化的值是上次執行后的值，這樣也就保證了前面想加的結果不會丟失。如果你修改為int sum=0，最后結果一定是最后結果是5而不是15。

/*實現 1+2+3+4+5 = ？*/ //使用 int sum = 0; #include <stdio.h>int add (int);int main (void) {add (1); }int add (int num) {int sum = 0;sum += num;printf ("sum = %d, num = %d\n", sum, num);if (num == 5) return ;add (++num); } 輸出結果： sum = 1, num = 1 sum = 2, num = 2 sum = 3, num = 3 sum = 4, num = 4 sum = 5, num = 5

上面的例子就很好的解釋了，被調用函數運行的棧空間獨立于調用函數的棧空間?這句話。

三、遞歸調用的形式

遞歸函數有直接遞歸調用和間接調用兩種形式. 直接遞歸即在函數出現調用函數本身，例如： /*6*5*4*3*2*1=？的階乘*/#include <stdio.h> int func(int num) //整數類型 {if(num==1){return 1;}return num*func(num-1);//直接遞歸 } int main() {int num=func(6);printf("6的階乘為%d\n",num);return 0; } 輸出結果： 6的階乘為720間接遞歸調用指函數中調用其他函數，而該其他函數卻又調用了本函數。例如： #include <stdio.h> int foo (int x) {printf ("x = %d\n", x);if (x <= 0)return x;return bar (x); //間接遞歸 }int bar (int y) {return foo (y - 1); }int main (void) {foo (5);return 0; } 輸出結果： x = 5 x = 4 x = 3 x = 2 x = 1 x = 0下面，再擴展一種遞歸，尾遞歸 當遞歸調用是整個函數中最后執行的語句且它的返回值不屬于表達式的一部分時，這個遞歸調用就是尾遞歸的。 上面的直接遞歸例子的返回值是 ?return num*func(num-1); 是一個表達式自然不是尾遞歸了，將其改為尾遞歸： #include <stdio.h>int func(int num, int n) {if(num == 1){return n;}return func(num-1, num*n);//尾遞歸 } int main() {int num=func(6, 1);printf("6的階乘為%d\n",num);return 0; } 輸出結果： 6的階乘為720 當編譯器檢查到一個函數是尾遞歸的時候，它就會覆蓋當前活躍記錄而不是在棧中去創建一個新的，這樣就解決了普通遞歸函數占用棧空間過大的問題。遺憾的是，大多數編程語言沒有針對尾遞歸做優化，所以，即使把函數改成尾遞歸方式，也會導致棧溢出。 突然想看看，棧溢出是什么現象？ 參看：遞歸函數 #include <stdio.h> void recurse(int count) { printf("%d \n",count); return recurse(count + 1); //遞歸 } int main() { recurse(1); } 輸出結果： ... 261929 261930 261931 261932 261933 261934 261935 段錯誤 (核心已轉儲) 上面提到了，棧是一種后進先出（LIFO）的數據結構，對棧的操作都是在棧頂上進行的。程序在運行時，如果調用一個函數，則將該函數壓棧（push），調用完一個函數則出棧（pop）。而對于上面定義的recurse函數，在遞歸過程中，不斷的壓棧(因為該函數并沒有執行完畢，因為還沒有執行到函數的最后一個大括號 } )。因為內存是有限的，因此程序最終會崩潰(Crash)。 所以，為了防止棧溢出，遞歸函數中必須包含可以終止遞歸調用的語句，通常我們的遞歸函數都有if-else語句來判斷何時終止遞歸。 說到這里，不妨再看看?return關鍵字，它表示了調用堆棧的返回； 參看：C語言再學習 -- 關鍵字return和exit ()函數
其實上面的例子，也可以用迭代來實現： #include <stdio.h>int func(int num) {int n = 1, m = 1;for (n = 1; n <= num; n++){m = m*n;}return m; } int main() {int num=func(6);printf("6的階乘為%d\n",num);return 0; } 輸出結果： 6的階乘為720這不是循環嗎，怎么說是迭代呢，循環和迭代一樣嗎，什么是迭代？ 參看：漫談遞歸：循環與迭代是一回事嗎？ 先講講什么是迭代： 迭代算法：是用計算機解決問題的一種基本方法。它利用計算機運算速度快、適合做重復性操作的特點，讓計算機對一組指令（或一定步驟）進行重復執行，在每次執行這組指令（或這些步驟）時，都從變量的原值推出它的一個新值。如果遞歸是自己調用自己的話，迭代就是A不停的調用B。
遞歸中一定有迭代，但是迭代中不一定有遞歸，大部分可以相互轉換。能用迭代的不用遞歸，遞歸調用函數,浪費空間，并且遞歸太深容易造成堆棧的溢出。
那么迭代和循環什么關系？ 迭代：“迭”：輪流，輪番，替換，交替，更換。“代”：代替。所以迭代的意思是：變化的循環，這種變化就是輪番代替，輪流代替。
循環：不變的重復。
個人認為迭代是循環的一種，循環體代碼分為固定循環體，和變化的循環體。
固定的循環，例如： #include <stdio.h> int main() { int i = 0;for (i = 0; i <= 5; i++){printf ("hello world!\n");}return 0; } 輸出結果： hello world! hello world! hello world! hello world! hello world! hello world!實現迭代： #include <stdio.h> int main() { int i = 0;int sum = 0;for (i = 0; i <= 5; i++){sum += i;}printf ("sum = %d\n", sum);return 0; } 輸出結果： sum = 15 上面的迭代是常見的遞增式迭代。類似的還有遞減式迭代，遞乘式迭代。
迭代的好處：迭代減少了冗余代碼，提高了代碼的利用率和動態性。
那么遞歸和循環什么關系呢？ 遞歸一般可以代替循環語句使用。有些情況下使用循環語句比較好，而有些時候使用遞歸更有效。遞歸方法雖然使用程序結構優美，但其執行效率卻沒有循環語句高。一般來說，選擇循環更好一些。首先，因為每次遞歸調用都擁有自己的變量集合，所以就需要占用較多的內存；每次遞歸調用需要把新的變量集合存儲在堆棧中。其次，由于進行每次函數調用需要花費一定的時間，所以遞歸的執行速度較慢。 說句題外話，使用遞歸來計算諸如斐波拉契數列之類簡單數學函數的值的想法一般來說不是一個好主意，只能說腦子被驢踢了。 好吧，我們來比較一下使用遞歸和迭代計算斐波拉契數列的時間。 //遞歸 #include <stdio.h> #include <sys/timeb.h> long long getSystemTime() { struct timeb t; ftime(&t); return (1000 * t.time + t.millitm); } int fibonacci(int n) { if( n > 1 ) { return fibonacci(n-1) + fibonacci(n-2); } else if( n == 1 ) { return 1; } else if( n == 0 ) { return 0; } } int main() { int i = 0; long long start = getSystemTime(); for(i=1; i<=40; i++) { printf("fibonacci(%d) = %d\n", i, fibonacci(i)); } long long end = getSystemTime(); printf("time: %lld ms\n", end-start); return 0; } 輸出結果： time: 4836 ms //迭代 #include <stdio.h> #include <sys/timeb.h> #include <stdlib.h> long long getSystemTime() { struct timeb t; ftime(&t); return (1000 * t.time + t.millitm); } int fibonacci(int n) { if (n == 1 || n == 0)return n;int *arr = (int*)malloc(sizeof (int)*n + 1);arr[1] = 1;arr[2] = 1;int i = 0;for (i = 3;i <=n; i++){arr[i] = arr[i-1] + arr[i-2]; }return arr[n]; } int main() { int i = 0; long long start = getSystemTime(); for(i=1; i<=10; i++) { printf("fibonacci(%d) = %d\n", i, fibonacci(i)); } long long end = getSystemTime(); printf("time: %lld ms\n", end-start); return 0; } 輸出結果： time: 1 ms

四、遞歸四條基本法則

（1）基準情形。必須總有某些進準情況，它無須遞歸就能解出。 意思是必須包含可以終止遞歸調用的語句。當然，不是說必須有返回值的。 #include <stdio.h> void show (int); int main (void) { show (1); return 0; } void show (int n) { printf ("Level %d: n location %p\n", n, &n); if (n < 4) show (n + 1); printf ("Level %d: n location %p\n", n, &n); } 執行結果如下： Level 1: n location 0xbf8bf680 Level 2: n location 0xbf8bf660 Level 3: n location 0xbf8bf640 Level 4: n location 0xbf8bf620 Level 4: n location 0xbf8bf620 Level 3: n location 0xbf8bf640 Level 2: n location 0xbf8bf660 Level 1: n location 0xbf8bf680 （2）不斷推進。對于那些需要遞歸求解的情形，每一次遞歸調用都必須要使求解狀況朝接近基準情形的方向推進。 很好理解吧，比如上面的例子里的 show (n + 1)。 （3）設計法則。假設所有的遞歸調用都能運行。 在遞歸函數定義中，必須先測試，后遞歸調用。也就是說，遞歸調用是有條件的，滿足了條件后，才可以遞歸。 ?
例如，下面的代碼無條件調用函數自己，造成無限制遞歸，終將使棧空間溢出： ?
#include <stdio.h> void count(int val) { count(val-1); //無限制遞歸 if(val>1) //該語句無法到達 printf ("ok\n"); }int main (void) {count (10);return 0; } 輸出結果： 段錯誤 (核心已轉儲) （4）合成效益法則。在求解一個問題的同一實例時，切勿在不同的遞歸調用中做重復性的工作。

五、遞歸進階篇

關于遞歸理論知識上面總結的已經很全面了。下面講一些利用遞歸解決問題的例程。

1、斐波那切數列

雖然之前說過，使用遞歸解決斐波那切數列，只能說腦子被驢踢了。但是它畢竟提供了一種解題思想。

首先了解下斐波那契數列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55，...

在數學上，斐波納契數列以如下被以遞歸的方法定義：F(0)=1，F(1)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）

所以也就有了下面的遞歸寫法：

//遞歸 #include <stdio.h> int fibonacci (int n) { if (n == 0) return 1; else if (n == 1) return 1; else if (n >= 2) return fibonacci (n - 1) + fibonacci (n - 2); } int main (void) { int i = 0; for(i = 0; i < 10; i++) printf ("fibonacci (%d) = %d\n", i, fibonacci (i)); return 0; } 輸出結果： fibonacci (0) = 1 fibonacci (1) = 1 fibonacci (2) = 2 fibonacci (3) = 3 fibonacci (4) = 5 fibonacci (5) = 8 fibonacci (6) = 13 fibonacci (7) = 21 fibonacci (8) = 34 fibonacci (9) = 55

當然，如果 n 比較大的情況下還是推薦使用迭代。

2、國王被“數字”欺騙的故事

傳說,舍罕王要重賞國際象棋的發明人——宰相達依爾.達依爾指著國際象棋的棋盤說：“陛下,請您在這張棋盤的第一

小格內,賞給我一粒麥子,第二小格內給二粒麥子,第三小格內給四粒麥子,照這樣下去,每一小格內的麥粒都比前一小格增

加一倍.然后把這棋盤上所有的64格的麥粒,都賞給您的仆人吧!”國王命令仆人把一袋麥子拿高棋盤前,但是,還沒有放

到第20格,袋子已經 空了.于是,麥子一袋一袋地扛進來,結果倉庫也空了,棋盤上的格子還沒有全部放上麥粒呢!舍罕王這

才想到受騙了.算一算,麥粒放到第（）格,這一格的麥粒已經超過一億粒；第64格大約要放（）億粒.

這個故事從小就聽過了，結果是：1, 2, 4, 8, 16, 32, ....

如果以遞歸的方式定義：F(0)=1，F(1)=2, F(n)=F(n-1)*2 ?（n > 1）

所以也就有了下面的遞歸寫法：

//遞歸 #include <stdio.h> int foo (int n) { if (n == 0) return 1; else if (n == 1) return 2; else if (n > 1) return foo (n - 1) * 2; } int main (void) { int i = 0, sum = 0; for(i = 0; i < 10; i++) { printf ("foo (%d) = %d\n", i, foo (i)); sum += foo (i); } printf ("總和為：%d\n", sum); return 0; } 輸出結果： foo (0) = 1 foo (1) = 2 foo (2) = 4 foo (3) = 8 foo (4) = 16 foo (5) = 32 foo (6) = 64 foo (7) = 128 foo (8) = 256 foo (9) = 512 總和為：1023 當 n = 64 的時候結果是天文數字了，我只想說知識改變命運啊，宰相您保重！

3、漢諾塔的故事

大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按大小順序摞著64片黃金圓盤。大梵天命令婆羅

門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。并且規定，在小圓盤上不能放大圓盤，在三根柱子之間一

次只能移動一個圓盤。

具體游戲怎么玩我就不說了，感興趣的可以玩兩把：新漢諾塔

所以也就有了下面的遞歸寫法：

參看：經典遞歸解決漢諾塔！

#include <stdio.h> //第一個塔為初始塔，中間的塔為借用塔，最后一個塔為目標塔 int i = 1; //記錄步數 void move (int n, char from, char to) //將編號為n的盤子由from移動到to { printf ("第%d步:將%d號盤子%c---->%c\n", i++, n, from, to); } void hanoi (int n, char from, char denpend_on, char to) //將n個盤子由初始塔移動到目標塔(利用借用塔) { if (n == 1) move (1, from, to); //只有一個盤子是直接將初塔上的盤子移動到目的地 else { hanoi (n - 1, from, to, denpend_on); //先將初始塔的前n-1個盤子借助目的塔移動到借用塔上 move (n, from, to); //將剩下的一個盤子移動到目的塔上 hanoi (n - 1, denpend_on, from, to); //最后將借用塔上的n-1個盤子移動到目的塔上 } } int main (void) { printf ("請輸入盤子的個數:\n"); int n; scanf ("%d", &n); char x = 'A', y = 'B', z = 'C'; printf ("盤子移動情況如下:\n"); hanoi (n, x, y, z); } 輸出結果： 請輸入盤子的個數: 3 盤子移動情況如下: 第1步:將1號盤子A---->C 第2步:將2號盤子A---->B 第3步:將1號盤子C---->B 第4步:將3號盤子A---->C 第5步:將1號盤子B---->A 第6步:將2號盤子B---->C 第7步:將1號盤子A---->C

4、全排列

假設123它的全排列有，123、132、213、231、321、312 高中應該就學過的，那它用遞歸該如何實現。 首先想再講一下交換的實現，這部分內容在講值傳遞、址傳遞時都講過了。 參看：C語言再學習 -- 值傳遞，址傳遞，引用傳遞 #include <stdio.h>int main (void) {int temp = 0;int a = 10, b = 5;printf ("a = %d, &a = %p\n", a, &a);printf ("b = %d, &b = %p\n", b, &b);printf ("temp = %d, &temp = %p\n", temp, &temp);printf ("\n------------------------\n");temp = a;a = b;b = temp; printf ("a = %d, &a = %p\n", a, &a);printf ("b = %d, &b = %p\n", b, &b);printf ("temp = %d, &temp = %p\n", temp, &temp);return 0; } 輸出結果： a = 10, &a = 0xbffd3b98 b = 5, &b = 0xbffd3b9c temp = 0, &temp = 0xbffd3b94------------------------ a = 5, &a = 0xbffd3b98 b = 10, &b = 0xbffd3b9c temp = 10, &temp = 0xbffd3b94以123為例分析全排列，以最高位為基準，交換后兩位。 1 23?1 32 2 13 ?2 31 3 12 ?3 21 理解明白了再看遞歸實現： #include <stdio.h> //此處為引用,交換函數.函數調用多,故定義為內聯函數. void swap (char *a , char *b) { char temp ; temp = *a; *a = *b; *b = temp; } void perm (char list[], int k, int m) //k表示前綴的位置,m是要排列的數目. { int i; if(k == m -1) //前綴是最后一個位置,此時打印排列數. { for(i = 0; i < m ;i++) printf ("%c", list[i]); printf ("\n"); } else { for(i = k ;i < m; i++) { //交換前綴,使之產生下一個前綴. swap (&list[k], &list[i]); perm (list, k + 1, m); //將前綴換回來,繼續做上一個的前綴排列. swap (&list[k], &list[i]); } } } int main (void) { char list[] ="123"; perm (list, 0, 3); return 0; } 輸出結果： 123 132 213 231 321 312 上面那種遞歸方式如果加條語句打印 i，就更加清楚了: 0 1 123 2 132 1 1 213 2 231 2 1 321 2 312如果不太喜歡這種方式，覺得難以理解，下面的方式不錯： #include <stdio.h> void Permutation(char* pStr, char* pBegin); void permutation(char* pStr) { Permutation(pStr, pStr); } void swap (char *a, char *b) { char temp; temp = *a; *a = *b; *b = temp; } void Permutation(char* pStr, char* pBegin) { char *pCh; if(!pStr || !pBegin) return; if(*pBegin == '\0') { printf("%s\n", pStr); } else { for(pCh = pBegin; *pCh != '\0'; pCh++) { // swap pCh and pBegin swap (pCh, pBegin); Permutation(pStr, pBegin + 1); // restore pCh and pBegin swap (pCh, pBegin); } } } int main() { char str[] ="123"; permutation(str); return 0; } 輸出結果： 123 132 213 231 321 312

5、strlen函數實現

之前將字符串函數的時候講過它的函數實現，參看：C語言再學習 -- 字符串和字符串函數 #include <stdio.h>int strlen (const char *s) {const char *sc = s;int cnt = 0;while (*sc != '\0'){sc++;cnt++;}return cnt; }int main (void) {printf ("%d\n", strlen ("12345"));return 0; } 輸出結果： 5那么用遞歸的話該怎么實現呢，很簡單： #include <stdio.h>int strlen (const char *s) {if (NULL == s)return -1;else if (*s == '\0')return 0;elsereturn strlen (s + 1) + 1; }int main (void) {printf("strlen(\"12345\") = %d\n", strlen("12345")); printf("strlen(NULL) = %d\n", strlen(NULL)); printf("strlen(\"\") = %d\n", strlen("")); return 0; } 輸出結果： strlen("12345") = 5 strlen(NULL) = -1 strlen("") = 0遞歸講完了，總結下來就是遞歸很難理解，而且耗時。在特定的情況下使用還行，否則還是別用了吧！

總結

以上是生活随笔為你收集整理的数据结构与算法 -- 再论递归的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。