函数的递归调用和重载

函数重载

a.函数的重载指的就是同一个类中出现的同名函数.

b.与权限没关系，与返回值类型没关系，与参数名没关系
只有和参数类型的排列组合有关系(注意一下参数类型的向下兼容问题)

c.重载的好处就在于我们可以扩展函数的功能(函数重名，但是参数类型不一样，执行内容也可以不一样)

递归需要注意的问题

寻找适当函数的流程
1.看是否有确切的参数定义 int+int 查看是否有(int,int)
2.看是否有可兼容的参数定义 int+int 查看是否有(double,double)
3.如果可兼容的参数定义有多个int+int,(double,int)或(int,double) 此时报错 引用不明确

函数的递归调用

递归的体现就是函数自身调用函数自身

函数递归主要解决的问题：

1. 一般而言，但凡能够被迭代（循环）解决的问题，递归都可以解决。
2. 递归解决的问题，迭代就不一定了。
3. 递归其实是分治法的一种实现方式（一种实现思路）。
4. 递归就是函数在进栈，进栈的次数多了，势必会占内存，无法避免的。在某些问题上，递归所写的代码要比迭代写的代码少，在某些问题上，迭代是写不出来的，所以只能用递归。
5. 分治法是一种算法思想，分治法主要解决的问题是将大问题，进行拆分，拆分成若干个小的问题进行求解，最终将每个小问题的解进行合并。其实，分治法就是一种暴力破解法（穷举），也是一种搜索最优答案的算法。

 

 

函数递归就是函数自己调用自己的体现，我们称之为递归函数。它的有点就是用有限的函数来定义实现对象无限集合，缺点就是由于自己调用自己，重复操作所以内存消耗严重。非必要的时候我们建议不要使用递归。递归的原理：通常把一个大型的复杂的问题层层转换成与原来问题相似的规模比较校的问题来解析。这样可以减少代码量。

递归一般思路是先捋顺往下递的思路，然后再归。这种思路对于解决问题来说是非常重要的。

递归经典题目例子

问题1：斐波那契数列 求前20项  : 1 1 2 3 5 8 13 21 34 55 ......

        f(n)指的是斐波那契的第n项

        f(n)=f(n-1)+f(n-2) f(1)=1 f(2)=1

                  f(5)

            f(4)        f(3)

        f(3)    f(2) f(2)   f(1)

    f(2)    f(1)

 

class Test1{
    public static void main(String[] args){
        for(int i=1;i<=100;i++){
            System.out.println(fibo(i));
        }
        System.out.println("==============");
        fiboIterator(20);//用迭代的思想求前20项
    }
    public static void fiboIterator(int n){
        int a=1;
        int b=1;
        System.out.println(a);
        System.out.println(b);
        int count=2;
        int c;
        while(true){
            c=a+b;
            System.out.println(c);
            count++;
            if(count==n){
                return;
            }
            a=b;
            b=c;
        }
    }
    public static int fibo(int n){
        if(n==1||n==2){
            return 1;
        }
        return fibo(n-1)+fibo(n-2);
    }
    
    
}

 问题2：汉诺塔

汉诺塔是迭代最经典的问题之一，它是由3根柱子，第一个柱子上有64个从小到大的圆环，要求从第一个柱子上将圆环移到带三个柱子上，要求，小环不能在大环之上，我们所要求的圆环移动的路程。

 

class Hanno{
    public static void main(String[] args){
        //盘子的个数 出发 中间 目的
        hanno(64,"X","Y","Z");
    }                                     
    public static void hanno(int n,String begin,String mid,String end){
        if(n==1){
            System.out.println(begin+" -> "+end);
        }else{
            hanno(n-1,begin,end,mid);
            System.out.println(begin+" -> "+end);
            hanno(n-1,mid,begin,end);
        }
    }
}

 设最初在塔座A上的圆盘数为n，则当n=1时，只需直接将这个圆盘移到塔座C上就可以了；否则执行以下操作：
（1）用C做过度，将A柱上的（n-1）个盘子移到B上；
（2）将A柱上最后一个盘子直接移到C柱子上；
（3）用A做过度，将B上的（n-1）个盘子移到C柱子上；

递归思路能很好的解决这个题目假设有3个盘子的话步骤按照上面的图示即可，有64个盘子的话情况也一样。我们只需把核心步骤编写成为递归体剩下的基本就是重复这些步骤，然后调用相同函数就能解决这些问题。