记得小时候常常讲的一个故事：从前有座山，山上有座庙，庙里有一个老和尚和一个小和尚，一天，老和尚给小和尚讲了一个故事，故事内容是“从前有座山，山上有座庙，庙里有一个老和尚和一个小和尚，一天，老和尚给小和尚讲了一个故事，故事内容......”java
什么是递归，上面的小故事就是一个明显的递归。以编程的角度来看，程序调用自身的编程技巧称为递归（ recursion）。算法
百度百科中的解释是这样的：递归作为一种算法在程序设计语言中普遍应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它一般把一个大型复杂的问题层层转化为一个与原问题类似的规模较小的问题来求解，递归策略只需少许的程序就可描述出解题过程所须要的屡次重复计算，大大地减小了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。编程
一、递归的定义
递归，就是在运行的过程当中调用本身。数组
递归必需要有三个要素：数据结构
①、边界条件数据结构和算法
②、递归前进段函数
③、递归返回段post
当边界条件不知足时，递归前进；当边界条件知足时，递归返回。测试
二、求一个数的阶乘：n!
|
1
|
n! = n*(n-1)*(n-2)*......1
|
规定：
①、0！=1
②、1！=1
③、负数没有阶乘
上面的表达式咱们先用for循环改写：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/**
* 0！=1 1！=1
* 负数没有阶乘,若是输入负数返回-1
* @param n
* @return
*/
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;
}
|
若是求阶乘的表达式是这样的呢？
|
1
|
n! = n*(n-
1
)！
|
咱们用递归来改写：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/**
* 0！=1 1！=1
* 负数没有阶乘,若是输入负数返回-1
* @param n
* @return
*/
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
;
}
|
咱们调用该方法getFactorial(4);即求4！打印以下：
这段递归程序的边界条件就是n==0时，返回1，具体调用过程以下：
三、递归的二分查找
注意：二分查找的数组必定是有序的！！！
在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，若是被查找的值等于array[mid],就返回下标mid; 不然，就将查找范围缩小一半。若是被查找的值小于array[mid], 就继续在左半边查找;若是被查找的值大于array[mid], 就继续在右半边查找。 直到查找到该值或者查找范围为空时， 查找结束。
不用递归的二分查找以下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* 找到目标值返回数组下标，找不到返回-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
;
}
|
二分查找用递归来改写，相信也很简单。边界条件是找到当前值，或者查找范围为空。不然每一次查找都将范围缩小一半。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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个盘子当作是一个盘子，那么解决办法为：
①、先将A塔座的第(N-1)~1个盘子当作是一个盘子，放到中介塔座B上，而后将第N个盘子放到目标塔座C上。
②、而后A塔座为空，当作是中介塔座，B塔座这时候有N-1个盘子，将第(N-2)~1个盘子当作是一个盘子，放到中介塔座A上，而后将B塔座的第(N-1)号盘子放到目标塔座C上。
③、这时候A塔座上有(N-2)个盘子，B塔座为空，又将B塔座视为中介塔座，重复①，②步骤，直到全部盘子都放到目标塔座C上结束。
简单来讲，跟把大象放进冰箱的步骤同样，递归算法为：
①、从初始塔座A上移动包含n-1个盘子到中介塔座B上。
②、将初始塔座A上剩余的一个盘子（最大的一个盘子）放到目标塔座C上。
③、将中介塔座B上n-1个盘子移动到目标塔座C上。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/**
* 汉诺塔问题
* @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为中介塔座
}
}
|
测试：
|
1
|
move(
3
,
"A"
,
"B"
,
"C"
);
|
打印结果为：
五、归并排序
归并算法的中心是归并两个已经有序的数组。归并两个有序数组A和B，就生成了第三个有序数组C。数组C包含数组A和B的全部数据项。
非递归算法为：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
/**
* 传入两个有序数组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()方法将数组的两半归并成为一个有序的数组。如何来为每一部分排序呢？这里咱们利用递归的思想：
把每一半都分为四分之一，对每一个四分之一进行排序，而后把它们归并成一个有序的一半。相似的，如何给每一个四分之一数组排序呢？把每一个四分之一分红八分之一，对每一个八分之一进行排序，以此类推，反复的分割数组，直到获得的子数组是一个数据项，那这就是这个递归算法的边界值，也就是假定一个数据项的元素是有序的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
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];
}
}
|
测试：
|
1
2
3
|
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));
|
结果为：
六、消除递归
一个算法做为一个递归的方法一般通概念上很容易理解，可是递归的使用在方法的调用和返回都会有额外的开销，一般状况下，用递归能实现的，用循环均可以实现，并且循环的效率会更高，因此在实际应用中，把递归的算法转换为非递归的算法是很是有用的。这种转换一般会使用到栈。
递归和栈
递归和栈有这紧密的联系，并且大多数编译器都是用栈来实现递归的，当调用一个方法时，编译器会把这个方法的全部参数和返回地址都压入栈中，而后把控制转移给这个方法。当这个方法返回时，这些值退栈。参数消失了，而且控制权从新回到返回地址处。
调用一个方法时所发生的事：
1、当一个方法被调用时，它的参数和返回地址被压入一个栈中；
2、这个方法能够经过获取栈顶元素的值来访问它的参数；
3、当这个方法要返回时，它查看栈以得到返回地址，而后这个地址以及方法的全部参数退栈，而且销毁。
七、递归的有趣应用
①、求一个数的乘方
通常稍微复杂一点的计算器上面都能求一个数的乘法，一般计算器上面的标志是 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。
|
1
|
x^y= (x^
2
)^(y/
2
)，定义a=x^
2
,b=y/
2
, 则获得形如： x^y= a^b;
|
具体算法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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、继续从第三个数据项开始，如此下去直到你已经试验了全部的组合，这时才知道有没有解决方案。
具体实现过程：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
package
com.ys.recursion;
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个爬山队员，名称为 A,B,C,D和E。想要从这五个队员中选择三个队员去登峰，这时候如何列出全部的队员组合。（不考虑顺序）
仍是以递归的思想来解决：首先这五我的的组合选择三我的分红两个部分，第一部分包含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)，以此类推，很容易想到递归的思想。
具体实现代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
package
com.ys.recursion;
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
);
}
}
|
八、总结
一个递归方法每次都是用不一样的参数值反复调用本身，当某种参数值使得递归的方法返回，而再也不调用自身，这种状况称为边界值，也叫基值。当递归方法返回时，递归过程经过逐渐完成各层方法实例的未执行部分，而从最内层返回到最外层的原始调用处。
阶乘、汉诺塔、归并排序等均可以用递归来实现，可是要注意任何能够用递归完成的算法用栈都能实现。当咱们发现递归的方法效率比较低时，能够考虑用循环或者栈来代替它。