逐步生成式递归

于 2022-04-10 16:05:19 发布
阅读量571 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 蓝桥杯 递归 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45724216/article/details/124080127
版权

本文目录

1. 走楼梯

问题描述：

有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶、3阶。
请实现一个方法，计算小孩有多少种上楼的方式。
为了防止溢出，请将结果Mod 1000000007

给定一个正整数int n，请返回一个数，代表上楼的方式数。
保证n小于等于100000。

思路解析：

递归方程：f(x) = f(x-1)+f(x-2)+f(x-3)

迭代方程：dp[i]=dp[i-1]+dp[i-2]+dp[i-3]

代码：

package 逐步生成式递归;

import java.util.Scanner;

/**
 * @author: DreamCode
 * @file: 走楼梯.java
 * @time: 2022年3月24日-上午9:01:26
 */
public class 走楼梯 {

	static long[] rec;
	static long MODE = 1000000007;

	public static void main(String[] args) {
		int n = 1000;
		rec = new long[n + 1];
		rec[1] = 1;
		rec[2] = 2;
		rec[3] = 4;
		long ans = recursion(n); // 递归
		long ans2 = iteration(n); // 迭代
		System.out.println(ans);
		System.out.println(ans2);

	}

	private static long iteration(int n) {
		// TODO 迭代形式
		long[] dp = new long[n + 1];
		dp[1] = 1;
		dp[2] = 2;
		dp[3] = 4;
		for (int i = 4; i <= n; i++) {
			dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
			dp[i] %= MODE;
		}
		return dp[n];
	}

	private static long recursion(int n) {
		// TODO 递归方程；f(x) = f(x-1)+f(x-2)+f(x-3)
		if (rec[n] != 0) {
			return rec[n];
		}
		long res;
		res = (recursion(n - 1) + recursion(n - 2) + recursion(n - 3)) % MODE;
		rec[n] = res;
		return res;
	}

}

2. 机器人走格子

问题描述：

有一个X*Y的网格，一个机器人只能走格点且只能向右或向下走，要从左上角走到右下角。
请设计一个算法，计算机器人有多少种走法。
给定两个正整数int x,int y，请返回机器人的走法数目。保证x＋y小于等于12。

思路解析：

递归方程：f(x,y)=f(x-1,y)+f(x,y-1)

迭代方程：dp(i,j) = dp(i-1,j) + dp(i,j-1)

代码：

package 逐步生成式递归;

/**
 * @author: DreamCode
 * @file: 机器人走格子.java
 * @time: 2022年3月24日-上午9:32:57
 */
public class 机器人走格子 {

	static long[][] rec;

	public static void main(String[] args) {
		int x = 1000;
		int y = 1000;
		rec = new long[x + 1][y + 1];
		long ans1 = recursion(x, y); // 递归
		long ans2 = iteration(x, y); // 迭代
		System.out.println(ans1);
		System.out.println(ans2);

	}

	private static long iteration(int x, int y) {
		// TODO 迭代形式（动态规划）
		long[][] dp = new long[x + 1][y + 1];
		for (int i = 1; i <= x; i++) { // 所有列为1的都只有一种走法
			dp[i][1] = 1;
		}
		for (int i = 1; i <= y; i++) { // 所有行为1的都只有一种走法
			dp[1][i] = 1;
		}
		for (int i = 2; i <= x; i++) {
			for (int j = 2; j <= y; j++) {
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}
		}
		return dp[x][y];
	}

	private static long recursion(int x, int y) {
		// TODO 递归方式：f(x,y)=f(x-1,y)+f(x,y-1)
		if (rec[x][y] != 0) {
			return rec[x][y];
		}
		long res;
		if (x == 1) { // 只有一列
			res = 1;
			rec[x][y] = res;
			return res;
		}
		if (y == 1) { // 只有一行
			res = 1;
			rec[x][y] = res;
			return res;
		}
		res = recursion(x - 1, y) + recursion(x, y - 1);
		rec[x][y] = res;
		return res;
	}

}

3. 非空子集（递归|迭代）

问题描述：

请编写一个方法，返回某集合的所有非空子集。

