递归基础Java

首先什么是递归：
递归的通用含义就是自己调用自己。

static void f(int i) {
        if(i==0)
            return;
        //调用自身
        f(i-1);
    }

解决递归类问题的一些知识：
找重复：

• 找到一种划分的方法
• 找到递推公式或者“等价转换”
• 都是父问题转化为求解子问题

找变化的量：

• 变化的量通常是要最为参数

找到出口：

• 根据参数变化的趋势，对边界进行控制，适时终止递归

下面是一些例题：

1. 求n的阶乘

2. 打印i到j

3. 反转字符串

4. 斐波那契数列

5. 最大公约数

6. 数组排序

   数组排序题目解析：
   对数组0_倒数第一个排序
   等价于：
   1.对数组0~倒数第二个元素，这部分进行排序
   2.然后把最后一个元素插入到这个有序的部分中

package 算法基础.递归;

import java.util.Arrays;

public class 阶乘 {
    public static void main(String[] args) {
        f(10);
        System.out.println(f1(4));
        f2(1,10);
        int[] arr={1,2,3,4};
        int res=f3(arr,0);
        System.out.println(res);
        String leng="abcd";
        System.out.println(reverse(leng,3));
       // System.out.println(reverse("abcd",3));
        System.out.println(fib(5));
        System.out.println(gcd(16,6));
        int[] arr2={4,3,5,7,9,6};
        insrtsort(arr2,5);
        System.out.println(Arrays.toString(arr2));

    }

    static void f(int i) {
        if(i==0)
            return;
        //调用自身
        f(i-1);
    }

    /**
     * 求n的阶乘
     *1.找重复 求n*f(n-1)的阶乘，求n-1的阶乘是对原问题的重复（规模更小）-子问题
     *2.找变化 变化的量作为参数
     *3.找边界 出口
     */
    static int f1(int i){
        if(i==1)
            return 1;
        return i*f1(i-1);
    }

    /**
     *打印i到j
     * 1.找重复
     * 2.找变化
     * 3.找边界
     */
    static void f2(int i,int j) {
        if(i>j)
            return;
        System.out.print(i+" ");
        f2(i+1,j);
    }
    /**
     *数组求和
     * 1.找重复
     * 2.找变化 变化的量作为参数
     * 3.找边界 出口
     */
    static int f3(int[] arr,int i){
        if(i==arr.length-1) {return arr[i];}
        return arr[i]+f3(arr,i+1);
//        temp+=arr[i];
//        f3(arr,i+1);
    }

    /**
     * 反转字符串
     * 1.找重复
     * 2.找变化
     * 3.找边界
     */
    static String reverse(String src,int end){
        if(end==0){
            return ""+src.charAt(0);
        }
        return src.charAt(end)+reverse(src,end-1);
    }

    /**
     * 斐波那契数列
     * 先横后纵 根 颈
     */

    static int fib(int n){
        if(n==1||n==2) return 1;

        return fib(n-1)+fib(n-2);
    }

    /**
     * 最大公约数
     */
    static int gcd(int m,int n){
        if(n==0){
            return n;
        }
        return gcd(n,m%n);
    }

    /**
     * 数组排序
     */
    static void insrtsort(int[] arr,int k){
        if(k==0){
            return;
        }
        //对k-1个元素进行排序
        insrtsort(arr,k-1);
        //将最后一个元素加入到前面排序好的元素中
        int x=arr[k];
        int index=k-1;
        while (index>-1&&x<arr[index]){
            arr[index+1]=arr[index];
            index--;
        }
        arr[index+1]=x;
    }

}

7.汉诺塔游戏

本题小解：
1-N从A移动到B，c作为辅助
等价于：

1. 1~N-1 从A移动到C，B为辅助
2. 把N从A移动到B
3. 1~N-1从C移动到B，A为辅助

package 算法基础.递归;

public class TowerOfHanoi {
    public static void main(String[] args) {
        printHanoiPower(3,"A","B","C");
    }

    /**
     *
     * @param N  初始的N个从小到大盘子，N是最大的
     * @param from  初始盘子
     * @param to   目标盘子
     * @param help  援助盘子
     */
    static void printHanoiPower(int N,String from,String to,String help){
        if(N==1){
            System.out.println("move"+N+"from"+from+"to"+to);
            return;
        }
        printHanoiPower(N-1,from,help,to);  //先把N-1个盘子移动到辅助空间上
        System.out.println("move"+N+"from"+from+"to"+to);  // 然后N可以顺利的到达目的盘子上
        printHanoiPower(N-1,help,to,from);  //再把N-1个盘子从辅助空间移动到源空间
    }
}