递归

递归的三个必要的因素：

1、 边界条件

2、递归前进段

3、递归返回段

当边界条件不满足时，递归前进；当边界条件满足时，递归返回

一、递归法实现斐波那契数列

public class Factorial {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }
    public static int getfactorialFor(int n) {
        if(n>=0) {
            if(n==0) {
                System.out.println(n+"!=1");
                return 1;
            }else {
                System.out.println(n);
                int temp = n*getfactorialFor(n-1);
                System.out.println(n+"!="+temp);
                return temp;
            }
        }
        return -1;
    }
}

二、递归法的二分查找

二分查找的数组一定是有序的数组。在数组Array[]中，不断将中间值mid和被查找的值作比较

若被查找的值等于array[mid]则返回array[mid]的值，若被查找的值小于array[mid],继续在左半边

查找，否则在右半边查找

public class findTwoPoint {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] a = {2,3,6,7,9,23,33,67,78};
        //int n = findTwoPoint(a,67);
        int n = search(a,67,0,a.length-1);
        System.out.println(n);
    }
    
    //二分查找，不用递归方法
    public static int findTwoPoint(int [] array,int key) {
        int start =0;
        int end = array.length-1;
        while(start<=end) {
            int mid = (end-start)/2+start;
            if(key==array[mid]) {
                return mid;
            }
            if(key>array[mid]) {//查找的值比当前值大
                start = mid+1;
            }
            if(key<array[mid]) {
                end = mid-1;
            }
        }
        return -1;
    }
    //递归方法
    public static int search(int [] array,int key,int low,int high) {
        int mid = (high-low)/2+low;
        if(key==array[mid]) {
            return mid;
        }
        else if(low>high) {
            return -1;
        }else {
            if(key<array[mid]) {
                return search(array,key,low,mid-1);
            }
            if(key>array[mid]) {
                return search(array,key,mid+1,high);
            }
        }
        return -1;
    }
}
3、归并排序

public class MergeSort {
    //归并排序
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] c= {2,7,8,3,1,6,9,0,5,4};
        c = mergeSort(c,0,c.length-1);
        System.out.println(Arrays.toString(c));
    }
    //非递归法排序
    public static int[] sort(int [] a,int [] b) {
        int [] c = new int[a.length+b.length];
        int aNum =0 ,bNum = 0,cNum =0;
        while(aNum<a.length&&bNum<b.length) {
            if(a[aNum]>=b[bNum]) {
                c[cNum++] = b[bNum++];
            }else {
                c[cNum++] = a[aNum++];
            }
        }
        while(aNum == a.length&& bNum<b.length) {
            c[cNum++] = b[bNum++];
        }
        while(bNum == b.length&& aNum<a.length) {
            c[cNum++] = a[aNum++];
        }
        return c;
    }
    public static int [] mergeSort(int [] c,int start,int end) {
        if(end>start) {
            int mid = start+(end-start)/2;
            mergeSort(c,start,mid);
            mergeSort(c,mid+1,end);
            merge(c,start,mid,end);
        }
        return c;
    }
    public static void merge(int [] c,int start,int mid,int end) {
        int []temp = new int[end-start+1];
        int i = start;
        int j = mid+1;
        int k=0;
        while(i<=mid&&j<=end) {
            if(c[i]<c[j]) {
                temp[k++] = c[i++];
            }else {
                temp[k++] = c[j++];
            }
        }
        while(i<=mid) {
            temp[k++] = c[i++];
        }
        while(j<=end) {
            temp[k++] = c[j++];
        }
        for(int k2=0;k2<temp.length;k2++) {
            c[k2+start] = temp[k2];
        }
    }

}