给定一个int数组A和数组的大小int n，请返回A的所有非空子集。
保证A的元素个数小于等于20，且元素互异。

各子集内部从大到小排序,子集之间字典逆序排序

思路解析：

常规子集生成（递归增量构造法）算法;f(n)是在f(n-1)的基础上逐步生成的

代码：

package 逐步生成式递归;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * @author: DreamCode
 * @file: 子集生成.java
 * @time: 2022年3月25日-下午2:14:16
 */
public class 非空子集生成 {

	public static void main(String[] args) {
		int n = 3;
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = i + 1;
		}
		Set<Set<Integer>> ans_recursion = getSubSet_recursion(arr, n - 1); // 递归
		System.out.println(ans_recursion);
		Set<Set<Integer>> ans_iteration = getSubSet_iteration(arr); // 迭代
		System.out.println(ans_iteration);
	}

	private static Set<Set<Integer>> getSubSet_iteration(int[] arr) {
		// TODO 逐步迭代
		Set<Set<Integer>> old_rec = new HashSet<>();
		old_rec.add(new HashSet<>()); // 初始化有一个空集
		for (int i = 0; i < arr.length; i++) {
			Set<Set<Integer>> new_rec = new HashSet<>(); // 新的集合
			for (Set<Integer> set : old_rec) { // 遍历旧集合的每一个元素
				new_rec.add(set); // 不选择arr[i]
				HashSet<Integer> temp = (HashSet<Integer>) ((HashSet<Integer>) set).clone();
				temp.add(arr[i]); // 选择当前元素加入集合
				new_rec.add(temp); // 将新的集合加入到new_rec
			}
			old_rec = new_rec;
		}
		return old_rec;
	}

	private static Set<Set<Integer>> getSubSet_recursion(int[] arr, int n) {
		// TODO 递归增量递增法
		Set<Set<Integer>> new_rec = new HashSet<>();
		if (n == -1) { // 出口
			new_rec.add(new HashSet<Integer>());
			return new_rec;
		}
		Set<Set<Integer>> old_rec = getSubSet_recursion(arr, n - 1);
		for (Set<Integer> set : old_rec) { // 遍历每一个f(n-1)
			new_rec.add(set); // 不选当前的arr[n]
			HashSet<Integer> temp = (HashSet<Integer>) ((HashSet<Integer>) set).clone(); // set为引用类型，修改时需要备份
			temp.add(arr[n]);
			new_rec.add(temp); // 选择当前元素
		}
		return new_rec;
	}

}

4. 非空子集（二进制）

问题描述：

请编写一个方法，返回某集合的所有非空子集。

给定一个int数组A和数组的大小int n，请返回A的所有非空子集。
保证A的元素个数小于等于20，且元素互异。

各子集内部从大到小排序,子集之间字典逆序排序

思路解析：

二进制法构造非空子集；二进制的每一位数字代表当前位置选与不选

代码：

package 逐步生成式递归;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author: DreamCode
 * @file: 非空子集生成_二进制.java
 * @time: 2022年3月25日-下午2:48:32
 */
public class 非空子集生成_二进制 {

	public static void main(String[] args) {
		int[] arr = { 1, 3, 2 }; 
		ArrayList<ArrayList<Integer>> ans = getSubSet(arr);
		System.out.println(ans);
	}

	private static ArrayList<ArrayList<Integer>> getSubSet(int[] arr) {
		// TODO 二进制法构造非空子集；二进制的每一位数字代表当前位置选与不选
		Arrays.sort(arr); // 对arr进行升序排序
		int n = arr.length; // arr数组的长度（元素的个数）
		ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
		for (int num = (int) (Math.pow(2, n) - 1); num > 0; num--) { // 为方便字典序，选择从大到小的遍历，不含有空集则不能等于0
			ArrayList<Integer> list = new ArrayList<>(); // 当前数的选择集合
			for (int i = n - 1; i >= 0; i--) { // 向右移动n-1~0位，再与1做&，得到1代表当前位选则，否则代表不选
				if (((num >> i) & 1) == 1) { // 当前位置选择
					list.add(arr[i]);
				}
			}
			ans.add(list);
		}
		return ans;
	}

}

5. 全排列（迭代）

思路解析：

