浅谈的递归思想

1. 递归定义

直接或间接的调用自身的算法（函数）称为递归算法（函数）

2. 递归思想：

（1）将原问题分解为规模较小的问题进行处理，分解后的问题与原问题类型完全相同，当规模较小，可通过小规模问题的解轻易的求得原问题的解
（2）问题的分解是有限的，当边界条件不能满足时，分解问题（继续递归），当边界问题不能满足时，直接求解
递归的应用：
我们以f(n）=n!

通过图我们很清楚的可以看到：
我们通过对函数进行分解逐层递归，最终会求出f(n)
代码实现：

   public static int  func(int n){
            n=6;
            if (n==0||n==1){
                return 1;
            }else {
                return n*func(n-1);
            }
        }

下边我们以几道题来体现递归思想
（1）求斐波那契数
1，1 ，2，3，5，8…

 public static int  func2(int n){
            n=20;
            if (n==1||n==2){
                return 1;
            }else {
                return func(n-2)+func(n-1);
            }
        }

(2)用递归的方法判断数组是否递增
/*int[]arr=new{12,5,7,89,54,32,13}
求func3(arr),实现一个是否递增
* */
//由于数组个元素没有关系

    public static boolean func3(int[]arr) {
        return func3(arr, 0, arr.length - 1);
    }
    //用以缩小范围i++,j--
    public static boolean func3(int []arr,int i,int j){
        //越界结束
        if (i+1>j){
            return true;
        }
        if (arr[i]>arr[i+1]){
            return false;
        }
        return func3(arr, i+1, j);
    }
    public static boolean fun4(int []arr){
            if (arr[0]<arr[1]){
                return true;
            }else {
                return fun4(arr);
            }
    }

（3）链表的递归调用

class Entry{
    int data;
    Entry next;

    public Entry(int data, Entry next) {
        this.data = data;
        this.next = next;
    }
    //@Test
    public void test02(){
        Entry root = new Entry(0, null);
        Entry n1 = new Entry(10, null);
        Entry n2 = new Entry(10, null);
        Entry n3 = new Entry(10, null);
        Entry n4 = new Entry(10, null);
        root.next = n1;
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;

        System.out.println("链表有效节点的数量:" + func4(root));
    }

    /**
     * 返回以root为根节点的单链表有效节点的数量，用递归实现
     * @param root
     * @return
     */
    private int func4(Entry root) {
        if (root==null){
            return 0;
        }else {
            return 1+func4(root.next);
        }
    }
    }

3. 递归常见问题及其解决方案

1.警惕堆栈溢出：可以声明一个全局变量来控制递归的深度，从而避免堆栈溢出。
2.警惕重复计算：通过某种数据结构来保存已经求解过的值，从而避免重复计算。
4.总结
（1）优点：递归是一种非常高效、简洁的编码技巧，一种应用非常广泛的算法，比如DFS深度优先搜索、前中后序二叉树遍历等都是使用递归。
（2）缺点：：空间复杂度高、有堆栈溢出风险、存在重复计算、过多的函数调用会耗时较多等问题。