什麼是遞歸程序

❶ 遞歸程序

while(w>0)
{pro(w-10);
printf("%d",w);
pro(w-1);
}

當w＝1時，這個while中的w始終沒有變化，當然是死循環。

❷ 遞歸程序和非遞歸程序的優缺點是什麼

遞歸代碼少，設計到遞推和回歸兩個過程，邏輯理解困難， 務必避免調用層次過多，和調用堆棧使用的棧內存過大，可能導致stack overflow
非遞歸就是正常寫法了，遞歸的都能改成非遞歸的
遞歸演算法必須寫的很精確，否則容易造成死循環

❸ 什麼是遞歸的概念

遞歸是一種重要的編程技術。該方法用於讓一個函數從其內部調用其自身。一個示例就是計算階乘。0 的階乘被特別地定義為 1。 更大數的階乘是通過計算 1 * 2 * ...來求得的，每次增加 1，直至達到要計算其階乘的那個數。

下面的段落是用文字定義的計算階乘的一個函數。

「如果這個數小於零，則拒絕接收。如果不是一個整數，則將其向下舍入為相鄰的整數。如果這個數為 0，則其階乘為 1。如果這個數大於 0，則將其與相鄰較小的數的階乘相乘。」

要計算任何大於 0 的數的階乘，至少需要計算一個其他數的階乘。用來實現這個功能的函數就是已經位於其中的函數；該函數在執行當前的這個數之前，必須調用它本身來計算相鄰的較小數的階乘。這就是一個遞歸示例。

遞歸和迭代（循環）是密切相關的 — 能用遞歸處理的演算法也都可以採用迭代，反之亦然。確定的演算法通常可以用幾種方法實現，您只需選擇最自然貼切的方法，或者您覺得用起來最輕松的一種即可。

顯然，這樣有可能會出現問題。可以很容易地創建一個遞歸函數，但該函數不能得到一個確定的結果，並且不能達到一個終點。這樣的遞歸將導致計算機執行一個「無限」循環。下面就是一個示例：在計算階乘的文字描述中遺漏了第一條規則（對負數的處理） ，並試圖計算任何負數的階乘。這將導致失敗，因為按順序計算 -24 的階乘時，首先不得不計算 -25 的階乘；然而這樣又不得不計算 -26 的階乘；如此繼續。很明顯，這樣永遠也不會到達一個終止點。

因此在設計遞歸函數時應特別仔細。如果懷疑其中存在著無限遞歸的可能，則可以讓該函數記錄它調用自身的次數。如果該函數調用自身的次數太多，即使您已決定了它應調用多少次，就自動退出。

所以你說的那個不是遞歸,頂多能算作遞推或迭代
int sum(int value)
{
if(value==0)return 0;
else return sum(value-1)+value;
}
main()
{
int result;
result=sum(100);
}
上面這才是遞歸

❹ 什麼是遞歸

遞歸：
遞歸是一種重要的編程技術。該方法用於讓一個函數從其內部調用其自身。一個示例就是計算階乘。0 的階乘被特別地定義為 1。 更大數的階乘是通過計算 1 * 2 * ...來求得的，每次增加 1，直至達到要計算其階乘的那個數。

下面的段落是用文字定義的計算階乘的一個函數。

「如果這個數小於零，則拒絕接收。如果不是一個整數，則將其向下舍入為相鄰的整數。如果這個數為 0，則其階乘為 1。如果這個數大於 0，則將其與相鄰較小的數的階乘相乘。」

要計算任何大於 0 的數的階乘，至少需要計算一個其他數的階乘。用來實現這個功能的函數就是已經位於其中的函數；該函數在執行當前的飧鍪��埃�匭氳饔盟�舊砝醇撲閬嗔詰慕閑∈�慕壯恕U餼褪且桓齙莨槭糾�?

遞歸和迭代（循環）是密切相關的 — 能用遞歸處理的演算法也都可以採用迭代，反之亦然。確定的演算法通常可以用幾種方法實現，您只需選擇最自然貼切的方法，或者您覺得用起來最輕松的一種即可。