逐个迭代的方法，逐个元素字符选取，插入到字符串的两两字符之间;避免产生重复子集元素，故选取set存储

代码：

package 逐步生成式递归;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author: DreamCode
 * @file: 全排列.java
 * @time: 2022年3月25日-下午9:30:33
 */
public class 全排列_迭代法 {

	public static void main(String[] args) {
		String A = "ABC";
		int n = 3;
		Set<String> ans = permutation(A, n);
		// 将HashSet排序，将HashSet转换为TreeSet，descendingSet()实现降序排序
		System.out.println(new TreeSet<>(ans).descendingSet());
	}

	private static Set<String> permutation(String string, int n) {
		// TODO 逐步生成大法-迭代法
		Set<String> rec_old = new HashSet<>();
		rec_old.add("");
		for (int i = 0; i < n; i++) {// 遍历每一个字符
			Set<String> rec_new = new HashSet<>(); // 新的存储容器
			char c = string.charAt(i);
			for (String s : rec_old) { // 访问上一趟集合中的每个字符串
				rec_new.add(c + s);  // s之前插入字符
				for (int j = 1; j < s.length(); j++) {  // s的每一个空格插入字符
					String subString = s.substring(0, j) + c + s.substring(j);  // substring(i,j):取左不取右
					rec_new.add(subString);
				}	
				rec_new.add(s + c);  // s之后插入字符
			}
			rec_old = rec_new; // 更新旧的容器
		}
		return rec_old;
	}

}

6. 全排列（递归回溯法）

思路解析：

逐步递归回溯。逐个交换,递归回溯;这次选用ArrayList存储;

简单、但是不能保证字典序。

如果原数组含有大量重复元素，会造成重复排列

代码：

package 逐步生成式递归;

import java.util.ArrayList;
import java.util.TreeSet;

/**
 * @author: DreamCode
 * @file: 全排类_交换法_递归回溯.java
 * @time: 2022年3月25日-下午10:15:33
 */
public class 全排类_交换法_递归回溯 {

	static ArrayList<String> container = new ArrayList<>();

	public static void main(String[] args) {
		String string = "ABC";
		int n = 3;
		permutation(string.toCharArray(), 0);
		System.out.println(new TreeSet<>(container).descendingSet());
	}

	private static void permutation(char[] string, int k) {
		// TODO 将第i位置字符逐个交换到第k位,递归回溯
		if (k == string.length) {// 当前已经构成一个完整的字符串
			container.add(new String(string));
			return;
		}
		for (int i = k; i < string.length; i++) {
			swap(string, i, k); // 将第i位与第k位进行交换
			permutation(string, k + 1); // 递归进入下一层
			swap(string, i, k); // 回溯
		}
	}

	private static void swap(char[] string, int i, int k) {
		// TODO 交换string字符串的i位与k位
		char t = string[i];
		string[i] = string[k];
		string[k] = t;
	}

}

7. 全排列（前缀法）

思路解析：

全排列_前缀法_递归回溯；每次根据字符数组从头扫描，只要该字符可用，就将其加到前缀的后面。

字符可用的前提：该字符在前缀中出现的次数小于在数组中出现的次数;

递归出口：前缀长度=字符数组长度

复杂、但是能保证字典序，对于求第K个是最佳选择;

代码：

package 逐步生成式递归;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: DreamCode
 * @file: 全排列_前缀法_递归回溯.java
 * @time: 2022年3月25日-下午10:33:05
 */
public class 全排列_前缀法_递归回溯 {

	static List<String> container = new ArrayList<>();
	static long k = 0; // 记录当前是第几个排列

	public static void main(String[] args) {
		String string = "ABCDEFGHIJKLMNOPQRS";
		permutation("", string.toCharArray());
		System.out.println(container);
	}

	private static void permutation(String prefix, char[] charArray) {
		// TODO 前缀法
		if (charArray.length == prefix.length()) {
			container.add(prefix);
			k++;
			if(k==100) {
				System.out.println(prefix);
				System.exit(0);
			}
			return;
		}
		//每次都从头扫描,只要该字符可用,我们就附加到前缀后面,前缀变长了
		for (int i = 0; i < charArray.length; i++) {
			char c = charArray[i];
			if(count(prefix,c)<count(new String(charArray),c)) {
				permutation(prefix+c, charArray);
			}
		}
	}

