java什么是递归算法

❶ java中递归的作用是什么为什么要用到递归

你的两个问题其实是一个问题，对吧。
递归的作用：递归算法可以解决一些通过递归定义的题目。
首先需要明白什么是递归定义的题目，通俗一点来说就是一个大问题中蕴含着小问题，而小问题同时又与大问题的结构相同，只是规模更小。
比如n阶乘的定义可以理解为：
n！= n*(n-1)!
从上面不难看出 (n-1)! 就是比n! 规模更小的问题，按照此方法不断分解下去，就能得到最初的一些基本的已知的数据。然后反过来就可以求出最终的结果了。
n的阶乘算法如下：
private static int jieCheng(int n) {
if(n == 1)
return 1;
else {
return n*jieCheng(n-1);
}
}
还有就是数据结构中二叉树的定义，也是递归定义的。因此二叉树的好多操作都是通过递归实现的。
用递归会使程序相当简洁。

❷ java 递归 定义是什么请举出个简单的例子，谢谢

一个类的定义方法：
public class Node
{
int value;
Node next;
以下有一些set,get方法及构造方法
}
一个类的成员是当前类

一个方法：
public int f(int n)
{
if(n<=1)
return 1;
else
return n+f(n-1);
}
以上是求1-n的累加
该方法调用了该方法自己

❸ JAVA如何理解递归

//这个是一个使用递归算法求某数阶乘的例子
//如果求5的阶乘，即求5*4*3*2*1
//即5×4的阶乘……如此类推

public class Test {//主类

public static void main(String[] args) {//主方法

System.out.print(Test.digui(5));//调用用于求阶乘的静态方法

}

public static int digui(int i){//求阶乘的方法，接收一个整数，求该数的阶乘

if(i==1){//当该数是1时，是递归的出口，递归一定要先设置出口，避免无限循环

return 1;

}else{

return i*digui(i-1); //这里就是递归，即方法调用自身。

}
}

}

❹ 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就是程序的出口。

❺ java中，递归什么方法怎么用

public static void main(String args[]) {
System.out.println(plus(3));
｝
static int count = 0;

public static int plus(int i) {
if (i > 10) {
} else {
count = i + plus(i + 1);
}
//System.out.println(count);
return count;
}
这就是一个最简单的递归

❻ 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);
}
}
}
}

❼ JAVA中的递归方法，求讲一下。

自己调用自己或几个方法相互调用。

最经典的是求正整数阶的算法：

int fact(int i){

if(i<=1)return 1;

return fact(i-1)*i;

}

多数递归方法可以转换成非递归方法。

一般同功能的非递归方法，执行效率要优于递归方法。但合理的使用递归方法，可以使代码结构更清晰，更有可读性，从而更方便维护。

❽ 用java递归方法实现

publicintfun(intn){
if(n==0||n==1)return1;
returnn*fun(n-1);
}

❾ java递归算法，怎么理解

n!=(n-1)*n！
简单理解，就是目前的所有任务，等于前面所有的任务+现在的任务。
比如你求1。。。100的加法总和
实际上是1...99的加法总和+100就是了。
这就是递归的来源。
你只需要计算你前一步的任务，然后加上自己，就OK了。
前一步，在再次调用前前一步......

❿ 请问大家java中递归算法,希望有详细解释

publicclassTest{
publicstaticintresult(intparameter){
if(parameter<=1)return1;//判断parameter是否小于等于1,如果不成立则递归调用
intnumber=parameter*result(parameter-1);//将parameter-1继续调用函数反复如此，直至条件成立。
returnnumber;
}
publicstaticvoidmain(String[]args{
intresult=result(5);
System.out.println(result);
}
}

它的执行原理是如下这样的：

result(5) 初始时 ==》进入函数体判断parameter是否小于等于1,此时parameter等于5，条件不成立，执行parameter*result(parameter-1) 即5*result(5-1),程序反复执行。。。

5*result(5-1)

4*result(4-1)

3*result(3-1)

2*result(2-1) 到此 parameter等于1符合条件 函数返回1，层层返回。即：

result(1) =1

2*result(1)=2*1=2

3*result(2)=3*2=6

4*result(3)=4*6=24

5*result(4)=5*24=120