第一個人10歲java遞歸
1.漢諾塔問題
import javax.swing.JOptionPane;
public class Hanoi {
private static final String DISK_B = "diskB";
private static final String DISK_C = "diskC";
private static final String DISK_A = "diskA";
static String from=DISK_A;
static String to=DISK_C;
static String mid=DISK_B;
public static void main(String[] args) {
String input=JOptionPane.showInputDialog("please input the number of the disks you want me move.");
int num=Integer.parseInt(input);
move(num，from，mid，to);
}
private static void move(int num， String from2， String mid2， String to2) {
if(num==1){
System.out.println("move disk 1 from "+from2+" to "+to2);
}
else {
move(num-1，from2，to2，mid2);
System.out.println("move disk "+num+" from "+from2+" to "+to2);
move(num-1，mid2，from2，to2);
}
}
}
2. 這是一個排列的例子，它所做的工作是將輸入的一個字元串中的所有元素進行排序並輸出，例如：你給出的參數是"abc" 則程序會輸出：
abc
acb
bac
bca
cab
cba
(1)演算法的出口在於：low=high也就是現在給出的排列元素只有一個時。
(2)演算法的逼近過程：先確定排列的第一位元素，也就是循環中i所代表的元素，
然後low+1開始減少排列元素，如此下去，直到low=high
public static void permute(String str) {
char[] strArray = str.toCharArray();
permute(strArray， 0， strArray.length - 1);
}
public static void permute(char[] list， int low， int high) {
int i;
if (low == high) {
String cout = "";
for (i = 0; i <= high; i++)
cout += list[i];
System.out.println(cout);
} else {
for (i = low; i <= high; i++) {
char temp = list[low];
list[low] = list[i];
list[i] = temp;
permute(list， low + 1， high);
temp = list[low];
list[low] = list[i];
list[i] = temp;
}
}
}
3。這是一個組合的例子，與上述的例子相似，只是它所做的工作是，輸出所給字元串中制定數目的元素的組合種類
(1)程序出口在於n=1，此時只要輸出目標數組的所有元素即可
(2)逼近過程，當n>1的時候，我們先取第一個元素放入目標數組中，然後n-1，如此下去，最後出來。
import javax.swing.JOptionPane;
public class Combination {
/**
* @param args
*/
public static void main(String[] args) {
String input = JOptionPane.showInputDialog("please input your String： ");
String numString = JOptionPane.showInputDialog("please input the number of your Combination： ");
int num = Integer.parseInt(numString);
Combine(input， num);
}
private static void Combine(String input， int num) {
char[] a = input.toCharArray();
String b = "";
Combine(a， num， b， 0， a.length);
}
private static void Combine(char[] a， int num， String b， int low， int high) {
if (num == 0) {
System.out.println(b);
} else {
for (int i = low; i < a.length; i++) {
b += a[i];
Combine(a， num - 1， b， i+1， a.length);
b=b.substring(0， b.length()-1);
}
}
}
}
『貳』 用遞歸方法。已知第一位學生的年齡最小為10歲，其餘學生一個比一個大兩歲，求第五位學生的年齡。
看你最後一行，printf裡面age()的應該是5，不是age(n)。
『叄』 C語言 用遞歸方法計算學生的年齡，已知第一位學生年齡最小，為10歲，其餘學生一個比一個大2歲，
#include<stdio.h>
#defineN10
intage(intx)
{
宏擾嘩絕旅亂凳if(x==1)returnN;
returnage(x-1)+2;
}
intmain()
{
printf("%d ",age(5));
return0;
}
『肆』 java中遞歸演算法是什麼怎麼算的
一、遞歸演算法基本思路：
Java遞歸演算法是基於Java語言實現的遞歸演算法。遞歸演算法是一種直接或者間接調用自身函數或者方法的演算法。遞歸演算法實質是把問題分解成規模縮小的同類問題的子問題，然後遞歸調用方法表示問題的解。遞歸往往能給我們帶來非常簡潔非常直觀的代碼形式，從而使我們的編碼大大簡化，然而遞歸的思維確實跟我們的常規思維相逆的，通常都是從上而下的思維問題，而遞歸趨勢從下往上的進行思維。
二、遞歸演算法解決問題的特點：
【1】遞歸就是方法里調用自身。
【2】在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。
【3】遞歸演算法代碼顯得很簡潔，但遞歸演算法解題的運行效率較低。所以不提倡用遞歸設計程序。
【4】在遞歸調用的過程中系統為每一層的返回點、局部量等開辟了棧來存儲。遞歸次數過多容易造成棧溢出等，所以一般不提倡用遞歸演算法設計程序。
【5】在做遞歸演算法的時候，一定把握出口，也就是做遞歸演算法必須要有一個明確的遞歸結束條件。這一點是非常重要的。其實這個出口就是一個條件，當滿足了這個條件的時候我們就不再遞歸了。
三、代碼示例：
publicclassFactorial{
//thisisarecursivefunction
intfact(intn){
if(n==1)return1;
returnfact(n-1)*n;
}}publicclassTestFactorial{publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Factorialfactorial=newFactorial();
System.out.println("factorial(5)="+factorial.fact(5));
}
}代碼執行流程圖如下：
此程序中n=5就是程序的出口。
『伍』 遞歸演算法怎麼理解
問題一：遞歸演算法還不是很理解!!高手教一教! 遞歸（recursion）是指把一個大的問題轉化為同樣形式但小一些的問題加以解決的方法。C語言允許一個函數調用它本身，這就是遞歸調用。即在調用一個函數的過程中又直接或間接地調用函數本身。不加控制的遞歸都是無終止的自身調用，程序中是絕對不應該出現這種情況的。為了防止無休止的遞歸，程序中應控制遞歸的次數，在某條件成立時進行遞歸，條件不成立不進行遞歸調用。並且在遞歸的調用過程中，不斷改變遞歸的條件，以使遞歸條件不再成立。
同一問題可能既可以用遞歸演算法解決，也可以用非遞歸演算法解決，遞歸往往演算法設計簡單，出奇制勝，而普通演算法（通常用循環解決）往往設計稍復雜。但執行效率遞歸演算法遜於循環演算法。遞歸反復調用自己，需要佔用較多內存和計算機時間。但有一些問題只有用遞歸方法才能解決，如著名的漢諾塔問題。
遞歸程序設計的關鍵就是考慮問題的兩種情況，一種是普遍情況即函數值等於把問題遞推一步後的本函數的調用，一種是極端或端點情況，此時函數值有確定的一個值而無須再調用本函數。遞歸的過程就是從普遍情況逐步過渡到端點情況的過程。
例子：
5個坐在一起論年齡，問第五個人多少歲？他說比第四個人大兩歲。問第四個人多少歲，他說比第三個人大兩歲。問第三個人多少歲，他說比第二個人大兩歲。問第二個人多少歲，他說比第一個人大兩歲。問第一個人多少歲，他說10歲。請問第五個人幾歲？
int age(int n)
{ int x;
if(n>1) x=age(n-1)+2;
else if(n==1) x=10;
return x;
}
void main( )
{ printf(%d,age(5));}
問題二：什麼是遞歸演算法 遞歸演算法就是一個函數通過不斷對自己的調用而求得最終結果滾咐的一種思維巧妙但是開銷很大的演算法。
比如：
漢諾塔的遞歸演算法：
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塊藉助hanno處函數的功能從B由A搬回到C 這樣的三步實習了n塊由A經過B到C這樣一個功能，同樣你不用糾結於hanoi函數到底如何實現這個功能的，只要知道他有這么一個神奇的功能就行
最後：遞歸都有收尾的時候對吧，收尾就是當只有一塊的時候漢諾塔怎麼個玩法呢？很簡單吧，直接把那一塊有Amove到C我們就完成了，所以hanoni這個函數最後還要加上 if(n==1)move(one,three);（當只有一塊時，直接有Amove到C位置就行）這么一個條件就能實現hanoin函數n>=1時......>>
問題三：怎麼更好地終極理解遞歸演算法 遞歸的基本思想是把規模大的問題轉化為規模小的相似的子問題來解決。在函數實現時，因為解決大問題的方法和解決小問題的方法往往是同一個方法，所以就產生了函數調用它自身的情況。另外這個解決問題的函數必須有明顯的結束條件，這樣就不會產生無限遞歸的情況了。
需注意的是，規模大轉化為規模小是核心思想，但遞歸並非是只做這步轉化，而是把規模大的問題分解為規模小的子問題和可以在子問題解決的基礎上剩餘的可以自行解決的部分。而後者就是歸的精髓所在，是在實際解決問題的過程。
問題四：怎樣才能深刻理解遞歸和回溯？ 遞歸的精華就在於大問題的分解，要學會宏觀的去看問題，如果這個大問題可分解為若干個性質相同的規模更小的問題，那麼我們只要不斷地去做分解，當這些小問題分解到我們能夠輕易解決的時候，大問題也就能迎刃而解了。如果你能獨立寫完遞歸創建二叉樹，前序、中序、後序遞歸遍歷以及遞歸計算二叉樹的最大深度，遞歸就基本能掌握了。
回溯本人用得很少，僅限於八皇後問題，所以幫不上啥了。
問題五：二叉樹的遞歸演算法到底該怎麼理解 這不就是在二叉排序樹上的遞歸查找，看程序
tree& find(const T& d, tree& t){
if(t==NULL) return t;如果二叉樹為空則返回空，查找失敗
if(t->data==d) return t;否則，如果當前根結點關鍵碼為d，則查找成功，當前根結點為待查找結點
if(d>t->data) return find(d, t->right);如果比根的關鍵碼大就遞歸查找右子樹
return find(d, t->left);如果比根的關鍵碼小就遞歸查找左子樹
}
二叉樹的遞歸定義的含義就是非空二叉樹，除了根以外，左右子樹都是二叉樹（可以為空）
問題六：怎麼理解遞歸演算法?我看了代碼但還是不理解? 函數自己調用自己就是遞歸啊。
從前有座山，山裡有座廟，廟里有個老和尚給小和尚講故事。講的內容是：
從前有座山，山裡有座廟，廟里有個老和尚給小和尚講故事，講
從前有座山，山裡有座廟，廟里有個老和尚給小和尚講故事……
跟循環差不多。而且浪費棧空間，效率不高。能夠轉化為循環最好。
問題七：數據結構中的二叉樹中的遞歸怎麼理解？ 以中序遍歷為例，思想是：
若二叉樹為空，則空操作；否則
（1）中序遍歷左子樹
（中序遍歷左子樹時也是這三步）
（2）訪問根結點
（3）中序遍歷右子樹
（當然右子樹也是重復著三步）
示例代碼：
int InOrderTraverse(BiTree T)
{
if(T)
{
InOrderTraverse(T->lchild);
printf(%d\t,T->data);
InOrderTraverse(T->rchild);
}
return OK;
}
問題八：java遞歸演算法，怎麼理解？？？ n! = (n-1)*n！
簡單理解，就是目前的所有任務，等於前面所有的任務+現在的任務。
比如你求 1。。。100的加法總和
實際上是 1... 99 的加法總和 + 100 就是了。
這就是遞歸的來源。
你只需要計算你前一步的任務，然後加上自己，就OK了。
前一步，在再次調用前前一步......
問題九：新手一個，有什麼更好理解遞歸的方法嗎？（c++） 遞歸的話就是重復調用方法直到滿足條件為止就停止這個方法，就跟循環類似，不過循環使用的方法一邊比較簡單
問題十：遞歸的原理解釋 遞歸的底層實現其實是一個棧.棧的特點是後進先出,也就是最後進入棧的事件是最先被處理的.
遞歸就是這樣運作.比如計算階乘函數F(n)=n!=n*F(n-1)=....
寫成遞歸,我用java
public static long F(long num){
if(num
『陸』 Java遞歸調用第一個為10每次加2，連續5次
int i=0;
int n=10;
while(i<豎模拆余棗碼塵5){
n += i*2;
i++;
}
『柒』 (編程題)第一個人10歲，第二個人比第一個人大2歲，以此類推，請用遞歸演算法求出第8個人多大
def getAge(k):
if k==1:
return 10
else:
return getAge(k-1)+2print (getAge(8))
結碧余兆果悔租毀帆24
『捌』 java遞歸如何理解
可以理解為遞歸,就是自己調用自己而已.每個遞歸都有一個結束條件辯亂.這薯埋個遞歸的結束條件就是a==1;
當a==1的時候,終止遞歸,return 1.這數灶螞個 1 給上一層調用者.也即是 plus(2)
簡單的說可以理解為, plus(10)=plus(9)+10.
plus(9)=plus(8)+9
以此類推
plus(2)=plus(1)+2
plus(2)=1(plus(1),既a==1，遞歸結束,renturn 1)+2
『玖』 如何使用java實現一個簡單的遞歸程序
【答案】：這是一個排列的例子，它胡亂所做的工作是將輸入的一個字元串中的所有元素進行排序並輸出，例如：你給出的參數是」abc」 則程序會輸出： abc acb bac bca cab cba a.演算法的出口在於：low=high也就是現在給出的排列元素只有一個時。 b.演算法的逼近過程：先確臘游定排列的第一位元素，也就是循環中i所代表的元素， 然後low+1開始褲局檔減少排列元素，如此下去，直到low=high public class Foo {
public static void main(String[] args) {
permute(「abc」);
}
public static void permute(String str) {
char[] strArray = str.toCharArray();
permute(strArray, 0, strArray.length – 1);
}
public static void permute(char[] list, int low, int high) {
int i;
if (low == high) {
String cout = 「」;
for (i = 0; i <= high; i++)
cout += list[i];
System.out.println(cout);
} else {
for (i = low; i <= high; i++) {
char temp = list[low];
list[low] = list[i];
list[i] = temp;
permute(list, low + 1, high);
temp = list[low];
list[low] = list[i];
list[i] = temp;
}
}
}
}