	private static int count(String string, char c) {
		// TODO 计算在string字符串中字符c出现的次数
		int res=0;
		for(int i=0;i<string.length();i++) {
			if(string.charAt(i)==c) {
				res++;
			}
		}
		return res;
	}

}

8. 全排列（抽取法）

思路解析：

整体和递归回溯法相似，但是在选择元素的时候有所不同。当前元素与前一个元素相同，必须保证前一个元素已经选择才能选择当前元素，不然会有重复

代码：

 package 第7届;

/**
 * @author: DreamCode
 * @file: G_剪邮票.java
 * @time: 2022年3月13日-下午5:42:19
 */
public class G_剪邮票 {

	static int[] record = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 }; // 全排列的数组，为1的位置为选择的卡片
	static boolean[] vis = new boolean[12]; // 记录当前的卡片是否选中的标记数组
	static int ans = 0; // 种类数答案

	public static void main(String[] args) {
		permutation(0, new int[12]); // 全排列
		System.out.println(ans);
	}

	private static void permutation(int k, int[] arr) {
		// TODO 全排列算法：抽取式
		if (k == 12) { // 排完一轮
			ans++;
			return;
		}
		for (int i = 0; i < 12; i++) {
             // 当前元素与前一个元素相同，必须保证前一个元素已经选择才能选择当前元素，不然会有重复
			if (i > 0 && record[i - 1] == record[i] && vis[i - 1] == false) { 
				continue;
			}
			if (vis[i] == false) {  // 当前元素未抽取
				vis[i] = true;
				arr[k] = record[i];
				permutation(k + 1, arr);
				vis[i] = false;  // 回溯
			}
		}
	}
    
}

9. 合法括号

思路解析：

输出合法的括号组合，输入括号对数，输出所有合法组合

输入:3

输出:()()(),((())),(()()),()(()),(())(),

判断一个字符串是否合法

思路解析：

f(n)=对f(n-1)中的每一个元素左边加括号，右边加括号，外层加括号

代码：

package 逐步生成式递归;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * @author: DreamCode
 * @file: 合法括号.java
 * @time: 2022年3月25日-上午9:43:12
 */
public class 合法括号 {

	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int n=scanner.nextInt();
		Set<String> ans= recursion(n);
		for(String string:ans) {
			System.out.print(string+"、");
		}
	}

	private static Set<String> recursion(int n) {
		Set<String> ans = new HashSet<>();
		if(n==1) {
			ans.add("()");
			return ans;
		}
		Set<String> ans_n_1 = recursion(n-1);
		for(String string:ans_n_1) {
			ans.add("()"+string);  //加左括号
			ans.add(string+"()");  //加右括号
			ans.add("("+string+")");  //外层加括号
		}
		return ans;
	}

}

10. 硬币表示

问题描述：

假设我们有8种不同面值的硬币｛1，2，5，10，20，50，100，200｝，用这些硬币组合构成一个给定的数值n。

例如n=200，那么一种可能的组合方式为 200 = 3 * 1 + 1＊2 + 1＊5 + 2＊20 + 1 * 50 + 1 * 100.
问总共有多少种可能的组合方式？ (这道题目来自著名编程网站ProjectEuler) 类似的题目还有：

[华为面试题] 1分2分5分的硬币三种，组合成1角，共有多少种组合 1x + 2y + 5*z=10 [创新工厂笔试题]
有1分，2分，5分，10分四种硬币，每种硬币数量无限，给定n分钱，有多少组合可以组成n分钱
1 5 10 25 分 n,多少种组合方法.

思路解析：

递归方式：f(n,a)=f(n-k*coins[a],a-1)+k

迭代方式：动态规划

代码：

package 逐步生成式递归;

/**
 * @author: DreamCode
 * @file: 硬币表示.java
 * @time: 2022年3月24日-上午9:51:15
 * @思路:
 */
public class 硬币表示 {