顯然，這樣有可能會出現問題。可以很容易地創建一個遞歸函數，但該函數不能得到一個確定的結果，並且不能達到一個終點。這樣的遞歸將導致計算機執行一個「無限」循環。下面就是一個示例：在計算階乘的文字描述中遺漏了第一條規則（對負數的處理） ，並試圖計算任何負數的階乘。這將導致失敗，因為按順序計算 -24 的階乘時，首先不得不計算 -25 的階乘；然而這樣又不得不計算 -26 的階乘；如此繼續。很明顯，這樣永遠也不會到達一個終止點。

因此在設計遞歸函數時應特別仔細。如果懷疑其中存在著無限遞歸的可能，則可以讓該函數記錄它調用自身的次數。如果該函數調用自身的次數太多，即使您已決定了它應調用多少次，就自動退出。

下面仍然是階乘函數，這次是用 JScript 代碼編寫的。

// 計算階乘的函數。如果傳遞了
// 無效的數值（例如小於零），
// 將返回 -1，表明發生了錯誤。若數值有效，
// 把數值轉換為最相近的整數，並
// 返回階乘。
function factorial(aNumber) {
aNumber = Math.floor(aNumber); // 如果這個數不是一個整數，則向下舍入。
if (aNumber < 0) { // 如果這個數小於 0，拒絕接收。
return -1;
}
if (aNumber == 0) { // 如果為 0，則其階乘為 1。
return 1;
}
else return (aNumber * factorial(aNumber - 1)); // 否則，遞歸直至完成。
}

詳見：http://61.50.172.137/shengc/java/java2tutorial/chapter6/chapter6-6.htm

❺ 遞歸是什麼意思

程序調用自身的編程技巧稱為遞歸（ recursion）。

構成遞歸需具備的條件有：

1、子問題須與原始問題為同樣的事，且更為簡單。

2、不能無限制地調用本身，須有個出口，化簡為非遞歸狀況處理。

遞歸做為一種演算法在程序設計語言中廣泛應用。 一個過程或函數在其定義或說明中有直接或間接調用自身的一種方法，它通常把一個大型復雜的問題層層轉化為一個與原問題相似的規模較小的問題來求解，遞歸策略只需少量的程序就可描述出解題過程所需要的多次重復計算，大大地減少了程序的代碼量。

(5)什麼是遞歸程序擴展閱讀：

遞歸一般用於解決三類問題：

1、數據的定義是按遞歸定義的。（Fibonacci函數，n的階乘）

2、問題解法按遞歸實現。（回溯）

3、數據的結構形式是按遞歸定義的。（二叉樹的遍歷，圖的搜索）

遞歸的缺點：

遞歸解題相對常用的演算法如普通循環等，運行效率較低。因此，應該盡量避免使用遞歸，除非沒有更好的演算法或者某種特定情況，遞歸更為適合的時候。在遞歸調用的過程當中系統為每一層的返回點、局部量等開辟了棧來存儲，因此遞歸次數過多容易造成棧溢出。

❻ 什麼是遞歸調用，詳細點

C通過運行時堆棧支持遞歸函數的實現。遞歸函數就是直接或間接調用自身的函數。
許多教科書都把計算機階乘和菲波那契數列用來說明遞歸，非常不幸我們可愛的著名的老潭老師的《C語言程序設計》一書中就是從階乘的計算開始的函數遞歸。導致讀過這本經書的同學們，看到階乘計算第一個想法就是遞歸。但是在階乘的計算里，遞歸並沒有提供任何優越之處。在菲波那契數列中，它的效率更是低的非常恐怖。
這里有一個簡單的程序，可用於說明遞歸。程序的目的是把一個整數從二進制形式轉換為可列印的字元形式。例如：給出一個值4267，我們需要依次產生字元『4』，『2』，『6』，和『7』。就如在printf函數中使用了%d格式碼，它就會執行類似處理。
我們採用的策略是把這個值反復除以10，並列印各個余數。例如，4267除10的余數是7，但是我們不能直接列印這個余數。我們需要列印的是機器字元集中表示數字『7』的值。在ASCII碼中，字元『7』的值是55，所以我們需要在余數上加上48來獲得正確的字元，但是，使用字元常量而不是整型常量可以提高程序的可移植性。『0』的ASCII碼是48，所以我們用余數加上『0』，所以有下面的關系：
『0』+ 0 =『0』
『0』+ 1 =『1』
『0』+ 2 =『2』
...

