JAVA递归
java全排列递归算法
java全排列递归算法全排列是指将一组元素按照一定的顺序进行排列，使得每个元素都能够出现在每个位置上，且每个元素只能出现一次。
在Java中，可以使用递归算法来实现全排列。
递归算法是一种通过调用自身来解决问题的方法。
在全排列问题中，可以通过递归的方式来生成所有可能的排列。
首先，我们需要定义一个递归函数，该函数接受一个数组和两个整数作为参数。
其中，数组表示待排列的元素，第一个整数表示当前排列的起始位置，第二个整数表示当前排列的结束位置。
在递归函数中，我们首先判断当前排列是否已经完成。
如果起始位置等于结束位置，说明已经完成了一次排列，我们可以将当前排列输出。
否则，我们需要对当前排列进行递归调用。
在递归调用中，我们需要将当前排列的起始位置与结束位置进行交换，然后对剩余的元素进行递归调用。
递归调用完成后，我们需要将当前排列的起始位置与结束位置进行交换，以便进行下一次排列。
下面是一个使用递归算法实现全排列的Java代码示例：```javapublic class Permutation {public static void permute(int[] nums, int start, int end) {if (start == end) {for (int num : nums) {System.out.print(num + " ");}System.out.println();} else {for (int i = start; i <= end; i++) {swap(nums, start, i);permute(nums, start + 1, end);swap(nums, start, i);}}}public static void swap(int[] nums, int i, int j) { int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}public static void main(String[] args) {int[] nums = {1, 2, 3};permute(nums, 0, nums.length - 1);}}```在上述代码中，我们定义了一个`permute`函数来实现全排列。
java循环和递归
java循环和递归在Java编程中，循环和递归是两种常用的控制结构，用于解决重复性的任务和处理递归问题。
循环可以用来重复执行一段代码，而递归则是通过调用自身来解决问题。
本文将介绍Java中的循环和递归的概念、用法和一些常见的应用场景。
一、循环的概念和用法循环是一种重复执行一段代码的控制结构。
在Java中，常见的循环结构有for循环、while循环和do-while循环。
1. for循环for循环是一种在已知循环次数的情况下重复执行一段代码的结构。
它的语法如下：```for (初始化表达式; 循环条件; 更新表达式) {// 循环体}```其中，初始化表达式用于初始化循环变量；循环条件是一个布尔表达式，用于判断是否继续执行循环；更新表达式用于更新循环变量的值。
for循环的执行顺序是先执行初始化表达式，然后判断循环条件，如果为真则执行循环体，然后执行更新表达式，再次判断循环条件，以此类推，直到循环条件为假时结束循环。
for循环的一个常见应用是遍历数组或集合。
例如，可以使用for循环计算数组中元素的总和：```int[] nums = {1, 2, 3, 4, 5};int sum = 0;for (int i = 0; i < nums.length; i++) {sum += nums[i];}System.out.println("数组的总和为：" + sum);```2. while循环while循环是一种在未知循环次数的情况下重复执行一段代码的结构。
它的语法如下：```while (循环条件) {// 循环体}```while循环的执行顺序是先判断循环条件，如果为真则执行循环体，然后再次判断循环条件，以此类推，直到循环条件为假时结束循环。
while循环的一个常见应用是读取用户输入，直到满足特定条件为止。
例如，可以使用while循环验证用户输入的密码是否正确：```import java.util.Scanner;Scanner scanner = new Scanner(System.in);String password = "123456";String input;do {System.out.println("请输入密码：");input = scanner.nextLine();} while (!input.equals(password));System.out.println("密码正确！");```3. do-while循环do-while循环是一种在未知循环次数的情况下重复执行一段代码的结构，与while循环的区别在于它先执行一次循环体，然后再判断循环条件。
java递归写法
java递归写法递归是一种重要的算法思想，它可以用来解决很多问题，例如数学中的阶乘、斐波那契数列、树的遍历等。
在Java中，递归的写法可以很简单，但是如果不小心就会出现栈溢出等问题。
本文将介绍Java中递归的写法，以及如何避免递归过程中出现的一些问题。
一、递归的概念递归是一种函数调用自身的算法思想。
它通过将一个问题分解为更小的子问题来解决问题。
递归算法的基本思路是：当问题的规模足够小时，直接求解；否则，将问题分解为规模更小的子问题，递归地解决子问题，最后将子问题的结果合并起来得到原问题的解。
递归算法有两个重要的特点：一是递归调用函数本身；二是需要有一个递归终止条件。
递归调用函数本身是为了将问题规模缩小，递归终止条件是为了避免无限递归。
二、递归的实现递归的实现需要考虑两个方面：递归调用和递归终止条件。
递归调用是指在函数中调用自身，递归终止条件是指当问题规模足够小时，直接求解。
例如，求n的阶乘可以使用递归实现。
当n等于1时，阶乘为1；否则，阶乘为n乘以(n-1)的阶乘。
代码如下：```javapublic class Factorial {public static long factorial(int n) {if (n == 1) {return 1;} else {return n * factorial(n - 1);}}}```这段代码中，递归调用在return语句中，递归终止条件是当n 等于1时，直接返回1。
三、递归的应用递归算法可以用来解决很多问题，例如数学中的阶乘、斐波那契数列、树的遍历等。
下面分别介绍这些应用。
1. 阶乘阶乘是指从1到n的所有正整数相乘的积。
例如，5的阶乘为5x4x3x2x1=120。
使用递归算法可以很容易地求出n的阶乘。
代码如下：```javapublic class Factorial {public static long factorial(int n) {if (n == 1) {return 1;} else {return n * factorial(n - 1);}}}```2. 斐波那契数列斐波那契数列是指第n个数等于前两个数之和。
java-递归练习
java-递归练习1、从键盘接收⼀个⽂件夹路径，统计该⽂件夹⼤⼩1public class Test1 {23/**4 * @param args5 * 需求:1,从键盘接收⼀个⽂件夹路径,统计该⽂件夹⼤⼩6 *7 * 从键盘接收⼀个⽂件夹路径8 * 1,创建键盘录⼊对象9 * 2,定义⼀个⽆限循环10 * 3,将键盘录⼊的结果存储并封装成File对象11 * 4,对File对象判断12 * 5,将⽂件夹路径对象返回13 *14 * 统计该⽂件夹⼤⼩15 * 1,定义⼀个求和变量16 * 2,获取该⽂件夹下所有的⽂件和⽂件夹listFiles();17 * 3,遍历数组18 * 4,判断是⽂件就计算⼤⼩并累加19 * 5,判断是⽂件夹,递归调⽤20*/21public static void main(String[] args) {22//File dir = new File("F:\\day06");23//System.out.println(dir.length()); //直接获取⽂件夹的结果是024 File dir = getDir();25 System.out.println(getFileLength(dir));2627 }2829/*30 * 从键盘接收⼀个⽂件夹路径31 * 1,返回值类型File32 * 2,参数列表⽆33*/34public static File getDir() {35//1,创建键盘录⼊对象36 Scanner sc = new Scanner(System.in);37 System.out.println("请输⼊⼀个⽂件夹路径:");38//2,定义⼀个⽆限循环39while(true) {40//3,将键盘录⼊的结果存储并封装成File对象41 String line = sc.nextLine();42 File dir = new File(line);43//4,对File对象判断44if(!dir.exists()) {45 System.out.println("您录⼊的⽂件夹路径不存在,请输⼊⼀个⽂件夹路径:");46 }else if(dir.isFile()) {47 System.out.println("您录⼊的是⽂件路径,请输⼊⼀个⽂件夹路径:");48 }else {49//5,将⽂件夹路径对象返回50return dir;51 }52 }5354 }5556/*57 * 统计该⽂件夹⼤⼩58 * 1,返回值类型long59 * 2,参数列表File dir60*/61public static long getFileLength(File dir) { //dir = F:\day06\day0762//1,定义⼀个求和变量63long len = 0;64//2,获取该⽂件夹下所有的⽂件和⽂件夹listFiles();65 File[] subFiles = dir.listFiles(); //day07 Demo1_Student.class Demo1_Student.java66//3,遍历数组67for (File subFile : subFiles) {68//4,判断是⽂件就计算⼤⼩并累加69if(subFile.isFile()) {70 len = len + subFile.length();71//5,判断是⽂件夹,递归调⽤72 }else {73 len = len + getFileLength(subFile);74 }75 }76return len;77 }78 }2、从键盘接收⼀个⽂件夹路径，删除该⽂件夹1public class Test2 {23/**4 * 需求:2,从键盘接收⼀个⽂件夹路径,删除该⽂件夹5 *6 * 删除该⽂件夹7 * 分析:8 * 1,获取该⽂件夹下的所有的⽂件和⽂件夹9 * 2,遍历数组10 * 3,判断是⽂件直接删除11 * 4,如果是⽂件夹,递归调⽤12 * 5,循环结束后,把空⽂件夹删掉13*/14public static void main(String[] args) {15 File dir = Test1.getDir(); //获取⽂件夹路径16 deleteFile(dir);17 }1819/*20 * 删除该⽂件夹21 * 1,返回值类型 void22 * 2,参数列表File dir23*/24public static void deleteFile(File dir) {25//1,获取该⽂件夹下的所有的⽂件和⽂件夹26 File[] subFiles = dir.listFiles();27//2,遍历数组28for (File subFile : subFiles) {29//3,判断是⽂件直接删除30if(subFile.isFile()) {31 subFile.delete();32//4,如果是⽂件夹,递归调⽤33 }else {34 deleteFile(subFile);35 }36 }37//5,循环结束后,把空⽂件夹删掉38 dir.delete();39 }40 }3、从键盘接收两个⽂件夹路径，把其中⼀个⽂件夹中(包含内容)拷贝到另⼀个⽂件夹中 1public class Test3 {23/**4 * 需求:3,从键盘接收两个⽂件夹路径,把其中⼀个⽂件夹中(包含内容)拷贝到另⼀个⽂件夹中5 *6 * 把其中⼀个⽂件夹中(包含内容)拷贝到另⼀个⽂件夹中7 * 分析:8 * 1,在⽬标⽂件夹中创建原⽂件夹9 * 2,获取原⽂件夹中所有的⽂件和⽂件夹,存储在File数组中10 * 3,遍历数组11 * 4,如果是⽂件就⽤io流读写12 * 5,如果是⽂件夹就递归调⽤13 * @throws IOException14*/15public static void main(String[] args) throws IOException {16 File src = Test1.getDir();17 File dest = Test1.getDir();18if(src.equals(dest)) {19 System.out.println("⽬标⽂件夹是源⽂件夹的⼦⽂件夹");20 }else {21 copy(src,dest);22 }23 }24/*25 * 把其中⼀个⽂件夹中(包含内容)拷贝到另⼀个⽂件夹中26 * 1,返回值类型void27 * 2,参数列表File src,File dest28*/29public static void copy(File src, File dest) throws IOException {30//1,在⽬标⽂件夹中创建原⽂件夹31 File newDir = new File(dest, src.getName());32 newDir.mkdir();33//2,获取原⽂件夹中所有的⽂件和⽂件夹,存储在File数组中34 File[] subFiles = src.listFiles();35//3,遍历数组36for (File subFile : subFiles) {37//4,如果是⽂件就⽤io流读写38if(subFile.isFile()) {39 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(subFile));40 BufferedOutputStream bos =41new BufferedOutputStream(new FileOutputStream(new File(newDir,subFile.getName()))); 4243int b;44while((b = bis.read()) != -1) {45 bos.write(b);46 }4748 bis.close();49 bos.close();50//5,如果是⽂件夹就递归调⽤51 }else {52 copy(subFile,newDir);53 }54 }55 }56 }4、从键盘接收⼀个⽂件夹路径，把⽂件夹中的所有⽂件以及⽂件夹的名字按层级打印1public class Test4 {23/**4 * 需求:4,从键盘接收⼀个⽂件夹路径,把⽂件夹中的所有⽂件以及⽂件夹的名字按层级打印, 例如:5 * 把⽂件夹中的所有⽂件以及⽂件夹的名字按层级打印6 * 分析:7 * 1,获取所有⽂件和⽂件夹,返回的File数组8 * 2,遍历数组9 * 3,⽆论是⽂件还是⽂件夹,都需要直接打印10 * 4,如果是⽂件夹,递归调⽤11 * day0712 * day0813 * xxx.jpg14 * yyy.txt15 * Demo1_Consturctor.class16 * Demo1_Consturctor.java17 * Demo1_Student.class18 * Demo1_Student.java19*/20public static void main(String[] args) {21 File dir = Test1.getDir(); //获取⽂件夹路径22 printLev(dir,0);23 }2425public static void printLev(File dir,int lev) {26//1,把⽂件夹中的所有⽂件以及⽂件夹的名字按层级打印27 File[] subFiles = dir.listFiles();28//2,遍历数组29for (File subFile : subFiles) {30for(int i = 0; i <= lev; i++) {31 System.out.print("\t");32 }33//3,⽆论是⽂件还是⽂件夹,都需要直接打印34 System.out.println(subFile);35//4,如果是⽂件夹,递归调⽤36if(subFile.isDirectory()) {37//printLev(subFile,lev + 1);38 printLev(subFile,++lev);39 }40 }41 }4243 }5、斐波那契数列1public class Test5 {23/**4 * * 不死神兔5 * 故事得从西元1202年说起，话说有⼀位意⼤利青年，名叫斐波那契。
java递归算法经典题目
java递归算法经典题目递归是一种常见的算法思想，它通过将问题分解为更小的子问题来解决问题。
在Java中，递归算法可以用于解决许多经典问题，如斐波那契数列、汉诺塔、阶乘等。
下面我们将介绍一些Java递归算法经典题目，帮助您更好地理解和掌握递归算法。
1.斐波那契数列斐波那契数列是一个经典的递归问题，它是指从第0项开始，每一项都是前两项的和。
在Java中，可以使用递归方法来求解斐波那契数列。
以下是一个简单的递归算法实现：```javapublicstaticintfibonacci(intn){if(n<=1){returnn;}else{returnfibonacci(n-1)+fibonacci(n-2);}}```这个算法会一直递归调用直到达到斐波那契数列的末项为止。
需要注意的是，递归算法的时间复杂度较高，当n值较大时可能会导致栈溢出等问题。
2.汉诺塔问题汉诺塔问题是一个经典的递归问题，它描述了一个操作：将一堆盘子从一个柱子移动到另一个柱子，要求遵循以下规则：每次只能移动一个盘子，并且大盘子不能放在小盘子上面。
在Java中，可以使用递归方法来解决汉诺塔问题。
以下是一个简单的递归算法实现：```javapublicstaticvoidhanoi(intn,Stringfrom,Stringto,Stringvia) {if(n==1){System.out.println("Movedisk"+n+"from"+from+"to"+to);}else{hanoi(n-1,from,via,to);System.out.println("Movedisk1from"+from+"to"+to);hanoi(n-1,via,to,from);}}```这个算法会一直递归调用，直到完成所有盘子的移动。
java 树形结构递归过滤
java 树形结构递归过滤Java树形结构递归过滤在Java编程中，树形结构是一种非常常见的数据结构。
它由一系列的节点构成，这些节点按照一定的层次关系连接起来。
树形结构可以用于模拟现实中的各种场景，比如文件系统、组织结构等。
然而，在实际应用中，我们经常需要对树形结构进行一些操作，如搜索、过滤等。
本文将重点讨论如何使用递归来对树形结构进行过滤操作。
第一步：了解树形结构在开始之前，首先要了解树形结构的基本概念。
树形结构由一个根节点和若干个子节点组成，每个节点包含数据以及连接到下一层节点的指针。
节点之间的连接关系遵循一定的层次关系，即每个节点最多有一个父节点和多个子节点。
# 示例：文件系统我们以文件系统为例来说明树形结构的概念。
在文件系统中，根节点表示整个文件系统，它的子节点表示根目录下的所有文件和文件夹。
每个子节点又可以有自己的子节点，构成了一个递归的树形结构。
例如，我们可以构建如下的文件系统树形结构：C:\Program FilesJavajdkbinlibApacheTomcatconflibUsersAliceBob在这个示例中，根节点表示C盘，它有两个子节点Program Files和Users。
以此类推，我们可以进一步展开每个子节点，直到最底层的叶子节点。
第二步：树形结构的递归过滤接下来，我们将树形结构的递归过滤问题进行具体讨论。
假设我们有一个文件系统树形结构，我们想要找出其中所有包含某个关键词的文件或文件夹。
这时，递归过滤就能帮助我们实现这个目标。
# 实现思路首先，我们需要定义一个递归函数来实现树形结构的遍历和过滤操作。
这个函数的输入参数包括当前节点、过滤关键词以及存储结果的数据结构。
函数的主要逻辑如下：1. 判断当前节点是否符合过滤条件，如果是，则将该节点添加到结果中。
2. 判断当前节点是否有子节点，如果有，则递归调用本函数继续遍历子节点。
3. 返回结果。
# 递归函数代码下面是一个简单的递归过滤函数的实现：javapublic void recursiveFilter(Node node, String keyword, List<Node>result) {if (node.getName().contains(keyword)) {result.add(node);}if (node.hasChildren()) {for (Node child : node.getChildren()) {recursiveFilter(child, keyword, result);}}}在这个代码中，我们通过判断节点的名称是否包含给定的关键词来决定是否将该节点添加到结果中。
java递归处理父节点选中状态
一、简介Java是一种面向对象的程序设计语言，递归是一种解决问题的常用方法，可以通过递归的方式来处理父节点的选中状态。
本文将介绍如何使用Java递归来处理父节点的选中状态，以及一些注意事项和实际应用中的示例。
二、递归处理父节点选中状态的原理1. 父节点选中状态与子节点的关系在树形结构中，父节点的选中状态通常与其子节点的选中状态有关。
当子节点全部选中时，父节点才会被选中；当子节点有部分未选中或全部未选中时，父节点则不应该被选中。
2. 递归调用的实现为了处理父节点的选中状态，我们可以使用递归的方式来遍历树形结构。
当子节点的选中状态发生变化时，可以递归地向上更新父节点的选中状态，直到根节点为止。
三、 Java中的递归处理父节点选中状态的实现1. 定义树形结构的数据模型我们需要定义树形结构的数据模型，通常可以使用树节点的类来表示。
每个树节点包含一个值和一个子节点列表，以及一个选中状态的属性。
2. 递归更新父节点的选中状态当子节点的选中状态发生变化时，可以递归地向上更新父节点的选中状态。
具体实现时，可以使用递归函数来完成这一过程。
四、注意事项1. 避免递归调用的深度过深在实际应用中，递归调用的深度应当受到限制，以避免栈溢出的风险。
可以考虑使用迭代代替递归，或者采用尾递归的方式优化递归调用。
2. 处理循环引用的情况如果树形结构中存在循环引用的情况，递归调用可能会导致无限循环。
在实际应用中，需要考虑如何处理这种情况，以避免程序陷入死循环。
五、实际应用中的示例1. 文件夹结构的表示在文件管理系统中，可以使用树形结构表示文件夹的层次关系。
当用户勾选某个文件夹时，可能需要递归更新其父文件夹的选中状态。
2. 商品类别的多级选择在电商全球信息站中，商品类别通常是多级的，用户可以选择某个类别来浏览商品。
当用户选择某个类别时，可能需要递归更新其所有父类别的选中状态。
六、总结通过本文的介绍，我们了解了如何使用Java递归来处理父节点的选中状态。
java 递归栈溢出解决方法
java 递归栈溢出解决方法在Java编程中，递归是一种强大的方法来解决问题。
然而，当递归过程中存在无限循环或者递归调用次数过多时，可能会导致栈溢出错误(StackOverflowError)。
在本文中，将介绍一些解决Java递归栈溢出错误的方法。
1. 优化递归算法递归函数可以通过优化算法来减少递归调用次数。
例如，可以使用尾递归来减少栈的使用。
尾递归是在递归函数的最后一步执行递归调用，而不进行其他任何计算。
这样可以避免不必要的栈增长。
另外，使用迭代也是一种避免栈溢出的方法。
2. 增加栈大小默认情况下，Java虚拟机为每个线程分配一块固定大小的栈空间。
可以通过设置虚拟机参数来增加栈的大小，以提高递归函数的深度。
例如，可以使用"-Xss"参数来增加栈的大小，如"-Xss4m"表示将栈的大小增加到4MB。
3. 循环替代递归有时，可以将递归算法转换为迭代算法，以避免递归过程中的栈溢出错误。
通过使用循环和临时变量来代替递归调用，可以将递归函数转换为迭代方式。
4. 限制递归深度可以在递归函数中添加一个深度限制，当递归深度超过一定值时，停止递归调用。
这种方法可以防止栈溢出错误，但需要根据具体情况确定合适的深度限制。
5. 检查递归终止条件栈溢出错误通常是由于递归没有正确的终止条件而导致的。
在编写递归函数时，务必确保存在递归的终止条件，并正确处理基本情况，以防止递归无限进行。
总结起来，解决Java递归栈溢出错误的方法包括优化递归算法、增加栈大小、循环替代递归、限制递归深度和检查递归终止条件。
选择合适的方法取决于具体的问题和需求。
通过合理的优化和调整，可以有效避免递归栈溢出错误的发生，确保程序的正常运行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
返回目录
2 对数列求和
※许多数学函数都是使用递归来定义的。我们首先从简单的例子研究起:
例：编写一个递归的方法来计算下面的级数；
m(i)=1/3+2/5+3/7+4/9+5/11+6/13+…i/(2i+1).
3 背包问题
递归算法：
bool knap(m,n) {
计科121404219 汤鑫 计科121404101 白钢
2014/09/18
引言
数列 求和
纵向显 示整数
背包 问题
字符串 排列
最大公约数
总结
引言
递归是一种方法（函数）调用自己的 编程技术，它在定义自身的同时又出现了 对自身的引用，有点类似于我们高中学的 的数学归纳法。用递归的目的在于解决一 种常见问题，即子任务不过是开始试图解 决的相同问题的一个较简单版本。
3 背包问题
现在将背包问题复杂化：一个背包容纳的物品最大质量为m, 现有n件物品，质量为m1,m2,… ,mn,均为正整数。要求从中 挑选若干件，使背包质量之和正好为m。
设用knap(m,n)来表示此问题。有解为true,否则为false。
3 背包问题
先考虑将物品mn放入背包的情况：
knap(m,n) = *若mn = m , 则knap(m,n) ← true *若mn > m,则knap(m,n) ← knap(m,n-1) *若mn < m， 则knap(m,n) ← knap(m,n-1) ＋knap(m-mn,n-1)
11,5
// Target=9, 5 is to small, no more items
8
// Target=20, 8 is to small
8,7
// Target=12, 7 is to small
8,7,6
// Target=5, 6 is to big8,7,5
8,7,5
// Target=5, 5 is right.
3 背包问题
分析：
1、如果选择的数据项的重量总和符合目标重量，工作就完成了。 2、从选择第一个数据项开始，剩余的数据项的加和必须符合背包 的目标重量减去第一个数据项的重量：这是一个新的目标重量。 3、逐个地试每种剩余数据项组合的可能性，但是，注意并不需要 去试所有的组合，因为只要数据项的和大于目标重量的时候，就 停止添加数据项。 4、如果没有组合合适的话，放弃第一个数据项，并且从第二个数 据项开始再重复一遍整个过程。 5、继续从第三个数据项开始，如此下去，直到试过所有组合，这 时就知道有没有解决方案。
2 对数列求和
由题可知a(i)=i/(2i+1)，要求a(i)就需要知道a(i-1)，由此可推，只要知道a(1)就可以 求a(i)。这里用递归方法就可以很简单的求解。
i
计算
1
1/3
2
1/3+2/5
3
11/15+3/7
4
122/105+4/9
5
506/315+5/11
6
7141/3465+6/13
… ……
3 背包问题
一个递归的程序能选择 第一个数据项，并且， 如果这个数据项比目标 重量小，程序可以用一 个新的目标值来调用自 身以继续试探剩余数据 项的和。
IHale Waihona Puke ems:11,8,7,6,5*********************************
11
// Target=20, 11 is to small
6/2= 3 ……} 0
3/2= 1 …… 1
当最后n=0时即可结束递归
1/2= 0 …… 1
返回目录
3 背包问题
例：试图将不同重量的数据项房入背包中，以使背包最
后达到指定的总重量。 如：背包精确地承重20磅，并且有5个可以选择放入的数据 项，它们的重量分别为11磅、8磅、7磅、6磅和5磅。对于选 择放入的数据项数量不大时，我们通过观察就可以解决这个 问题，只需放入8、7、5磅的数据项即可。 可是当背包所承受的总重量和数据项的重量过大时，我们需 要借用计算机来解决问题。
十进制转二进制
例：编写一个递归的方法，将一个整型十进制数转换为
一个二进制数。
分析：平常我们将p十ub进lic制st数atnic转vo化id成to二Bi进na制ry(数int时n，um是){将n不断除2， 然后所得的余数，从下if往(nu上m读/2取==0。){//此时已经计算到了结束
例如97：97/2=48……1} System.out.print(num%2); 48/2=24……0else{ 24/2=12……0 toBinary(num/2);//向下继续计算 System.out.print(num%2); 12/2= 6 ……0}
i
m(i-1)+i/(2i+1)
m(i) 1/3 11/15 122/105 506/315 7141/315 113623/45045 …… m(i）
2 对数列求和
边界
由表可知递归方程：
条件
1/3，i=1;
m(i)=
递归方程
“边界条件”是递归的 必要条件之一（它是递 归运算的出口）：另一 个条件是递归体,前者 确定递归到何时结束,
11,8
// Target=9, 8 is to small
11,8,7
// Target=1, 7 is to big
11,8,6
// Target=1, 6 is to big
11,8,5
// Target=1, 5 is to big, no more items
11,7
// Target=9, 7 is to small
11,7,6
// Target=2, 6 is to big
11,7,5
// Target=2, 5 is to big, no more items
11,6
// Target=9, 6 is to small
11,6,5
// Target=3, 5 is to big, no more items
m(i-1)+i/(2*i+1).
后者确定递归求解时的
所以，计算sequence_m(i)的算法可以简单如下：递推关系。
if(i==1)
return 1/3;
else
return sequence_m(i-1)+i/(2*i+1);
递归
现在大家应该对递归方法有了初步的了解 ， 可以开始用递归解决简单问题了。