	/**
	 * 假设我们有8种不同面值的硬币｛1，2，5，10，20，50，100，200｝，用这些硬币组合构成一个给定的数值n。
	 * 例如n=200，那么一种可能的组合方式为 200 = 3 * 1 + 1＊2 + 1＊5 + 2＊20 + 1 * 50 + 1 * 100.
	 * 问总共有多少种可能的组合方式？ (这道题目来自著名编程网站ProjectEuler) 类似的题目还有：
	 * 
	 * [华为面试题] 1分2分5分的硬币三种，组合成1角，共有多少种组合 1*x + 2*y + 5*z=10 [创新工厂笔试题]
	 * 有1分，2分，5分，10分四种硬币，每种硬币数量无限，给定n分钱，有多少组合可以组成n分钱
	 * 
	 * 1 5 10 25 分 n,多少种组合方法.
	 */
	static long[][] rec;
	static int[] coins = { 1, 2, 5, 10, 20, 50, 100, 200 };

	public static void main(String[] args) {
		int n = 1000;
		rec = new long[n + 1][coins.length];
		long ans1 = recursion(n, coins.length - 1); // 递归
		long ans2 = iteration(n); // 递推（动态规划）二维
		long ans3 = iteration2(n); // 递推（动态规划）一维
		System.out.println(ans1);
		System.out.println(ans2);
		System.out.println(ans3);

	}

	private static long iteration2(int n) {
		// TODO 迭代方式（动态规划）一维
		int[] dp = new int[n + 1]; // 记录每种面值可以兑换的方法数
		dp[0] = 1; // 面值为0只有一种兑换方法
		for (int i = 0; i < coins.length; i++) {
			for (int j = coins[i]; j <= n; j++) {
				dp[j] = dp[j] + dp[j - coins[i]];
			}
		}
		return dp[n];
	}

	private static long iteration(int n) {
		// TODO 迭代方式（动态规划）二维
		int[][] dp = new int[coins.length][n + 1];
		for (int i = 0; i <= n; i++) { // 只有“1”这种硬币的兑换方式都只有1种
			dp[0][i] = 1;
		}
		for (int i = 0; i < coins.length; i++) { // 不管有哪些硬币，兑换“0”都只有一种方法
			dp[i][0] = 1;
		}
		for (int i = 1; i < coins.length; i++) {
			for (int j = 1; j <= n; j++) { // 用前i种硬币兑换j的面值
				for (int k = 0; k <= j / coins[i]; k++) { // 当前兑换i种硬币的个数
					dp[i][j] += dp[i - 1][j - k * coins[i]];
				}
			}
		}
		return dp[coins.length - 1][n];
	}