從這些關系中，我們很容易看出在余數上加上『0』就可以產生對應字元的代碼。接著就列印出余數。下一步再取商的值，4267/10等於426。然後用這個值重復上述步驟。
這種處理方法存在的唯一問題是它產生的數字次序正好相反，它們是逆向列印的。所以在我們的程序中使用遞歸來修正這個問題。
我們這個程序中的函數是遞歸性質的,因為它包含了一個對自身的調用。乍一看，函數似乎永遠不會終止。當函數調用時，它將調用自身，第2次調用還將調用自身，以此類推，似乎永遠調用下去。這也是我們在剛接觸遞歸時最想不明白的事情。但是，事實上並不會出現這種情況。
這個程序的遞歸實現了某種類型的螺旋狀while循環。while循環在循環體每次執行時必須取得某種進展，逐步迫近循環終止條件。遞歸函數也是如此，它在每次遞歸調用後必須越來越接近某種限制條件。當遞歸函數符合這個限制條件時，它便不在調用自身。
在程序中，遞歸函數的限制條件就是變數quotient為零。在每次遞歸調用之前，我們都把quotient除以10，所以每遞歸調用一次，它的值就越來越接近零。當它最終變成零時，遞歸便告終止。

/*接受一個整型值（無符號0，把它轉換為字元並列印它，前導零被刪除*/

#include <stdio.h>

int binary_to_ascii( unsigned int value)
{
unsigned int quotient;

quotient = value / 10;
if( quotient != 0)
binary_to_ascii( quotient);
putchar ( value % 10 + '0' );
}

遞歸是如何幫助我們以正確的順序列印這些字元呢？下面是這個函數的工作流程。
1. 將參數值除以10
2. 如果quotient的值為非零，調用binary-to-ascii列印quotient當前值的各位數字

3. 接著，列印步驟1中除法運算的余數
注意在第2個步驟中，我們需要列印的是quotient當前值的各位數字。我們所面臨的問題和最初的問題完全相同，只是變數quotient的值變小了。我們用剛剛編寫的函數（把整數轉換為各個數字字元並列印出來）來解決這個問題。由於quotient的值越來越小，所以遞歸最終會終止。
一旦你理解了遞歸，閱讀遞歸函數最容易的方法不是糾纏於它的執行過程，而是相信遞歸函數會順利完成它的任務。如果你的每個步驟正確無誤，你的限制條件設置正確，並且每次調用之後更接近限制條件，遞歸函數總是能正確的完成任務。
但是，為了理解遞歸的工作原理，你需要追蹤遞歸調用的執行過程，所以讓我們來進行這項工作。追蹤一個遞歸函數的執行過程的關鍵是理解函數中所聲明的變數是如何存儲的。當函數被調用時，它的變數的空間是創建於運行時堆棧上的。以前調用的函數的變數扔保留在堆棧上，但他們被新函數的變數所掩蓋，因此是不能被訪問的。
當遞歸函數調用自身時，情況於是如此。每進行一次新的調用，都將創建一批變數，他們將掩蓋遞歸函數前一次調用所創建的變數。當我追蹤一個遞歸函數的執行過程時，必須把分數不同次調用的變數區分開來，以避免混淆。

❼ 什麼是遞歸函數 怎樣實現遞歸

遞歸就是一個函數在它的函數體內調用它自身。執行遞歸函數將反復調用其自身，每調用一次就進入新的一層。遞歸函數必須有結束條件。

當函數在一直遞推，直到遇到牆後返回，這個牆就是結束條件。

所以遞歸要有兩個要素，結束條件與遞推關系。

遞歸有兩個基本要素：

