递归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)逼近过程，当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如何理解递归

//这个是一个使用递归算法求某数阶乘的例子
//如果求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的递归方法

横线填：d2b(n/2);

㈣ java 递归

花了将近一天时间才实现任意长度的字符串所有可能的排列，下面分享一下成果

里面最重要的思想是：假定已经将n-1个字符组成的字符所有可能的排列算好了，将它们放到List中存放着。在依次取出每个元素，那么将新增的字符插入这个元素的n个位置上，那么每个元素就会产生新的n个字符的排列了。

所以：总共产生的排列个数=List中已有元素个数 乘以 n

优化前代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
*
* @author chenhui
*
*/
public class TestArrayABC {

/**
* @param str 字符串str中每个字符都不相同
* @return 字符串str所有可能的排列
*/
public List<String> doCompute(String str)
{
List<String> list = new ArrayList<String>();
List<String> temp = new ArrayList<String>();
temp.addAll(list);
list.removeAll(null);
if(str.length() == 1)
{
list.add(str);
return list;
}
else
{
char ch = str.charAt(0);
temp = doCompute(str.substring(1));
for(int j = 0; j < temp.size(); j++)
{
String s = temp.get(j);
char[] charArray = s.toCharArray();
char[] tempArray = new char[s.length() + 1];
//将ch分别放到charArray.length + 1个位置
for(int k = 0; k < charArray.length + 1; k++)
{
for(int i = 0; i < charArray.length + 1; i++)
{
if(i < k)
{
tempArray[i] = charArray[i];
}
else if(i == k)
{
tempArray[i] = ch;
}
else
{
tempArray[i] = charArray[i - 1];
}
}
list.add(j, new String(tempArray));
}
}
return list;
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

TestArrayABC abc = new TestArrayABC();
List<String> list = abc.doCompute(

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

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

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

int fact(int i){

if(i<=1)return 1;

return fact(i-1)*i;

}

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

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

㈥ JAVA中能够实现方法的递归调用吗如何实现

能 递归函数即自调用函数，在函数体内直接或间接的调用自己，即函数的嵌套是函数本身。递归调用又分为直接调用和间接调用
直接调用funca(){ ...... funca();};间接调用；funca(){ ...... funcb();}funcb(){ ..... funca(); .....} 汉诺塔源码public class HanoiY { void Move(char chSour,char chDest){ System.out.println("Move the top plate of "+chSour+"-->"+chDest); } void Hanoi(int n,char chA,char chB,char chC) { if(n==1) Move(chA,chC); else { Hanoi(n-1,chA,chC,chB); this.Move(chA,chC); Hanoi(n-1,chB,chA,chC); } } public static void main(String[] args) { int n=Integer.parseInt(args[0]); HanoiY han=new HanoiY(); han.Hanoi(n,'A','B','C'); } }

㈦ 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

/**
* 二分查找
* @author tenglian
*
*/
class BinaryFind{

public void find(int leftIndex, int rightIndex, int val, int arr[]){
int midIndex = (leftIndex + rightIndex)/2;
int midVal = arr[midIndex];
if(rightIndex >= leftIndex){
if(midVal > val){
find(leftIndex, midIndex - 1, val, arr);
} else if(midVal < val){
find(midIndex + 1, rightIndex, val, arr);
} else if(midVal == val){
System.out.println(midIndex);
}
} else {
System.out.println("NotDataFound");
}
}
}
上面这个例子是个二分查找，典型的 用到 递归的例子 自己运行下看看，相信你能理解 不难

㈩ 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);
}
}
还有就是数据结构中二叉树的定义，也是递归定义的。因此二叉树的好多操作都是通过递归实现的。
用递归会使程序相当简洁。