遞歸演算法javatree

『壹』 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中什麼是遞歸有什麼用

Java方法遞歸是指在一個方法的內部調用自身的過程，以此類推就是java方法遞歸的理解思想，具體來講就是把規模大的問題轉化為規模小的相似的子問題來解決。在函數實現時，因為解決大問題的方法和解決小問題的方法往往是同一個方法，所以就產生了函數調用它自身的情況。另外這個解決問題的函數必須有明顯的結束條件，這樣就不會產生無限遞歸的情況了。因此，java方法遞歸的兩個條件就是，一通過遞歸調用來縮小問題規模，且新問題與原問題有著相同的形式；二存在一種簡單情境，可以使遞歸在簡單情境下退出。

『叄』 JTree，如何用遞歸演算法構建樹

public void addChild(DefaultMutableTreeNode fatherNode,int fatherId) {
List<Map>list=codeservices.getAssetCode( fatherId);
for(Map map:list){
DefaultMutableTreeNode child=new DefaultMutableTreeNode((String)map.get("TYPENAME"));
int id=Integer.parseInt((String)map.get("TYPEID"));
fatherNode.add(child);
addChild(child,id);
}
}

其中list是從資料庫獲取的所有節點，fatherNode是根節點，fatherid是父id，後面的id是自身節點id

『肆』 用java遞歸方法實現

publicintfun(intn){
if(n==0||n==1)return1;
returnn*fun(n-1);
}

『伍』 求Java List 遞歸演算法..

無需JAVA遞歸取！

從設計角度看，表結構設計已經有問題了！
即使是樹狀結構，為何表結構沒有體現？這也構成了為何樓主需要想辦法來應對非樹狀結構數據的樹狀顯示問題。

先進一步來說，表加一個grade欄位，來表明當前記錄處於第幾級。那麼直接一個SQL就可以取出來：
select lpad(' ',a.grade,'-')||a.name from myList a
這樣就可以按樓主需要的結構取出數據；

但還存在一個問題，就是順序問題，這樣取出的數據是無序的！

那麼我們再進一步看，我在做這種數據結構的表設計時，往往會給每個結點增加兩個欄位，left/right，分別代表其在樹中的左右值。

這樣就可以在上面SQL後增加order by a.left以保證取出數據的順序。

『陸』 java使用遞歸實現樹形結構

inserttb_menu(id,name,parent)(640000000000,北京市,0);
inserttb_menu(id,name,parent)(640100000000,昌平區,1);
inserttb_menu(id,name,parent)(640101000000,霍營,2);
inserttb_menu(id,name,parent)(640101001000,回龍觀東大街,3);

添加一個節點屬性， 根據數據不同代表的地位不同，0就代表父節點 ，1是0的子節點，2是1的子節點，以此類推。

『柒』 請問大家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.漢諾塔問題
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、准備表結構及對應的表數據
a、表結構：
create table TB_TREE
(
CID NUMBER not null,
CNAME VARCHAR2(50),
PID NUMBER //父節點
)

b、表數據：

insert into tb_tree (CID, CNAME, PID) values (1, '中國', 0);
insert into tb_tree (CID, CNAME, PID) values (2, '北京市', 1);
insert into tb_tree (CID, CNAME, PID) values (3, '廣東省', 1);
insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);
insert into tb_tree (CID, CNAME, PID) values (5, '廣州市', 3);
insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 3);
insert into tb_tree (CID, CNAME, PID) values (7, '海珠區', 5);
insert into tb_tree (CID, CNAME, PID) values (8, '天河區', 5);
insert into tb_tree (CID, CNAME, PID) values (9, '福田區', 6);
insert into tb_tree (CID, CNAME, PID) values (10, '南山區', 6);
insert into tb_tree (CID, CNAME, PID) values (11, '密雲縣', 2);
insert into tb_tree (CID, CNAME, PID) values (12, '浦東', 4);

2、TreeNode對象，對應tb_tree

public class TreeNode implements Serializable {
private Integer cid;
private String cname;
private Integer pid;
private List nodes = new ArrayList();

public TreeNode() {
}

//getter、setter省略
}

3、測試數據

public class TreeNodeTest {
@Test
public void loadTree() throws Exception{
System.out.println(JsonUtils.javaToJson(recursiveTree(1)));
}

/**
* 遞歸演算法解析成樹形結構
*
* @param cid
* @return
* @author jiqinlin
*/
public TreeNode recursiveTree(int cid) {
//根據cid獲取節點對象(SELECT * FROM tb_tree t WHERE t.cid=?)
TreeNode node = personService.getreeNode(cid);
//查詢cid下的所有子節點(SELECT * FROM tb_tree t WHERE t.pid=?)
List childTreeNodes = personService.queryTreeNode(cid);
//遍歷子節點
for(TreeNode child : childTreeNodes){
TreeNode n = recursiveTree(child.getCid()); //遞歸
node.getNodes().add(n);
}

return node;
}
}

輸出的json格式如下：

{
"cid": 1,
"nodes": [
{
"cid": 2,
"nodes": [
{
"cid": 11,
"nodes": [

],
"cname": "密雲縣",
"pid": 2
}
],
"cname": "北京市",
"pid": 1
},
{
"cid": 3,
"nodes": [
{
"cid": 5,
"nodes": [
{
"cid": 7,
"nodes": [

],
"cname": "海珠區",
"pid": 5
},
{
"cid": 8,
"nodes": [

],
"cname": "天河區",
"pid": 5
}
],
"cname": "廣州市",
"pid": 3
},
{
"cid": 6,
"nodes": [
{
"cid": 9,
"nodes": [

],
"cname": "福田區",
"pid": 6
},
{
"cid": 10,
"nodes": [

],
"cname": "南山區",
"pid": 6
}
],
"cname": "深圳市",
"pid": 3
}
],
"cname": "廣東省",
"pid": 1
},
{
"cid": 4,
"nodes": [
{
"cid": 12,
"nodes": [

],
"cname": "浦東",
"pid": 4
}
],
"cname": "上海市",
"pid": 1
}
],
"cname": "中國",
"pid": 0
}