java遞歸
Ⅰ 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的遞歸方法
橫線填：d2b(n/2);
Ⅲ 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遞歸方法實現
publicintfun(intn){
if(n==0||n==1)return1;
returnn*fun(n-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方法遞歸調用
python">1.當n=1時，返回1
2.當n>1時，返回n+(n-1)
最簡單的了，還有個有名的數列遞歸叫做「斐波那契」數列遞歸
Ⅷ 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遞歸 怎麼執行的
根據函數定義，fn(6)=fn(5)+fn(4)
=fn(4)+fn(3)+fn(3)+fn(2)
=fn(3)+fn(2)+fn(2)+fn(1)+fn(2)+fn(1)+fn(1)+fn(0)
=fn(2)+fn(1)+fn(1)+fn(0)+fn(1)+fn(0)+1+fn(1)+fn(0)+1+1+0
=fn(1)+fn(0)+1+1+0+1+0+1+1+0+1+1+0
=1+0+1+1+0+1+0+1+1+0+1+1+0
=8
Ⅹ JAVA中的遞歸方法，求講一下。
自己調用自己或幾個方法相互調用。
最經典的是求正整數階的演算法：
int fact(int i){
if(i<=1)return 1;
return fact(i-1)*i;
}
多數遞歸方法可以轉換成非遞歸方法。
一般同功能的非遞歸方法，執行效率要優於遞歸方法。但合理的使用遞歸方法，可以使代碼結構更清晰，更有可讀性，從而更方便維護。