10. 递归算法代码（阶乘、二分查找、汉诺塔、归并排序）

版权声明：作者：changshuchao https://blog.csdn.net/changshuchao/article/details/88406727

/*递归算法的测试*/
public class TestRecursion {

    /* 1   阶乘*/
    private static int testFactorial(int i){
        if(i == 0){
            return 1;
        }else{
            return i*testFactorial(i-1);
        }
    }


    /* 2    递归的二分查找
    *
    * 注意：二分查找的数组一定是有序的！！！

　　在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，如果被查找的值等于array[mid],就返回下标mid;
    否则，就将查找范围缩小一半。
    如果被查找的值小于array[mid], 就继续在左半边查找;如果被查找的值大于array[mid],  就继续在右半边查找。 直到查找到该值或者查找范围为空时， 查找结束。
    * */
    private static int find(int[] arr , int valueToSearch , int start , int end){
        System.out.println(start + " | "+end);
        /*中间值的下标*/
        int midIndex = (end-start)/2+start;
        if(start > end){
            return -1;
        }else if(arr[midIndex] == valueToSearch){ //结束条件
            return midIndex;
        }else if(arr[midIndex] > valueToSearch){
            return find(arr,valueToSearch,start,midIndex);
        }else {
            return find(arr,valueToSearch,midIndex+1,end);
        }

    }


    /* 3   汉诺塔问题*/
    public static void move(int dish,String from,String temp,String to){
        if(dish == 1){
            System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);
        }else{
            move(dish-1,from,to,temp);//A为初始塔座，B为目标塔座，C为中介塔座
            System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);
            move(dish-1,temp,from,to);//B为初始塔座，C为目标塔座，A为中介塔座
        }
    }

    public static void main(String[] args) {
//        System.out.println(testFactorial(3));
//
//        /*start 开始下标，end 结束下标*/
//        int[] arrayToSearch = new int[]{0,1,2,3,4,5,6,7,8,9};
//        System.out.println(find(arrayToSearch,10,0,arrayToSearch.length-1));
//
//        move(3,"A","B","C");

        UnionSort(new int[]{1,2,3,4,5},new int[]{2,4,6,8,10,11,12,13});
    }

    /* 4    归并排序
    * arrayA arrayB  是从小到大的两个数组
    * */

    public static void UnionSort(int[] arrayA , int[] arrayB){
        if(arrayA !=null && arrayB !=null){
            int[] arrayC = new int[arrayA.length+arrayB.length];
            int indexA = 0;
            int indexB = 0;
            int indexC = 0;
            while(indexA != arrayA.length && indexB != arrayB.length){
                int currentA = arrayA[indexA];
                int currentB = arrayB[indexB];
                if(currentA < currentB){
                    arrayC[indexC] = currentA;
                    indexC++;
                    indexA++;
                }else if(currentA == currentB){
                    arrayC[indexC] = currentA;
                    arrayC[indexC+1] = currentA;
                    indexC+=2;
                    indexA++;
                    indexB++;
                }else{
                    arrayC[indexC] = currentB;
                    indexC++;
                    indexB++;
                }
            }

            if(indexA == arrayA.length){
                for (int i = indexB; i < arrayB.length; i++) {
                    arrayC[indexC+i-indexB] = arrayB[i];
                }
            }
            if(indexB == arrayB.length){
                for (int i = indexA; i < arrayA.length; i++) {
                    arrayC[indexC+i-indexA] = arrayA[i];
                }
            }

            for (int i : arrayC){
                System.out.print(i+" ");
            }
        }

    }
}