递归

递归(recursion)做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归的定义
递归就是在运行的过程中调用自身。
递归必须要有三个要素：
①、边界条件
②、递归前进段
③、递归返回段
当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

n!阶乘运算
规定：
①、0！=1
②、1！=1
③、负数没有阶乘

// for循环实现
public static int getFactorialFor(int n) {
     int temp = 1;
     if (n >= 0) {
         for (int i = 1; i <= n; i++) {
             temp = temp * i;
         }
     } else {
         return -1;
     }
     return temp;
}

// 递归实现
public static int getFactorial(int n) {
     if (n >= 0) {
         if (n == 0) {
             System.out.println(n + "!=1");
             return 1;
         } else {
             System.out.println(n);
             int temp = n * getFactorial(n - 1);
             System.out.println(n + "!=" + temp);
             return temp;
        }
      }
     return -1;
 }

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

// 普通二分查找
/**
  * 找到目标值返回数组下标，找不到返回-1
  *
  * @param array
  * @param key
  * @return
  */
public static int findTwoPoint(int[] array, int key) {
    int start = 0;
    int last = array.length - 1;
    while (start <= last) {
        int mid = (last - start) / 2 + start; // 防止直接相加造成int范围溢出
        if (key == array[mid]) { // 查找值等于当前值，返回数组下标
            return mid;
        }
        if (key > array[mid]) { // 查找值比当前值大
            start = mid + 1; 
        }
        if (key < array[mid]) { // 查找值比当前值小
            last = 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) { // 找不到查找值，返回-1
         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;
}

递归、非递归二分查找比较
①查找效率都为O(logN)。
②递归速度比非递归慢。
③递归比非递归更加简洁，便于理解。

分治算法
把一个大问题分成两个相对来说更小的问题，并且分别解决每一个小问题，对每一个小问题的解决方法是一样的：把每个小问题分成两个更小的问题，并且解决它们，这个过程一直持续下去直到达到易于求解的基值情况，就不用再继续分了。分治算法通常要回到递归。

递归的二分查找法就是一个分治算法的典型例子，分治算法常常是一个方法，在这个方法中含有两个对自身的递归调用，分别对应于问题的两个部分。二分查找中，将查找范围分成比查找值大的一部分和比查找值小的一部分，每次递归调用只会有一个部分执行。后面的归并排序真正执行了两个递归调用（对分成两半的数组分别进行排序）。

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

试想一下，如果只有两个盘子，盘子从小到大我们以数字命名（也可以想象为直径），两个盘子上面就是盘子1，下面是盘子2，那么我们只需要将盘子1先移动到B塔座上，然后将盘子2移动到C塔座，最后将盘子1移动到C塔座上。即完成2个盘子从A到C的移动。

如果有三个盘子，那么我们将盘子1放到C塔座，盘子2放到B塔座，在将C塔座的盘子1放到B塔座上，然后将A塔座的盘子3放到C塔座上，然后将B塔座的盘子1放到A塔座，将B塔座的盘子2放到C塔座，最后将A塔座的盘子1放到C塔座上。

如果有四个，五个，N个盘子，那么我们应该怎么去做？这时候递归的思想就很好解决这样的问题了，当只有两个盘子的时候，我们只需要将B塔座作为中介，将盘子1先放到中介塔座B上，然后将盘子2放到目标塔座C上，最后将中介塔座B上的盘子放到目标塔座C上即可。

所以无论有多少个盘子，我们都将其看做只有两个盘子。假设有 N 个盘子在塔座A上，我们将其看为两个盘子，其中(N-1)~1个盘子看成是一个盘子，最下面第N个盘子看成是一个盘子，那么解决办法为：

1. 先将A塔座的第(N-1)~1个盘子看成是一个盘子，放到中介塔座B上，然后将第N个盘子放到目标塔座C上。
2. 然后A塔座为空，看成是中介塔座，B塔座这时候有N-1个盘子，将第(N-2)~1个盘子看成是一个盘子，放到中介塔座A上，然后将B塔座的第(N-1)号盘子放到目标塔座C上。
3. 这时候A塔座上有(N-2)个盘子，B塔座为空，又将B塔座视为中介塔座，重复①，②步骤，直到所有盘子都放到目标塔座C上结束。

简单来说，跟把大象放进冰箱的步骤一样，递归算法为：
①、从初始塔座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);//A为初始塔座，B为目标塔座，C为中介塔座
        System.out.println("将盘子" + dish + "从塔座" + from + "移动到目标塔座" + to);
        move(dish - 1, temp, from, to);//B为初始塔座，C为目标塔座，A为中介塔座
    }
}

