遞歸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);
}
}
還有就是數據結構中二叉樹的定義，也是遞歸定義的。因此二叉樹的好多操作都是通過遞歸實現的。
用遞歸會使程序相當簡潔。