「java递归算法原理」什么是递归算法?递归算法的特性?

今天给各位分享java递归算法原理的知识，其中也会对什么是递归算法?递归算法的特性?进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中递归算法是怎么算的？
• 2、递归的原理解释
• 3、JAVA中的递归方法，求讲一下。
• 4、JAVA程序经常用到“递归”,“递归”的基本思想是
• 5、请问大家java中递归算法,希望有详细解释
• 6、java中递归的作用是什么？为什么要用到递归？

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)逼近过程，当n1　的时候，我们先取第一个元素放入目标数组中，然后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; ia.length; i++) {

b += a[i];

Combine(a， num - 1， b， i+1， a.length);

b=b.substring(0， b.length()-1);

}

}

}

}

递归的原理解释

递归的底层实现其实是一个栈.栈的特点是后进先出,也就是最后进入栈的事件是最先被处理的.

递归就是这样运作.比如计算阶乘函数F(n)=n!=n*F(n-1)=....

写成递归,我用java

public static long F(long num){

if(num=1)

return 1;

return F(num-1)*num;

}

static public void main(String argv[]){

System.out.println(F(5));

}:

第一次计算的时候是F(num),进入之后会直接return F(num-1)*num.也就是把这一项入栈.

然后这一项到底是多少还不知道需要继续计算.

第二次递归就是 F(num-1-1)*(num-1).入栈.

直到满足num=1.计算出最后入栈的F(1)=1;return这句就限定了最终栈的大小.

然后开始出栈.第一个出栈的是F(1);已经计算得出是1;

第二个出栈是F(2).由F(1)可以得知F(2).

这样直到栈空,阶乘也就计算出来了.

递归的内部是栈实现的.理解了这个,你也可以自己写非递归的递归,也就是用栈实现的递归.

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

方法递归和循环语句差不多，打个比喻。方法递归是小明上楼拿东西，一楼，二楼，三楼……楼顶。在楼顶拿到想要的东西以后，你总不能直接跳下来吧。你得一层一层的返回下来。循环就是驴拉磨，你转多少圈都是在原地。变化的只是盘子里的东西有变化。方法递归不会进入死循环，但陷的太深系统会崩溃。

答得不好抱歉

JAVA程序经常用到“递归”,“递归”的基本思想是

递归的核心思想是分解。把一个很复杂的问题使用同一个策略将其分解为较简单的问题，如果这个的问题仍然不能解决则再次分解，直到问题能被直接处理为止。

比如求 1+1/2+1/3+...+1/n的和，如果按照我们正常的思维，就会使用一个循环，把所有的表示式的值加起来，这是最直接的办法。如果使用递归的思维，过程就是这样的，要求1+1/2+1/3+...+1/n的值，可以先求s1=1+1/2+1/3+...+1/(n-1)的值，再用s1加上1/n就是所求的值，而求s1的过程又可以使用上面的分解策略继续分解，最终分解到求1+1/2的值，而这个问题简单到我们可以直接解决，自此问题得到解决。

递归强调的分治的策略，再举个例子，有一种排序算法叫归并排序，其思想是这样的：要对一个无序的数组进行排序，可以将这个数组分解为2个小数组，然后对这两个数组分别排序，再把排好序的两个数组合并。而这一过程中只有“对两个数组分别排序”不是我们能解决的，但是这个问题可以使用上面的策略进行再次的分解，最后这个问题就被分解到对2个元素的数组进行排序，而这个问题简单到我们可以直接处理。

上面提到的分解的策略，或者说算法，抽象出来就是我们的函数，因为在这个过程中我们要不同的使用这个策略来不断的分解问题，所以代码上就体现为这个函数会不断的调用自身。还有一点，并不是所有的递归都是可以实现的，或者说有意义的。如果在分解的过程中，问题最终不能分解到一个可以直接解决的问题，则这个过程是没有意义，也就是无限的循环。

具体的代码都不贴了，有兴趣可以百度看看。

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

public class Test{

    public static int result(int parameter){

          if(parameter=1) return 1; // 判断parameter是否小于等于1,如果不成立则递归调用

          int number = parameter*result(parameter-1);  // 将parameter-1继续调用函数 反复如此，直至条件成立。                                            

             return number;

     }

    public static void main(String[]args{

          int result = 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

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递归算法原理和什么是递归算法?递归算法的特性?的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。