运行move(3,"A","B","C")结果如下：
// 将盘子1从塔座A移动到目标塔座C
// 将盘子2从塔座A移动到目标塔座B
// 将盘子1从塔座C移动到目标塔座B
// 将盘子3从塔座A移动到目标塔座C
// 将盘子1从塔座B移动到目标塔座A
// 将盘子2从塔座B移动到目标塔座C
// 将盘子1从塔座A移动到目标塔座C

归并排序
归并算法的中心是归并两个已经有序的数组。归并两个有序数组A和B，就生成了第三个有序数组C。数组C包含数组A和B的所有数据项。

普通实现

    /**
     * 传入两个有序数组a和b，返回一个排好序的合并数组
     *
     * @param a
     * @param b
     * @return
     */
    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]) { // 比较a数组和b数组的元素，谁更小将谁赋值到c数组
                c[cNum++] = b[bNum++];
            } else {
                c[cNum++] = a[aNum++];
            }
        }
        // 如果a数组全部赋值到c数组了，但是b数组还有元素，则将b数组剩余元素按顺序全部复制到c数组
        while (aNum == a.length && bNum < b.length) {
            c[cNum++] = b[bNum++];
        }
        // 如果b数组全部赋值到c数组了，但是a数组还有元素，则将a数组剩余元素按顺序全部复制到c数组
        while (bNum == b.length && aNum < a.length) {
            c[cNum++] = a[aNum++];
        }
        return c;
    }

该方法有三个while循环，第一个while比较数组a和数组b的元素，并将较小的赋值到数组c；第二个while循环当a数组所有元素都已经赋值到c数组之后，而b数组还有元素，那么直接把b数组剩余的元素赋值到c数组；第三个while循环则是b数组所有元素都已经赋值到c数组了，而a数组还有剩余元素，那么直接把a数组剩余的元素全部赋值到c数组。

 归并排序的思想是把一个数组分成两半，排序每一半，然后用上面的sort()方法将数组的两半归并成为一个有序的数组。如何来为每一部分排序呢？这里我们利用递归的思想：把每一半都分为四分之一，对每个四分之一进行排序，然后把它们归并成一个有序的一半。类似的，如何给每个四分之一数组排序呢？把每个四分之一分成八分之一，对每个八分之一进行排序，以此类推，反复的分割数组，直到得到的子数组是一个数据项，那这就是这个递归算法的边界值，也就是假定一个数据项的元素是有序的。

递归实现

public static int[] mergeSort(int[] c, int start, int last) {
        if (last > start) {
            // 也可以是(start+last)/2，这样写是为了防止数组长度很大造成两者相加超过int范围，导致溢出
            int mid = start + (last - start) / 2;
            mergeSort(c, start, mid); // 左边数组排序
            mergeSort(c, mid + 1, last); // 右边数组排序
            merge(c, start, mid, last); // 合并左右数组
        }
        return c;
    }

    public static void merge(int[] c, int start, int mid, int last) {
        int[] temp = new int[last - start + 1];//定义临时数组
        int i = start; // 定义左边数组的下标
        int j = mid + 1; // 定义右边数组的下标
        int k = 0;
        while (i <= mid && j <= last) {
            if (c[i] < c[j]) {
                temp[k++] = c[i++];
            } else {
                temp[k++] = c[j++];
            }
        }
        // 把左边剩余数组元素移入新数组中
        while (i <= mid) {
            temp[k++] = c[i++];
        }
        // 把右边剩余数组元素移入到新数组中
        while (j <= last) {
            temp[k++] = c[j++];
        }

        // 把新数组中的数覆盖到c数组中
        for (int k2 = 0; k2 < temp.length; k2++) {
            c[k2 + start] = temp[k2];
        }
    }

