递归算法简单应用

递归：

程序调用自身的编程技巧称为递归。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

    @Test
    public void test03(){
        int []arr=new int []{5,7,12,13,24,54,68};
        int a=binarySearch(arr,0,arr.length-1,54);
        System.out.println(a);
    }

    /**
     * 递归实现二分查找
     * binarySearch在arr数组中从i到j的范围中，用二分查找搜索val
     * @param arr
     * @param i
     * @param j
     * @param val
     * @return
     */
    private int binarySearch(int[]arr,int i,int j,int val) {
        if (i > j) {
            return -1;
        }
            int mid = (i + j) / 2;
            if (val < arr[mid]) {
                return binarySearch(arr, i, mid - 1, val);
            } else if (val > arr[mid]) {
                return binarySearch(arr, mid + 1, j, val);
            } else {
                return mid;
            }
        }

    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);
        }
    }
    @Test
    public void test01(){
        /**
         * 实现一个递归函数func3,判断arr数组是否是一个递增序列的数组 true false
         */
        int [] arr=new int []{12,5,7,89,32,13};
       boolean a= func3(arr);
       System.out.println(a);

    }
    private boolean func3(int arr[]){
        return func3(arr,0,arr.length);
    }
        private 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);
    }

    /**
     * 递归求斐波那契数字
     * @param n
     * @return
     */
    private int func2(int n){
        if(n==0||n==1){
            return 1;
        }else {
            return  func2(n-1)+func2(n-2);
        }
    }
}