第一个人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;
}
}
}
}