// 运行如下：
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));

// 返回结果：[0,1,2,3,4,5,6,7,8,9]

消除递归
一个算法作为一个递归的方法通常通概念上很容易理解，但是递归的使用在方法的调用和返回都会有额外的开销，通常情况下，用递归能实现的，用循环都可以实现，而且循环的效率会更高，所以在实际应用中，把递归的算法转换为非递归的算法是非常有用的。这种转换通常会使用到栈。

递归和栈有这紧密的联系，而且大多数编译器都是用栈来实现递归的，当调用一个方法时，编译器会把这个方法的所有参数和返回地址都压入栈中，然后把控制转移给这个方法。当这个方法返回时，这些值退栈。参数消失了，并且控制权重新回到返回地址处。

调用一个方法时所发生的事：
一、当一个方法被调用时，它的参数和返回地址被压入一个栈中；
二、这个方法可以通过获取栈顶元素的值来访问它的参数；
三、当这个方法要返回时，它查看栈以获得返回地址，然后这个地址以及方法的所有参数退栈，并且销毁。

递归的有趣应用
①求一个数的乘方
一般稍微复杂一点的计算器上面都能求一个数的乘法，通常计算器上面的标志是 x^y 这样的按键，表示求 x 的 y 次方。一般情况下我们是如何求一个数的乘法的呢？
比如2^8,我们可以会求表达式2*2*2*2*2*2*2*2 的值，但是如果y的值很大，这个会显得表达式很冗长。那么由没有更快一点方法呢？
数学公式如下是成立的：
(Xa)b = Xa*b
如果求28次方，我们可以先假定22=a,于是28 = (22)4 ，那么就是a4 ；假定 a2 = b，那么 a4 = b2，而b2可以写成(b2)1。于是现在28就转换成：b*b
也就是说我们将乘方的运算转换为乘法的运算。
求xy的值，当y是偶数的时候，最后能转换成两个数相乘，当时当y是奇数的时候，最后我们必须要在返回值后面额外的乘以一个x。

x^y= (x^2)^(y/2)，定义a=x^2,b=y/2, 则得到形如： x^y= a^b;

 

public static int pow(int x, int y) {
        if (x == 0 || x == 1) {
            return x;
        }
        if (y > 1) {
            int b = y / 2;
            int a = x * x;
            if (y % 2 == 1) {//y为奇数
                return pow(a, b) * x;
            } else {//y为偶数
                return pow(a, b);
            }
        } else if (y == 0) {
            return 1;
        } else {//y==1
            return x;
        }
}

②背包问题
背包问题也是计算机中的经典问题。在最简单的形式中，包括试图将不同重量的数据项放到背包中，以使得背包最后达到指定的总重量。
比如：假设想要让背包精确地承重20磅，并且有 5 个可以放入的数据项，它们的重量分别是 11 磅，8 磅，7 磅，6 磅，5 磅。这个问题可能对于人类来说很简单，我们大概就可以计算出 8 磅+ 7 磅 + 5 磅 = 20 磅。但是如果让计算机来解决这个问题，就需要给计算机设定详细的指令了。
算法如下：

1. 如果在这个过程的任何时刻，选择的数据项的总和符合目标重量，那么工作便完成了。
2. 从选择的第一个数据项开始，剩余的数据项的加和必须符合背包的目标重量减去第一个数据项的重量，这是一个新的目标重量。
3. 逐个的试每种剩余数据项组合的可能性，但是注意不要去试所有的组合，因为只要数据项的和大于目标重量的时候，就停止添加数据。
4. 如果没有合适的组合，放弃第一个数据项，并且从第二个数据项开始再重复一遍整个过程。
5. 继续从第三个数据项开始，如此下去直到你已经试验了所有的组合，这时才知道有没有解决方案。

 