	private static long recursion(int n, int available) {
		// TODO 递归方式：f(n,a)=f(n-k*coins[a],a-1)+k
		if (rec[n][available] != 0) {
			return rec[n][available];
		}
		if (available == 0 || n == 0) { // 当前只有“1”这一种硬币，必然只有一种兑换方法
			return 1;
		}
		long res = 0;
		for (int k = 0; k * coins[available] <= n; k++) {
			res += recursion(n - k * coins[available], available - 1);
		}
		rec[n][available] = res;
		return res;
	}

}
梦码城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
生成式人工智能（AIGC）之最全详解图解
DFCED的博客
02-13 3万+
生成式人工智能（AIGC）之最全详解图解1. AIGC的发展历程1.1 AIGC演化重要时间节点AIGC发展历程图OpenAI大语言模型发展进程1.2技术推进路线2.AIGC技术场景2.1 技术场景3.1AIGC相关应用4.AIGC未来发展前景 1. AIGC的发展历程 AIGC（AI-Generated Content）是利用人工智能技术来生成内容。2021年之前，AIGC生成的主要还是文字，而新一代模型可以处理的格式内容包括：文字、语音、代码、图像、视频、机器人动作等等。AIGC被认为是继专业生产内容
MOOC 数据结构 第六周
weixin_46226815的博客
08-03 2663
1.一个正确的递归算法通常包含（ C）。 A.递归出口 B.递归体 C.递归出口和递归体 D.以上都不包含 2.递归函数f(x，y)定义如下： f(x，y)=f(x-1，y)+f(x，y-1) 当x>0且y>0 f(x，y)=x+y 否则 则f(2，1)的值是（ D）。 A.1 B.2 C.3 D.4 3.某递归算法的执行时间的递推关系如下： T(n)=1 当n=1时 T(n)=T(n/2)+1
武汉大学数据结构MOOC第6周测验
猪脚王的博客
11-15 1819
1单选(2分)一个正确的递归算法通常包含（ ）。 A.递归出口 B.递归体 C.递归出口和递归体 D.以上都不包含 正确答案：C 解析： C、正确的递归算法应包含递归出口和递归体两部分，缺一不可。 2单选(2分)递归函数f(x，y)定义如下： f(x，y)=f(x-1，y)+f(x，y-1) 当x>0且y>0 f(x，y)=x+y 否则 则f(2，1)的值是（ ）。 A.1 B.2 C.3 D.4 正确答案：D 解析： D、f(2,1)=f(1
递归计算向非递归计算转换模板-转自http://mingliangfeng.javaeye.com/blog/201084
iteye_289的博客
01-14 227
最近由于工作上的需要，研究了一下递归计算向非递归计算的转换问题。理论上而言，所有递归程序都可以用非递归程序来实现；这种理论的基础是递归程序的计算总能用一颗树型结构来表示。递归计算从求树根节点的值开始，树根节点的值依赖一个或多个子节点的值，子节点的值又依赖下一级子节点的值，如此直至树的叶子节点。叶子节点的值能直接计算出来，也就是递归程序的出口。如下图所示，是递归函数f(x) = f(x-1) + f...
京东2016研发工程师编程题
CYF18120161685的专栏
09-07 431
上台阶时间限制：3秒 空间限制：32768K 有一楼梯共m级，刚开始时你在第一级，若每次只能跨上一级或者二级，要走上m级，共有多少走法？注：规定从一级到一级有0种走法。 给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100。为了防止溢出，请返回结果Mod 1000000007的值。 测试样例： 3 返回：2思路： fabonacci数列 注意：初始条件，一开
程序员面试金典：上楼梯、机器人走方格I
feeling good
07-22 787
1.上楼梯 题目描述 有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶、3阶。请实现一个方法，计算小孩有多少种上楼的方式。为了防止溢出，请将结果Mod 1000000007 给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100000。 测试样例： 1 返回：1
递归式特征消除：Recursive feature elimination
热门推荐
FontTian的博客
01-08 3万+
简述 特征的选取方式一共有三种，在sklearn实现了的包裹式(wrapper)特诊选取只有两个递归式特征消除的方法，如下： recursive feature elimination ( RFE )通过学习器返回的 coef_ 属性 或者 feature_importances_ 属性来获得每个特征的重要程度。 然后，从当前的特征集合中移除最不重要的特征。在特征集合上不断的重复递归这个步骤
[算法系列] 深入递归本质+经典例题解析——如何逐步生成, 以此类推,步步为营
lawfree的博客
02-29 2658
[算法系列] 深入递归(1) 本文是递归系列的第三篇, 第一篇介绍了递归的形式以及递归设计方法(迭代改递归),;第二篇以递归为引子, 详细介绍了快排和归排以及堆排的核心思想; 本篇主要通过几个题, 从递推, 归纳法的角度, 深入了介绍了递归的本质和具体应用. 往期回顾: 搞懂递归, 看这篇就够了 !! 递归设计思路 + 经典例题层层递进 递归应用: 快速排序+归并排序算法及其核心思想与拓展 … ...
递归笔记
baidu_28017013的博客
10-12 692
目录日常遇到的递归阶乘计算斐波那契数列计算倒序输出正整数新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 日常遇...
leetcode 46. Permutations 迭代+递归 python3
12-21
LeetCode第46题的解决方案展示了如何使用递归和迭代生成全排列。虽然递归方法更加直观，但由于可能的重复计算，其空间效率较低。迭代方法虽然实现相对复杂，但能有效地减少不必要的计算，提高空间效率。在实际编程中...
FOR循环语句的翻译程序设计（递归下降法、输出四元式）
01-11
它基于编译原理中的上下文无关文法，通过递归函数来匹配输入的源代码，逐步构建语法树。在处理FOR循环时，递归下降法会定义一个或多个函数来对应FOR循环的各个部分，如初始化、条件检查、循环体和更新。例如： ```...
ARGAN：基于递归生成对抗网络的阴影检测和消除
10213ARGAN：用于阴影检测和消除的注意递归生成对抗网络丁斌1、龙澄江2 *、张玲3、肖春霞1 *1武汉大学计算机科学学院，湖北武汉2Kitware Inc.，关闭NY，USA3武汉科技大学，中国湖北武汉dingbin@whu.edu.cn，...
数据结构（字符串和多维数组）
梦码城博客中心
01-03 1577
1. 字符串匹配（BF算法） 【问题描述】给定两个字符串S和T，在主串中寻找字串T的过程称为模式匹配，T称为模式。如果匹配成功，返回T在S中的位置；如果匹配失败，返回0。 【输入形式】两行，第一行是主串S，第二行是模式串T 【输出形式】模式串T第一次出现在主串S中的位置。 【样例输入】 abcabcacb abcac 【样例输出】4 【样例说明】注意返回的是模式串在主串的位置，区别存储时的角标。 【评分标准】注意读入字符时，有可能中间含有空格字符。所以可以用getline读取字符串。 #include&lt
数据结构（树和二叉树）
梦码城博客中心
01-03 1427
1. 前序打印叶子结点 【问题描述】设计算法，要求按照前序遍历方式打印二叉树的叶子结点。 【输入形式】一行字符串，该行是扩展二叉树的前序遍历序列，用于构造二叉树。 【输出形式】二叉树的前序叶子遍历序列（中间用空格隔开）。 【样例输入】AB#D##C## 【样例输出】 D C #include <iostream> #include <string> using namespace std; struct BiNode { char data; BiNode *L_child;
数据结构（栈和队列）
梦码城博客中心
01-03 1362
1. 数制转换 【问题描述】 十进制数N和其他d进制数的转换是计算机实现计算的基本问题，其解决方法很多，其中一个简单算法基于下列原理： N = (N div d) * d +(N mod d) 其中div是整除运算，mod是求余运算。 例如（2018）10= （3742）8= （7E2）16 【输入形式】一个十进制数以及d进制数(2<=d<=16) 【输出形式】该十进制数所对应d进制数 【样例输入】2018 16 【样例输出】7E2 #include<iostream> using
数据结构（图）
梦码城博客中心
01-04 1176
1. 基于邻接矩阵存储的有向图，求出度为零的顶点个数 【问题描述】基于邻接矩阵存储的有向图，设计算法求出度为零的顶点个数。 【输入形式】第一行输入图的顶点个数verNum和边的个数edgeNum，用于构造图。 第二行顶点信息；接下来edgeNum行，每行描述一条边的信息，即起点、终点，以及边上的整型权值。 【输出形式】出度为零的顶点个数。 【样例输入】 6 9 A B C D E F A B 34 A C 46 A F 19 B E 12 C D 17 C F 25 D E 38 D F
数据结构（链表）
梦码城博客中心
01-03 1026
1. 实验一 顺序表 【问题描述】请阅读以下顺序表的实现代码，完善并实现顺序表的插入和删除操作。 【举例】 请输入顺序表的最大长度：20 请输入顺序表的数据的个数：5 请依次输入5个数据：2 4 6 8 10 请输入插入数据的位置和数值：2 3 执行插入操作后的顺序表：2 3 4 6 8 10 请输入删除数据的位置：3 执行删除操作后的顺序表：2 3 6 8 10 #include<iostream> #include<stdlib.h> using namesp
常用的排序算法
梦码城博客中心
04-10 999
本文目录1. 冒泡排序2. 选择排序3. 插入排序4. 堆排序4. TopK问题5. 排序数组中找指定和的因子6. 判断数组的包含问题7. 数组能排成的最小数8. 需排序的子数组长度 1. 冒泡排序 算法思路： 第一趟，通过两两交换的手段，将最大元素顶到最末端 第二趟，将次大元素顶到倒数第二个位置 ………………………………………… 时间复杂度：O(n²) 空间复杂度：O(1) 原址排序 稳定性：有相同元素，排序前和排序后相对位置不会变化，稳定 代码： package 排序; /** * @autho
java stream流递归生成树
最新发布
07-25
Java Stream API 提供了一种基于函数式编程风格的数据处理方式，可以用来简化并行操作、数据转换等任务。虽然 Java Streams 并不是直接用于生成树结构的工具，但它们能够非常方便地配合其他 Java 类库（如 Apache Commons Lang 的 RecursiveTreeBuilder 或自定义算法）来构建或操作树形结构。 在讨论如何使用 Java Stream API 来递归生成树之前，我们需要了解基本的树形结构及其关键组件： - **节点**：树的基本单位，通常包含数据和指向其子节点的引用。 - **根节点**：树的最顶级节点，无父节点。 - **子节点**：每个非叶子节点都有一个或多个子节点。 ### 使用 Java Stream 实现树的构建 虽然 Java Stream 主要用于处理集合，并非直接用于递归生成树，但在某种程度上，通过将递归过程转换为迭代形式，我们可以在一定程度上利用 Stream 来构建树状结构。下面是一个简单的示例，展示如何使用 Stream 构建树形结构。假设我们有一个代表树节点的简单类 `TreeNode`： ```java class TreeNode { String value; List<TreeNode> children; public TreeNode(String value) { this.value = value; this.children = new ArrayList<>(); } // 添加子节点 public void addChild(TreeNode child) { children.add(child); } } ``` #### 示例：使用递归来创建树结构 下面的例子展示了如何使用递归和 Java Streams 的组合来创建树结构。在这个例子中，我们将从一个列表开始，其中包含了父节点与子节点的关系，然后逐步构建树结构。 ```java public class TreeBuilder { public static TreeNode buildTree(List<NodePair> nodePairs) { return nodePairs.stream() .reduce(new TreeNode(null), (parent, next) -> { if (next.getParent() == null || parent.getValue().equals(next.getParent())) { parent.addChild(new TreeNode(next.getValue())); return parent; } else { return null; // 这里只是举例，实际情况下需要更复杂的逻辑来调整路径 } }, (left, right) -> left); // 使用空值作为初始节点，最终返回构建完成的根节点 // NodePair 类表示一个节点及其父节点名称 class NodePair { String value; String parent; public NodePair(String value, String parent) { this.value = value; this.parent = parent; } public String getParent() { return parent; } public String getValue() { return value; } } } } // 测试数据 List<NodePair> nodePairs = Arrays.asList( new NodePair("nodeB", "nodeA"), new NodePair("nodeD", "nodeC"), new NodePair("nodeE", "nodeC") ); TreeNode root = TreeBuilder.buildTree(nodePairs); root.getChildren().forEach(System.out::println); // 打印树的所有节点以验证结果 ``` 请注意，上述代码仅展示了如何将数据映射到树结构的基础概念。实际上，在构建树的过程中可能涉及到更复杂的问题，比如循环依赖检查、优化路径查找或添加额外的属性到节点上等等。在真正的应用中，你可能需要设计更多的辅助类和逻辑来处理各种情况。此外，这个示例并没有使用实际的 Stream 减少机制，而是简单地使用了 reduce 操作来进行构建。对于大型树结构的构建，使用传统的 for 循环或递归可能会更高效。 ### 相关问题: 1. **如何在构建树过程中处理循环依赖问题？** - 当遇到循环依赖时，应采取策略来避免无限递归，例如，可以限制递归深度或使用图论中的拓扑排序来检测和处理循环。 2. **Stream 是否适用于大规模树结构的构建？** - 尽管 Stream API 提供了一个优雅的方式来处理集合和序列化操作，但对于构建大型或极其复杂的树结构，由于内存管理和并行计算的限制，可能需要考虑使用传统循环或其他非函数式编程技术。 3. **在实际项目中应该选择哪种方式构建树结构？** - 这取决于具体的业务需求和系统的性能约束。如果系统允许并发处理并且对代码的简洁性和易读性有较高要求，那么使用 Stream 可能是更好的选择；而对于性能敏感的应用场景，则可能需要权衡代码复杂度和执行效率，考虑使用迭代或其他数据处理机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦码城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值