遞歸演算法java公式_java中遞歸演算法是什麼怎麼算的

❶ java全排列遞歸演算法

思路:先有一個起始排列，如1234.從後面掃描，直到找到a[k],a[k]<a[k+1];再從後面掃描，直到找到a[j],這里有 a[k]<a[j]。交換a[k],a[j].再把a[k+1],...a[n-1]排序（從小到大），即得到了一個排列，再循環下去，直到找出所有的排序。用C語言的，參考下: http://user.qzone.qq.com/646203846/infocenter?ptlang=2052

❷ 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(String[]args){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中遞歸演算法,希望有詳細解釋

publicclassTest{
publicstaticintresult(intparameter){
if(parameter<=1)return1;//判斷parameter是否小於等於1,如果不成立則遞歸調用
intnumber=parameter*result(parameter-1);//將parameter-1繼續調用函數反復如此，直至條件成立。
returnnumber;
}
publicstaticvoidmain(String[]args{
intresult=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冒泡排序和遞歸演算法

冒泡排序

（1）基本思想：在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

（2）用java實現

ublicclassbubbleSort{

publicbubbleSort(){

inta[]={1,54,6,3,78,34,12,45};

inttemp=0;

for(inti=0;i<a.length;i++){

for(intj=i+1;j<a.length;j++){

if(a[i]>a[j]){

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

}

for(inti=0;i<a.length;i++)

System.out.println(a[i]);

}

}

遞歸

遞歸演算法，就是程序的自身調用。表現在一段程序中往往會遇到調用自身的那樣一種coding策略，可以利用大道至簡的思想，把一個大的復雜的問題層層轉換為一個小的和原問題相似的問題來求解的這樣一種策略。能看到我們會用很少的語句解決了非常大的問題，所以遞歸策略的最主要體現就是小的代碼量解決了非常復雜的問題。

java代碼：

packagecom.cjq.filedown;

publicclassFab{

publicstaticvoidmain(Stringargs[]){
System.out.println(fab(5));
}

privatestaticintfab(intindex){
if(index==1||index==2){
return1;
}else{
returnfab(index-1)+fab(index-2);
}
}
}

❺ java遞歸演算法，怎麼理解

n!=(n-1)*n！
簡單理解，就是目前的所有任務，等於前面所有的任務+現在的任務。
比如你求1。。。100的加法總和
實際上是1...99的加法總和+100就是了。
這就是遞歸的來源。
你只需要計算你前一步的任務，然後加上自己，就OK了。
前一步，在再次調用前前一步......

❻ 在java中利用遞歸法，計算曲線y=x的平方與直線x=1，x軸所包圍的曲邊三角形的面積。


publicclassUtil{
	publicstaticvoidmain(String[]args){
		System.out.println(getMj(2000));		
	}
	publicstaticdoublegetMj(doublen){		
		if(n==1){
			return1.0;
		}else{
			doubler=(n-1)*(n-1)*(n+1)*(2*n+1)/(n*n*n*(2*n-1));	
			returnr*getMj(n-1);	
		}
	}
}

遞歸演算法前提是知道它的通項公式，2000表示把曲邊三角形等分2000個矩形，原理如下圖：

publicclassUtil{
publicstaticvoidmain(String[]args){
System.out.println(getMj(100000));
}
publicstaticdoublegetMj(doublen){
return(n+1)*(2*n+1)/(6*n*n);
}
}

❼ java遞歸演算法的例子。

階乘：

要求：給定一個數值，計算出它的階乘值，例如5的階乘為5*4*3*2*1

實現：

[html] view plain

// 利用遞歸實現一個數的階乘值 private static BigDecimal getNum(BigDecimal inNum) { if (inNum.compareTo(BigDecimal.ONE) == 0) { return inNum; } return inNum.multiply(getNum(inNum.subtract(BigDecimal.ONE))); }

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

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

實現：

[html] view plain

// 利用遞歸實現了Fibonacci數列 private static int fab(int index) { if (index == 1 || index == 2) { return 1; } else { return fab(index - 1) + fab(index - 2); } }

（3）漢諾塔

要求：漢諾塔挪動

實現：

[html] view plain

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); }

[html] view plain

// 利用遞歸實現漢諾塔 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); } }

（4）排列組合

要求：將輸入的一個字元串中的所有元素進行排序並輸出，例如：你給出的參數是"abc"，

則程序會輸出

abc

acb

bac

bca

cab

cba

實現：

[html] view plain

public static void permute(String str) { char[] strArray = str.toCharArray(); permute(strArray, 0, strArray.length - 1); }

[html] view plain

// 利用遞歸實現，將輸入的一個字元串中的所有元素進行排序並輸出 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中遞歸演算法是什麼怎麼算的

一、遞歸演算法基本思路：

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用遞歸演算法求 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公式

遞歸演算法java公式

與遞歸演算法java公式相關的資料