Java 面向对象 递归方法的使用 斐波那契数列 汉诺塔问题

概念

递归方法：一个方法体内调用它自身。
方法地柜包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这些递归变成了无穷递归，类似于死循环。

//计算1-100之间的左右自然数的和
public int sum(int num){
    if(num==1){
        return 1;
    }else{
        return num+sum(num-1);
    }
}

例一

计算1-100之间所有自然数的和

public class RecursionTest {
    //例一：计算1-100之间所有自然数的和
    //方式一
    int sum = 0;
    for(int i =1;i<=100;i++){
        sum+=i;
    }
}

public class RecursionTest {
    public static void main(String[] args) {
        //例一：计算1-100之间所有自然数的和
        //方式二
        RecursionTest test = new RecursionTest();
        int sum1 = test.getSum(100);
        System.out.println(sum1);
    }

    public int getSum(int n){
        if(n == 1){
            return 1;
        }else{
            return n+getSum(n-1);
        }
    }
}

例二

    //例2：计算1-n之间所有自然数的乘积：n！
    public int getSum1(int n){
        if(n == 1){
            return 1;
        }else{
            return n * getSum1(n - 1));
        }
    }

例三

例3：已知一个数列：f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n)
其中n是大于0的整数，求f（10）的值。

public class RecursionTest {
    public static void main(String[] args) {
        //例一：计算1-100之间所有自然数的和
        //方式二
        RecursionTest test = new RecursionTest();
        System.out.println("*******************");
        test.f(10);
    }

    //例3：已知一个数列：f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n)
    //其中n是大于0的整数，求f（10）的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if (n == 1){
            return 4;
        }else{
            return f(n + 2) - 2*f(n + 1);
        }
    }
}

结果

不应该写 f(n + 2) - 2f(n + 1)
应该写乘
成这样子 return(2f(n-1)+f(n-2));

public class RecursionTest {
    public static void main(String[] args) {
        //例一：计算1-100之间所有自然数的和
        //方式二
        RecursionTest test = new RecursionTest();
        System.out.println("*******************");
        int num = test.f(10);
        System.out.println(num);

    }

    //例3：已知一个数列：f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n)
    //其中n是大于0的整数，求f（10）的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if (n == 1){
            return 4;
        }else{
            //return f(n + 2) - 2*f(n + 1);//错误 应该吧f（n+2）当做n，变换后面式子
            return(2*f(n-1)+f(n-2));
        }
    }
}

结果

例四 斐波那契数列

import java.util.Scanner;

public class RecursionTest {
    public static int fibonacciSequence(int i){
        if(i <= 1){
            return i;
        }
        return fibonacciSequence(i-1)+fibonacciSequence(i-2);
    }
    public static void main(String[] args) {
        System.out.println("请输入要计算第多少位数字:");
        Scanner scanner = new Scanner(System.in);
        int next = scanner.nextInt();
        for (int i = 0; i < next; i++) {
            System.out.print(fibonacciSequence(i)+"\t");
        }
    }
}

例五 汉诺塔问题

package project01;
/**
 * n阶汉诺塔的移动步骤
 *
 * @author meng
 *
 */
public class hannuota {
    private static int count = 0;

    public static void main(String[] args) {

        hanio(3,'x','y','z');
        System.out.println(" 总共移动了 " + count + " 次" );
    }
    /**
     * 移动
     * @param n 共需要移动的盘子
     * @param x  从起始位置
     * @param y  借助辅助塔
     * @param z  移动到终止位置
     */
    public static void hanio(int n, char x, char y, char z) {
        count++;
        if(n==1) {
            move(x,n,z);
        }else {
            hanio(n-1,x,z,y);
            move(x,n,z);
            hanio(n-1,y,x,z);
        }

    }
    /**
     * 打印移动
     * @param x  从起使位置
     * @param n  移动第几个盘子
     * @param y  要移动到的最终位置
     */
    private static void move(char x, int n, char y) {
        // TODO Auto-generated method stub
        System.out.println(" Move " + n + " from " + x + " to " + y);
    }
}

参考链接