（1）邊界條件：確定遞歸到何時終止，也稱為遞歸出口。

（2）遞歸模式：大問題是如何分解為小問題的，也稱為遞歸體。遞歸函數只有具備了這兩個要素，才能在有限次計算後得出結果

在遞歸函數中，調用函數和被調用函數是同一個函數，需要注意的是遞歸函數的調用層次，如果把調用遞歸函數的主函數稱為第0層，進入函數後，首次遞歸調用自身稱為第1層調用；從第i層遞歸調用自身稱為第i+1層。反之，退出第i+1層調用應該返回第i層。

一個遞歸函數的調用過程類似於多個函數的嵌套的調用，只不過調用函數和被調用函數是同一個函數。為了保證遞歸函數的正確執行，系統需設立一個工作棧。具體地說，遞歸調用的內部執行過程如下：

（1）運動開始時，首先為遞歸調用建立一個工作棧，其結構包括值參、局部變數和返回地址；

（2）每次執行遞歸調用之前，把遞歸函數的值參和局部變數的當前值以及調用後的返回地址壓棧；

（3）每次遞歸調用結束後，將棧頂元

(7)什麼是遞歸程序擴展閱讀：

遞歸就是某個函數直接或間接地調用了自身，這種調用方式叫做遞歸調用。說白了，還是函數調用。既然是函數調用，那麼就有一個雷打不動的原則：所有被調用的函數都將創建一個副本，各自為調用者服務，而不受其他函數的影響。

你的ff函數，遞歸多少次，就有多少個副本，再利用內存的棧式管理，反向退出。這個最好找一下「棧」這方面的東西看看，挺容易的，就像子彈匣一樣，先進後出。

從某種意義上說，這是不對的，因為就像剛才說的，一旦被調用，他將在內存中復制出一份代碼，再被調用就再復制一份，換句話說，你可以吧同一個函數的多次調用理解稱謂多個不同函數的一次調用，這樣也會會簡單些。

再說=1和=0是為什麼退出。遞歸，很需要注意的就是死遞歸，也就是說，某一個函數進入了無限調用自身的情況，永無止境地消耗內存等資源，這在編程方面是一大忌。

但凡是遞歸的函數，一定會在某一個地方存在能夠返回上一層函數的代碼，否則必定死遞歸。ff函數中，那個else就是返回的出口，你可以這樣想，如果沒有那個if來進行判斷，你遞歸到什麼時候算完？ff是不是會一直調用自己。

因為一旦某個函數A中調用了函數B（或者自己），那麼A中的代碼會停在調用的位置，而轉向B中去執行，同理，如果B又調用函數C，那麼B又停在調用的位置，去執行C，如果無限調用，那麼程序是永遠不會結束的。

當然，也有這種情況，A調用B，然後繼續自己的代碼，不管B的死活，這種不在我們的討論范圍內，因為那牽扯到另一種編程方式：多線程。

❽ 什麼是遞歸調用

遞歸調用是一種特殊的嵌套調用，是某個函數調用自己或者是調用其他函數後再次調用自己的，只要函數之間互相調用能產生循環的則一定是遞歸調用，遞歸調用一種解決方案，一種是邏輯思想，將一個大工作分為逐漸減小的小工作。

遞歸函數特點：

1、函數要直接或間接調用自身。

2、要有遞歸終止條件檢查，即遞歸終止的條件被滿足後，則不再調用自身函數。

3、如果不滿足遞歸終止的條件，則調用涉及遞歸調用的表達式。在調用函數自身時，有關終止條件的參數要發生變化，而且需向遞歸終止的方向變化。

(8)什麼是遞歸程序擴展閱讀：

遞歸調用的過程：

遞歸調用之前的語句是從上到下的，函數調用之後的語句呢是從下到上的，因為後面的語句要等最下層或者最裡面最後調用的那個函數執行之後不再調用了開始執行，然後返回上一層的時候再執行上一層函數調用後面的語句。並且特別注意的是，每次函數返回後直接就是函數調用後面的語句。

