关于递归的思路的例子

前台框架是easyui,需要返回给前台tree的数据,返回的数据格式为[{id:1,text:22,children:(map)},{id:2,text:22,children:(map)},{id:3,text:22,children:(map)},{id:4,text:22,children:(map)}]。就是List<Map<String,Object>>。

代码为:

public static List<Map<String, Object>> getFileList() {  
        List<Map<String, Object>> redata = new ArrayList<Map<String,Object>>();  
        Document document = FileDao.readFile("cda/fileConfig.xml");  
        Element rootElement = document.getRootElement();  
        List<Element> lists = rootElement.elements();  
        for (Element element : lists) {  
            Map<String,Object> map = new HashMap<String,Object>();  
            eachFile(element, map);  
            redata.add(map);  
        }  
        return redata;  
    }         
  
    @SuppressWarnings("unchecked")  
    public static void eachFile(Element element,Map<String,Object> map) {  
        map.put("id", element.attributeValue("id"));  
        map.put("text", element.attributeValue("text"));  
        List<Map<String, Object>> childList = new ArrayList<>();
        map.put("children", childList);  
        if(element.elements()!=null){  
            List<Element> childElements = element.elements();  
            for (Element child : childElements) {  
                if(!child.getName().equals("dataset")){  
                	map.put("state", "closed");
                	Map<String,Object> map1 = new HashMap<String,Object>();  
                    eachFile(child,map1);  
                    childList.add(map1);
                }  
            }  
        }  
    }



这里需要注意的是递归方法中要做的内容必须要清晰,对于该递归方法而言,任务就是要把传入的Element的数据提取到传入的map中,如果该element有对应的子节点,则得到子节点,把子节点的element递归调用该方法,同时传入的还有childMap。


如果不传入map,则在方法内新建map,构建完map后返回。改造后如下代码:

public static List<Map<String, Object>> getFileList() {
		List<Map<String, Object>> redata = new ArrayList<Map<String,Object>>();
		Document document = FileDao.readFile("cda/fileConfig.xml");
		Element rootElement = document.getRootElement();
		List<Element> lists = rootElement.elements();
		for (Element element : lists) {
			redata.add(eachFile(element));
		}
		return redata;
	}		

	@SuppressWarnings("unchecked")
	public static Map<String,Object> eachFile(Element element) {
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("id", element.attributeValue("id"));
		map.put("text", element.attributeValue("text"));
		if(element.elements()!=null){
			List<Element> childElements = element.elements();
			List<Map<String, Object>> childList = new ArrayList<Map<String,Object>>();
			map.put("children", childList);
			for (Element child : childElements) {
				if(!child.getName().equals("dataset")){
					childList.add(eachFile(child));
				}
			}
			if(childList.size()!=0){
				map.put("state", "closed");
			}
		}
		return map;
	}



