java递归算法代码（java递归算法的例子）

本文目录

• java递归算法的例子
• java递归算法
• java用递归算法求 1-2+3-4+5-6+
• 用java递归方法实现
• JAVA递归算法，1^2+2^2+3^2+.+n^2
• java算法分别用递归和递推方法编写
• java递归方法
• 用java递归算法求一个数字的阶乘

java递归算法的例子

阶乘：

要求：给定一个数值，计算出它的阶乘值，例如5的阶乘为5*4*3*2*1

实现：

[html] view plaincopy

《span style=“font-size:12px;“》  // 利用递归实现一个数的阶乘值      private static BigDecimal getNum(BigDecimal inNum) {          if (inNum.compareTo(BigDecimal.ONE) == 0) {              return inNum;          }          return inNum.multiply(getNum(inNum.subtract(BigDecimal.ONE)));      }《/span》  

（2）Fibonacci数列：1，1，2，3，5，8，13……

要求：找出数列中指定index位置的数值

实现：

[html] view plaincopy

《span style=“font-size:12px;“》  // 利用递归实现了Fibonacci数列      private static int fab(int index) {          if (index == 1 || index == 2) {              return 1;          } else {              return fab(index - 1) + fab(index - 2);          }      }《/span》  

（3）汉诺塔

要求：汉诺塔挪动

实现：

[html] view plaincopy

《span style=“font-size:12px;“》  《span style=“white-space:pre;“》 《/span》private static final String DISK_B = “diskB“;    《span style=“white-space:pre;“》   《/span》private static final String DISK_C = “diskC“;    《span style=“white-space:pre;“》   《/span》private static final String DISK_A = “diskA“;    《span style=“white-space:pre;“》   《/span》static String from=DISK_A;  《span style=“white-space:pre;“》 《/span》  static String to=DISK_C;  《span style=“white-space:pre;“》 《/span》  static String mid=DISK_B;    《span style=“white-space:pre;“》 《/span》  public static void main(String args) {  《span style=“white-space:pre;“》 《/span》      String input=JOptionPane.showInputDialog(“please input the number of the disks you want me move.“);  《span style=“white-space:pre;“》 《/span》      int num=Integer.parseInt(input);  《span style=“white-space:pre;“》 《/span》      move(num,from,mid,to);  《span style=“white-space:pre;“》 《/span》  }《/span》  

[html] view plaincopy

《span style=“font-size:12px;“》  // 利用递归实现汉诺塔      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);          }      }《/span》  

（4）排列组合

要求：将输入的一个字符串中的所有元素进行排序并输出，例如：你给出的参数是“abc“，

则程序会输出

abc

acb

bac

bca

cab

cba

实现：

[html] view plaincopy

《span style=“font-size:12px;“》《span style=“white-space:pre;“》   《/span》public static void permute(String str) {   《span style=“white-space:pre;“》    《/span》   char strArray = str.toCharArray();    《span style=“white-space:pre;“》   《/span》 permute(strArray, 0, strArray.length - 1);  《span style=“white-space:pre;“》 《/span》}《/span》  

[html] view plaincopy

《span style=“font-size:12px;“》  // 利用递归实现，将输入的一个字符串中的所有元素进行排序并输出      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];  

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用递归算法求 1-2+3-4+5-6+

思路：先用递归求出一个数的阶乘，接着for循环累加求和。参考代码：《pre t=“code“ l=“cpp“》#include《stdio.h》
int fun(int n){
if(n==1) return 1;//递归结束条件
return n*fun(n-1);//递归式
}
int main()
{
int sum=0,i;
for(i=1;i《=6;i++)//for循环累加求和
sum+=fun(i);
printf(“%d\n“,sum);
return 0;
}
/*
运行结果：
873
*/

用java递归方法实现

1、递归做为一种算法在程序设计语言中广泛使用，是指函数/过程/子程序在运行过程中直接或间接调用自身而产生的重入现象。
2、递归算法一般用于解决三类问题：

1）数据的定义是按递归定义的。（Fibonacci（斐波那契）的函数）
2）问题解法按递归算法实现。（回溯）

3）数据的结构形式是按递归定义的。（树的遍历，图的搜索）

JAVA递归算法，1^2+2^2+3^2+.+n^2

publicclassDigui{//递归算法:publicstaticdoubledigui(intn){doublesum=0.0;if(n==1){sum=1;}else{if(n%2==0){sum=1.0/n+digui(n-1);}else{sum=-1.0/n+digui(n-1);}}returnsum;}//非递归算法：publicstaticdoublefeidigui(intn){doublecount=0.0;StringBuffersb=newStringBuffer();for(doublei=1;i《=n;i++){if(i==1){count=1;sb.append(“n!=“+n+“!=1“);}else{if(i%2==0){count=count+1/i;sb.append(“+1/“+(int)i);}else{count=count-1/i;sb.append(“-1/“+(int)i);}}}System.err.println(sb.toString());returncount;}publicstaticvoidmain(Stringargs){intn=10;doubledigui=feidigui(n);doublefeidigui=digui(n);System.out.println(“递归算法：“+n+“!=“+digui);System.out.println(“非递归算法：“+n+“!=“+feidigui);}}运行结果如下：n!=10!=1+1/2-1/3+1/4-1/5+1/6-1/7+1/8-1/9+1/10递归算法：10!=1.3543650793650797非递归算法：10!=1.3543650793650797

java算法分别用递归和递推方法编写

//递归
private static double wages1(int n)
{
if (n 《= 0)
{
return 0;
}
else if (n == 1)
{
return 1500*12;
}
else
{
return wages1(n-1) * 1.1;
}
}
//递推
private static double wages2(int n)
{
if (n 《= 0)
{
return 0;
}
double wages = 1500 * 12;
for (int i = 1; i 《 n ; i++)
{
wages *= 1.1;
}
return wages;
}

java递归方法

一般递归只实现一个方向的逻辑，把两个方向的逻辑放到一方法里并不好，不容易控制，实现也很麻烦，考虑到维护时的难度请不要在实际项目中使用。
搞了好一会，搞出个这样的输出2N-1行星号，中间最长的一行不重复，如果楼主希望重复中间一行，可以对代码做一点点改动。
/**
* 入口，传入N
*/
public static void printStar(int number){
printStar2(number, number, 1);
}

/**
*
* @param number 给定的N
* @param oldNumber 给定的N
* @param direction 递归时的方向
*/
public static void printStar2(int number,int oldNumber, int direction){
if(number==0)direction++;
String s=““;
int i = number;
if(direction==1){
for(;i《oldNumber;i++){
s+=“*“;
}
number--;
}else{
for(;i《oldNumber;i++){
s+=“*“;
}
number++;
if(number》oldNumber){
return;
}
}

printStar2(number,oldNumber,direction);
System.out.println(s);
}

-----------------------------------------------------------------------------------------
运行效果：
printStar(5);
*
**
***
****
*****
****
***
**
*

用java递归算法求一个数字的阶乘

1、采用自顶向上的递归方法，代码如下：

2、递归方法：   

递归算法是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数（或过程）来表示问题的解。一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数).

3、特点：

(1) 递归就是在过程或函数里调用自身。

(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。

(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。