public class Knapsack {
    private int[] weights; //可供选择的重量
    private boolean[] selects; //记录是否被选择
     
    public Knapsack(int[] weights){
        this.weights = weights;
        selects = new boolean[weights.length];
    }
     
    /**
     * 找出符合承重重量的组合
     * @param total 总重量
     * @param index 可供选择的重量下标
     */
    public void knapsack(int total,int index){
        if(total < 0 || total > 0 && index >= weights.length){
            return;//没找到解决办法，直接返回
        }
        if(total == 0){//总重量为0，则找到解决办法了
            for(int i = 0 ; i < index ; i++){
                if(selects[i] == true){
                    System.out.println(weights[i]+" ");
                }
            }
            System.out.println();
            return;
        }
        selects[index] = true;
        knapsack(total-weights[index], index+1);
        selects[index] = false;
        knapsack(total, index+1);
    }
     
    public static void main(String[] args) {
        int array[] = {11,9,7,6,5};
        int total = 20;
        Knapsack k = new Knapsack(array);
        k.knapsack(total, 0);
    }
}

③【组合】选择一支队伍
在数学中，组合是对事物的一种选择，而不考虑他们的顺序。
比如有5个登山队员，名称为ABCDE。想要从这五个队员中选择三个队员去登峰，这时候如何列出所有的队员组合。（不考虑顺序）还是以递归的思想来解决：首先这五个人的组合选择三个人分成两个部分，第一部分包含A队员，第二部分不包含A队员。假设把从5个人中选出3个人的组合简写为（5,3），规定n是这群人的大小，并且k是组队的大小。那么根据法则可以有：(n,k) = (n-1,k-1) + (n-1,k)

对于从 5 个人中选择 3 个人，有：(5,3) = (4,2)+(4,3)

(4,2)表示已经有A队员了，然后从剩下的4个队员中选择2个队员，(4,3)表示从5个人中剔除A队员，从剩下的4个队员中选择3个队员，这两种情况相加就是从5个队员中选择3个队员。

现在已经把一个大问题转换为两个小问题了。从4个人的人群中做两次选择（一次选择2个，一次选择3个），而不是从5个人的人群中选择3个。

从4个人的人群中选择2个人，又可以表示为：(4,2) = (3,1) + (3,2)，以此类推，很容易想到递归的思想。

 

public class Combination {
    private char[] persons;//组中所有可供选择的人员
    private boolean[] selects;//标记成员是否被选中，选中为true
     
    public Combination(char[] persons){
        this.persons = persons;
        selects = new boolean[persons.length];
    }
    public void showTeams(int teamNumber){
        combination(teamNumber,0);
    }
    /**
     *
     * @param teamNumber 需要选择的队员数
     * @param index 从第几个队员开始选择
     */
    public void combination(int teamNumber,int index){
        if(teamNumber == 0){//当teamNumber=0时，找到一组
            for(int i = 0 ; i < selects.length ; i++){
                if(selects[i] == true){
                    System.out.print(persons[i]+" ");
                }
            }
            System.out.println();
            return;
        }
        //index超过组中人员总数，表示未找到
        if(index >= persons.length ){
            return;
        }
        selects[index] = true;
        combination(teamNumber-1, index+1);
        selects[index] = false;
        combination(teamNumber, index+1);
    }
 
    public static void main(String[] args) {
        char[] persons = {'A','B','C','D','E'};
        Combination cb = new Combination(persons);
        cb.showTeams(3);
    }
}

总结
一个递归方法每次都是用不同的参数值反复调用自己，当某种参数值使得递归的方法返回，而不再调用自身，这种情况称为边界值，也叫基值。当递归方法返回时，递归过程通过逐渐完成各层方法实例的未执行部分，从最内层返回到最外层的原始调用处。

阶乘、汉诺塔、归并排序等都可以用递归来实现，但是要注意任何可以用递归完成的算法用栈都能实现。当我们发现递归的方法效率比较低时，可以考虑用循环或者栈来代替它。

原文：https://www.cnblogs.com/ysocean/p/8005694.html