遞歸其實就是利用了函數調用的一些特點，很巧妙的不斷調用自己，把一個很大的問題分成了很多部分，讓每一個函數解決一部分，並且上一層的結果編譯器給我們保留了起來，返回的時候還能用。

所以遞歸調用一定要是每深入一層都會把問題變得越來越小，而且最後能解決，不然就會無限制的調用自己，形成一個無限的循環，最後造成棧的溢出，最後程序崩潰。

❾ 什麼是遞歸演算法

遞歸演算法就是一個函數通過不斷對自己的調用而求得最終結果的一種思維巧妙但是開銷很大的演算法。
比如：
漢諾塔的遞歸演算法：
void move(char x,char y){
printf("%c-->%c\n",x,y);
}

void hanoi(int n,char one,char two,char three){
/*將n個盤從one座藉助two座，移到three座*/
if(n==1) move(one,three);
else{
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}

main(){
int n;
printf("input the number of diskes:");
scanf("%d",&n);
printf("The step to moving %3d diskes:\n",n);
hanoi(n,'A','B','C');
}
我說下遞歸的理解方法
首先：對於遞歸這一類函數，你不要糾結於他是干什麼的，只要知道他的一個模糊功能是什麼就行，等於把他想像成一個能實現某項功能的黑盒子，而不去管它的內部操作先，好，我們來看下漢諾塔是怎麼樣解決的
首先按我上面說的把遞歸函數想像成某個功能的黑盒子，void hanoi(int n,char one,char two,char three); 這個遞歸函數的功能是：能將n個由小到大放置的小長方形從one 位置，經過two位置 移動到three位置。那麼你的主程序要解決的問題是要將m個的"漢諾塊"由A藉助B移動到C，根據我們上面說的漢諾塔的功能，我相信傻子也知道在主函數中寫道：hanoi(m,A,B,C)就能實現將m個塊由A藉助B碼放到C，對吧？所以，mian函數裡面有hanoi(m,'A','C','B');這個調用。
接下來我們看看要實現hannoi的這個功能，hannoi函數應該幹些什麼？
在hannoi函數里有這么三行
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
同樣以黑盒子的思想看待他，要想把n個塊由A經過B搬到C去，是不是可以分為上面三步呢？
這三部是：第一步將除了最後最長的那一塊以外的n-1塊由one位置經由three搬到two 也就是從A由C搬到B 然後把最下面最長那一塊用move函數把他從A直接搬到C 完事後 第三步再次將剛剛的n-1塊藉助hannoi函數的功能從B由A搬回到C 這樣的三步實習了n塊由A經過B到C這樣一個功能，同樣你不用糾結於hanoi函數到底如何實現這個功能的，只要知道他有這么一個神奇的功能就行
最後：遞歸都有收尾的時候對吧，收尾就是當只有一塊的時候漢諾塔怎麼個玩法呢？很簡單吧，直接把那一塊有Amove到C我們就完成了，所以hanoni這個函數最後還要加上 if(n==1)move(one,three);（當只有一塊時，直接有Amove到C位置就行）這么一個條件就能實現hanoin函數n>=1時將n個塊由A經由B搬到C的完整功能了。
遞歸這個復雜的思想就是這樣簡單解決的，呵呵 不知道你看懂沒？純手打，希望能幫你理解遞歸
總結起來就是不要管遞歸的具體實現細節步驟，只要知道他的功能是什麼，然後利用他自己的功能通過調用他自己去解決自己的功能（好繞口啊，日）最後加上一個極限情況的條件即可，比如上面說的1個的情況。

❿ 什麼是遞歸程序

很簡單，自己調用自己，我們最常說的：
從前有座山，山裡有座廟，廟里有個老和尚，有一天，老和尚給小和尚故事：
從前有座山，山裡有座廟，廟里有個老和尚，有一天，老和尚給小和尚故事：
從前有座山，山裡有座廟，廟里有個老和·····················
這就是一個標準的遞歸！
注意：必須要有結束的條件，這個例子就是沒有結束條件，成死循環了·····
可以加個，計數的，比如：n++，如果n==10，break或者return。
望採納！全手打！