<think>我们被要求提供递归算法的经典例子。根据用户提供的引用,我们可以参考斐波那契数列(引用[1])、台阶问题(引用[2])以及递归函数的本结构(引用[3])。此外,我们还可以补充一些其他经典例子。 递归算法的经典例子包括: 1. 斐波那契数列 2. 阶乘计算 3. 汉诺塔问题 4. 二叉树遍历(如前序遍历、中序遍历、后序遍历) 5. 台阶问题(爬楼梯问题) 下面我们将选择其中几个进行详细说明和代码实现(使用C语言,因为引用[1]中提到了C语言)。 ### 1. 斐波那契数列 斐波那契数列的定义为:第1项和第2项为1,从第3项开始,每一项等于前两项之和。即: $$ F(1) = 1, F(2) = 1 $$ $$ F(n) = F(n-1) + F(n-2) \quad (n \geq 3) $$ 递归实现(C语言): ```c #include <stdio.h> int fibonacci(int n) { if (n <= 2) { return 1; } return fibonacci(n-1) + fibonacci(n-2); } int main() { int n = 10; // 求前10个数 for (int i = 1; i <= n; i++) { printf("%d ", fibonacci(i)); } return 0; } ``` 注意:这个递归实现存在重复计算,效率较低,实际应用中可以使用循环或记忆化优化。 ### 2. 阶乘 阶乘的定义:$n! = n \times (n-1)!$,且$0! = 1$。 递归实现(C语言): ```c #include <stdio.h> int factorial(int n) { if (n == 0) { return 1; } return n * factorial(n-1); } int main() { int n = 5; printf("%d! = %d\n", n, factorial(n)); return 0; } ``` ### 3. 汉诺塔问题 汉诺塔问题是一个经典的递归问题。规则:将n个盘子从A柱移动到C柱,每次只能移动一个盘子,且大盘子不能放在小盘子上面。 递归思路: - 将n-1个盘子从A移到B(借助C) - 将第n个盘子从A移到C - 将n-1个盘子从B移到C(借助A) 递归实现(C语言): ```c #include <stdio.h> void hanoi(int n, char from, char to, char aux) { if (n == 1) { printf("Move disk 1 from %c to %c\n", from, to); return; } hanoi(n-1, from, aux, to); printf("Move disk %d from %c to %c\n", n, from, to); hanoi(n-1, aux, to, from); } int main() { int n = 3; // 3个盘子 hanoi(n, 'A', 'C', 'B'); return 0; } ``` ### 4. 台阶问题(爬楼梯问题) 问题描述:有n阶台阶,每次可以爬1阶或2阶,问有多少种不同的方法爬到楼顶。 递归关系:设f(n)为爬n阶台阶的方法数,则: $$ f(n) = f(n-1) + f(n-2) $$ 其中,f(1)=1,f(2)=2(注意:这里f(2)有两种方法:1+1或2)。 但是,这个递归同样存在重复计算问题。我们可以用动态规划优化,但这里仅展示递归形式。 递归实现(C语言): ```c #include <stdio.h> int climbStairs(int n) { if (n == 1) return 1; if (n == 2) return 2; return climbStairs(n-1) + climbStairs(n-2); } int main() { int n = 4; printf("There are %d ways to climb %d stairs.\n", climbStairs(n), n); return 0; } ``` ### 总结 递归算法通过将问题分解为更小的子问题来解决,但需要注意递归终止条件和递归调用的正确性。递归虽然简洁,但可能带来性能问题(如重复计算),因此在实际应用中需要根据情况考虑优化(如使用迭代或记忆化搜索)。 §§相关问题§§ 1. 递归算法的优缺点是什么? 2. 如何避免递归中的重复计算问题? 3. 递归和迭代之间如何选择? 4. 什么是尾递归?它有什么优点? 5. 如何用递归实现二叉树的遍历? [^1]: 斐波那契数列的递归实现,虽然简洁但效率较低,因为存在大量重复计算[^1]。 [^2]: 台阶问题展示了递归的本思想:将大问题分解为小问题,并找到递推关系[^2]。 [^3]: 递归函数需要设置终止条件,否则会导致无限递归[^3]。</think>### 递归算法经典示详解 递归算法的核心思想是**函数直接或间接调用自身**,通过分解问题为更小的同类子问题来解决复杂任务。以下是四个经典递归示及其实现原理: #### 1. 斐波那契数列(数学序列) **问题描述**:计算第n项斐波那契数,其中: $$ F(0) = 0, \quad F(1) = 1, \quad F(n) = F(n-1) + F(n-2) \quad (n \geq 2) $$ **C语言实现**: ```c int fibonacci(int n) { if (n <= 1) return n; // 终止条件 return fibonacci(n-1) + fibonacci(n-2); // 递归调用 } ``` **调用过程**(以n=4为): ```mermaid graph TD A[fib4] --> B[fib3] A --> C[fib2] B --> D[fib2] B --> E[fib1] D --> F[fib1] D --> G[fib0] C --> H[fib1] C --> I[fib0] ``` #### 2. 阶乘计算(数学运算) **问题描述**:计算n的阶乘: $$ n! = n \times (n-1)! \quad 且 \quad 0! = 1 $$ **Python实现**: ```python def factorial(n): if n == 0: # 终止条件 return 1 return n * factorial(n-1) # 递归分解 ``` #### 3. 汉诺塔问题(分治策略) **问题描述**:将n个盘子从A柱移动到C柱,要求: 1. 每次只能移动一个盘子 2. 大盘不能压小盘 **Java实现**: ```java void hanoi(int n, char from, char to, char aux) { if (n == 1) { // 终止条件 System.out.println("Move disk 1 from " + from + " to " + to); return; } hanoi(n-1, from, aux, to); // 将n-1个盘移到辅助柱 System.out.println("Move disk " + n + " from " + from + " to " + to); hanoi(n-1, aux, to, from); // 将n-1个盘移到目标柱 } ``` #### 4. 爬楼梯问题(动态规划) **问题描述**:爬n阶楼梯,每次可爬1或2阶,求方案数: $$ f(n) = f(n-1) + f(n-2) \quad 且 \quad f(1)=1, f(2)=2 $$ **JavaScript实现**: ```javascript function climbStairs(n) { if (n <= 2) return n; // 终止条件 return climbStairs(n-1) + climbStairs(n-2); } ``` ### 递归算法核心要素 | 要素 | 说明 | 示 | |--------------|-------------------------------|----------------------------| | **终止条件** | 防止无限递归的边界 | `n == 0`(阶乘) | | **递归调用** | 分解为更小的同类子问题 | `fibonacci(n-1)` | | **状态传递** | 缩小问题规模的参数 | 台阶数n、盘子数n | | **结果合并** | 子问题解的整合方式 | 加法(斐波那契)、乘法(阶乘)| > ⚠️ **注意事项**:递归可能引发**栈溢出**(深递归)和**重复计算**问题(如斐波那契),可通过**尾递归优化**或**记忆化技术**解决[^1][^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值