递归——在运行的过程中调用自己

递归，就是在运行的过程中调用自己

递归必须要有三个要素：
①、边界条件
②、递归前进段
③、递归返回段
当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

递归关键：写出递推公式，找到终止条件

1.求解阶乘

n! = n*(n‐1)(n‐2)…1

/**
 * 0！=1  1！=1
 * 负数没有阶乘,如果输入负数返回‐1
 * @param n
 * @return
 */
public static int Factorial(int n){
    int temp = 1;
    if(n >=0){
        for(int i = 1 ; i <= n ; i++){
            temp = temp*i;
        }
    }else{
        return ‐1;
    }
    return temp;
}

n! = n*(n‐1)！

/**
 * 0！=1  1！=1
 * 负数没有阶乘,如果输入负数返回‐1 
 * @param n
 * @return
 */
public static int Factorial(int n){
    if(n >= 0){
        if(n==0){
            System.out.println(n+"!=1");
            return 1;
        }else{
            System.out.println(n);
            int temp = n*Factorial(n‐1);
            System.out.println(n+"!="+temp);            
			return temp;
        }
    }
    return ‐1;
}

2.二分查找

注：二分查找的数组一定是有序的！！！

在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，如果被查找的值等于array[mid],就返回下标mid;否则，就将查找范围缩小一半。如果被查找的值小于array[mid],就继续在左半边查找;如果被查找的值大于array[mid],就继续在右半边查找。直到查找到该值或者查找范围为空时，查找结束。

/**
	 * 二分查找有序数组-----循环
	 * @param arr 要查找的数组
	 * @param key 目标值
	 * @return
	 */
	public int findTwoPoint(int[] arr,int key) {
		int start = 0;
		int last = arr.length-1;
		while(last>=start) {
			int mid = (last-start)/2+start;
			if(arr[mid]==key) {
				return mid;
			}else if(arr[mid]>key) {
				last = mid-1;
			}else if(arr[mid]<key){
				start = mid+1;
			}
		}
		return -1;
	}

/**
	 * 二分查找有序数组-----递归
	 * @param arr 要查找的数组
	 * @param key 目标值
	 * @param start 数组起始位
	 * @param last 数组结束位
	 * @return
	 */
	public int search(int[] arr,int key,int start,int last) {
		int mid = (last-start)/2+start;
		 if(arr[mid]==key) {//查找值等于当前值，返回当前坐标
			 return mid;
		 }else if (start>last) {//没有找到
			 return -1;
		 } else {
			 if(key>arr[mid]) {//查找值大于当前
				 return search(arr,key,mid+1,last);
			 }else if(key<arr[mid]) {//查找值小于当前值
				 return search(arr,key,start,mid-1);
			 }
		 }
		 
		 return -1;
	}

3.汉诺塔问题

汉诺塔问题是由很多放置在三个塔座上的盘子组成的一个古老的难题。所有盘子的直径是不同的，并且盘子中央都有一个洞使得它们刚好可以放在塔座上。所有的盘子刚开始都放置在A塔座上。这个难题的目标是将所有的盘子都从塔座A移动到塔座C上，每次只可以移动一个盘子，并且任何一个盘子都不可以放置在比自己小的盘子之上。

所以无论有多少个盘子，我们都将其看做只有两个盘子。假设有N个盘子在塔座A上，我们将其看为两个盘子，其中(N-1)~1个盘子看成是一个盘子，最下面第N个盘子看成是一个盘子，那么解决办法为：
①、从初始塔座A上移动包含n-1个盘子到中介塔座B上。
②、将初始塔座A上剩余的一个盘子（最大的一个盘子）放到目标塔座C上。
③、将中介塔座B上n-1个盘子移动到目标塔座C上。

/**
	 * 汉诺塔问题
	 * @param dish 盘子个数
	 * @param from 初始塔座
	 * @param temp 中间塔座
	 * @param to 目标塔座
	 */
	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);
			System.out.println("将盘子"+dish+"从"+from+"移动到"+to);
			move(dish-1,temp,from,to);
		}
	}