Beauty begins the moment you decide to be yourself.
node
美丽开始于你决定作本身的那一刻。web
啥叫递归算法
tips：文章有点长，能够慢慢看，若是来不及看，也能够先收藏之后有时间在看。json
聊递归以前先看一下什么叫递归。数组
递归，就是在运行的过程当中调用本身。微信
构成递归需具有的条件：数据结构
1. 子问题须与原始问题为一样的事，且更为简单；数据结构和算法
2. 不能无限制地调用自己，须有个出口，化简为非递归情况处理。编辑器
递归语言例子ide
咱们用2个故事来阐述一下什么叫递归。
1，从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？“从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？‘从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……’”
2，大雄在房里，用时光电视看着从前的状况。电视画面中的那个时候，他正在房里，用时光电视，看着从前的状况。电视画面中的电视画面的那个时候，他正在房里，用时光电视，看着从前的状况……
递归模板
咱们知道递归必须具有两个条件，一个是调用本身，一个是有终止条件。这两个条件必须同时具有，且一个都不能少。而且终止条件必须是在递归最开始的地方，也就是下面这样
public void recursion(参数0) { if (终止条件) { return; } recursion(参数1);}
不能把终止条件写在递归结束的位置，下面这种写法是错误的
public void recursion(参数0) { recursion(参数1); if (终止条件) { return; }}
若是这样的话，递归永远退不出来了，就会出现堆栈溢出异常(StackOverflowError)。
但实际上递归可能调用本身不止一次，而且不少递归在调用以前或调用以后都会有一些逻辑上的处理，好比下面这样。
public void recursion(参数0) { if (终止条件) { return; }
可能有一些逻辑运算 recursion(参数1) 可能有一些逻辑运算 recursion(参数2) …… recursion(参数n) 可能有一些逻辑运算}
实例分析
我对递归的理解是先往下一层层传递，当碰到终止条件的时候会反弹，最终会反弹到调用处。下面咱们就以5个最多见的示例来分析下
1，阶乘
咱们先来看一个最简单的递归调用-阶乘，代码以下
1public int recursion(int n) {
2 if (n == 1)
3 return 1;
4 return n * recursion(n - 1);
5}
这个递归在熟悉不过了，第2-3行是终止条件，第4行是调用本身。咱们就用n等于5的时候来画个图看一下递归到底是怎么调用的
若是看不清，图片可点击放大。
这种递归仍是很简单的，咱们求f(5)的时候，只须要求出f(4)便可，若是求f(4)咱们要求出f(3)……，一层一层的调用，当n=1的时候，咱们直接返回1，而后再一层一层的返回，直到返回f(5)为止。
递归的目的是把一个大的问题细分为更小的子问题，咱们只须要知道递归函数的功能便可，不要把递归一层一层的拆开来想，若是同时调用屡次的话这样你极可能会陷入循环而出不来。好比上面的题中要求f(5)，咱们只须要计算f(4)便可，即f(5)=5*f(4)；至于f(4)是怎么计算的，咱们就不要管了。由于咱们知道f(n)中的n能够表明任何正整数，咱们只须要传入4就能够计算f(4)。
2，斐波那契数列
咱们再来看另外一道经典的递归题，就是斐波那契数列，数列的前几项以下所示
[1，1，2，3，5，8，13……]
咱们参照递归的模板来写下，首先终止条件是当n等于1或者2的时候返回1，也就是数列的前两个值是1，代码以下
1public int fibonacci(int n) {
2 if (n == 1 || n == 2)
3 return 1;
4 这里是递归调用；
5}
递归的两个条件，一个是终止条件，咱们找到了。还一个是调用本身，咱们知道斐波那契数列当前的值是前两个值的和，也就是
fibonacci(n) =fibonacci(n - 1) + fibonacci(n - 2)
因此代码很容易就写出来了
1//1,1,2,3,5,8,13……
2public int fibonacci(int n) {
3 if (n == 1 || n == 2)
4 return 1;
5 return fibonacci(n - 1) + fibonacci(n - 2);
6}
3，汉诺塔
经过前面两个示例的分析，咱们对递归有一个大概的了解，下面咱们再来看另外一个示例-汉诺塔，这个其实前面讲过，有兴趣的能够看下362，汉诺塔
汉诺塔的原理这里再简单提一下，就是有3根柱子A，B，C。A柱子上由上至下依次由小至大排列的圆盘。把A柱子上的圆盘借B柱子所有移动到C柱子上，而且移动的过程始终是小的圆盘在上，大的在下。咱们仍是用递归的方式来解这道题，先来定义一个函数
public void hanoi(int n, char A, char B, char C)
他表示的是把n个圆盘从A借助B成功的移动到C。
咱们先来回顾一下递归的条件，一个是终止条件，一个是调用本身。咱们先来看下递归的终止条件就是当n等于1的时候，也就是A柱子上只有一个圆盘的时候，咱们直接把A柱子上的圆盘移动到C柱子上便可。
1//表示的是把n个圆盘借助柱子B成功的从A移动到C
2public static void hanoi(int n, char A, char B, char C) {
3 if (n == 1) {
4 //若是只有一个，直接从A移动到C便可
5 System.out.println("从" + A + "移动到" + C);
6 return;
7 }
8 这里是递归调用
9}
再来看一下递归调用，若是n不等于1，咱们要分3步，
1，先把n-1个圆盘从A借助C成功的移动到B
2，而后再把第n个圆盘从A移动到C
3，最后再把n-1个圆盘从B借助A成功的移动到C。
那代码该怎么写呢，咱们知道函数
hanoi(n, 'A', 'B', 'C')表示的是把n个圆盘从A借助B成功的移动到C
因此hanoi(n-1, 'A', 'C', 'B')就表示的是把n-1个圆盘从A借助C成功的移动到B
hanoi(n-1, 'B', 'A', 'C')就表示的是把n-1个圆盘从B借助A成功的移动到C
因此上面3步若是用代码就能够这样来表示
1，hanoi(n-1, 'A', 'C', 'B')
2，System.out.println("从" + A + "移动到" + C);
3，hanoi(n-1, 'B', 'A', 'C')
因此最终完整代码以下
1//表示的是把n个圆盘借助柱子B成功的从A移动到C
2public static void hanoi(int n, char A, char B, char C) {
3 if (n == 1) {
4 //若是只有一个，直接从A移动到C便可
5 System.out.println("从" + A + "移动到" + C);
6 return;
7 }
8 //表示先把n-1个圆盘成功从A移动到B
9 hanoi(n - 1, A, C, B);
10 //把第n个圆盘从A移动到C
11 System.out.println("从" + A + "移动到" + C);
12 //表示把n-1个圆盘再成功从B移动到C
13 hanoi(n - 1, B, A, C);
14}
经过上面的分析，是否是感受递归很简单。因此咱们写递归的时候彻底能够套用上面的模板，先写出终止条件，而后在写递归的逻辑调用。还有一点很是重要，就是必定要明白递归函数中每一个参数的含义，这样在逻辑处理和函数调用的时候才能驾轻就熟，函数的调用咱们必定不要去一步步拆开去想，这样颇有可能你会奔溃的。
4，二叉树的遍历
再来看最后一个常见的示例就是二叉树的遍历，在前面也讲过，若是有兴趣的话能够看下373，数据结构-6,树，咱们主要来看一下二叉树的前中后3种遍历方式，
1，先看一下前序遍历（根节点最开始），他的顺序是
根节点→左子树→右子树
咱们来套用模板看一下
1public void preOrder(TreeNode node) {
2 if (终止条件)// (必需要有)
3 return;
4 逻辑处理//（不是必须的）
5 递归调用//(必需要有)
6}
终止条件是node等于空，逻辑处理这块直接打印当前节点的值便可，递归调用是先打印左子树在打印右子树，咱们来看下
1public static void preOrder(TreeNode node) {
2 if (node == null)
3 return;
4 System.out.printf(node.val + "");
5 preOrder(node.left);
6 preOrder(node.right);
7}
中序遍历和后续遍历直接看下
2，中序遍历（根节点在中间）
左子树→根节点→右子树
1public static void inOrder(TreeNode node) {
2 if (node == null)
3 return;
4 inOrder(node.left);
5 System.out.println(node.val);
6 inOrder(node.right);
7}
3，后序遍历（根节点在最后）
左子树→右子树→根节点
1public static void postOrder(TreeNode tree) {
2 if (tree == null)
3 return;
4 postOrder(tree.left);
5 postOrder(tree.right);
6 System.out.println(tree.val);
7}
5，链表的逆序打印
这个就不在说了，直接看下
1public void printRevers(ListNode root) {
2 //（终止条件）
3 if (root == null)
4 return;
5 //（递归调用）先打印下一个
6 printRevers(root.next);
7 //（逻辑处理）把后面的都打印完了在打印当前节点
8 System.out.println(root.val);
9}
分支污染问题
经过上面的分析，咱们对递归有了更深一层的认识。但总以为还少了点什么，其实递归咱们还能够经过另外一种方式来认识他，就是n叉树。在递归中若是只调用本身一次，咱们能够把它想象为是一棵一叉树（这是我本身想的，咱们能够认为只有一个子节点的树），若是调用本身2次，咱们能够把它想象为一棵二叉树，若是调用本身n次，咱们能够把它想象为一棵n叉树……。就像下面这样，当到达叶子节点的时候开始往回反弹。
递归的时候若是处理不当可能会出现分支污染致使结果错误。为何会出现这种状况，我先来解释一下，由于除了基本类型是值传递之外，其余类型基本上不少都是引用传递。看一下上面的图，好比我开始调用的时候传入一个list对象，在调用第一个分支以后list中的数据修改了，那么后面的全部分支都能感知到，实际上也就是对后面的分支形成了污染。
咱们先来看一个例子吧
给定一个数组nums=[2，3，5]和一个固定的值target=8。找出数组sums中全部可使数字和为target的组合。先来画个图看一下
图中红色的表示的是选择成功的组合，这里只画了选择2的分支，因为图太大，因此选择3和选择5的分支没画。在仔细一看这不就是一棵3叉树吗，OK，咱们来使用递归的方式，先来看一下函数的定义
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2
3}
在把递归的模板拿出来
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2 if (终止条件) {
3 return;
4 }
5 //逻辑处理
6
7 //由于是3叉树，因此这里要调用3次
8 //递归调用
9 //递归调用
10 //递归调用
11
12 //逻辑处理
13}
这种解法灵活性不是很高，若是nums的长度是3，咱们3次递归调用，若是nums的长度是n，那么咱们就要n次调用……。因此咱们能够直接写成for循环的形式，也就是下面这样
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2 //终止条件必需要有
3 if (终止条件) {
4 return;
5 }
6 //逻辑处理(无关紧要，是状况而定)
7 for (int i = 0; i < sums.length; i++) {
8 //逻辑处理(无关紧要，是状况而定)
9 //递归调用(递归调用必需要有)
10 //逻辑处理(无关紧要，是状况而定)
11 }
12 //逻辑处理(无关紧要，是状况而定)
13}
下面咱们再来一步一步看
1，终止条件是什么？
当target等于0的时候，说明咱们找到了一组组合，咱们就把他打印出来，因此终止条件很容易写，代码以下
1 if (target == 0) {
2 System.out.println(Arrays.toString(cur.toArray()));
3 return;
4 }
2，逻辑处理和递归调用
咱们一个个往下选的时候若是要选的值比target大，咱们就不要选了，若是不比target大，就把他加入到list中，表示咱们选了他，若是选了他以后在递归调用的时候target值就要减去选择的值，代码以下
1 //逻辑处理
2 //若是当前值大于target咱们就不要选了
3 if (target < sums[i])
4 continue;
5 //不然咱们就把他加入到集合中
6 cur.add(sums[i]);
7 //递归调用
8 combinationSum(cur, sums, target - sums[i]);
终止条件和递归调用都已经写出来了，感受代码是否是很简单，咱们再来把它组合起来看下完整代码
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2 //终止条件必需要有
3 if (target == 0) {
4 System.out.println(Arrays.toString(cur.toArray()));
5 return;
6 }
7 for (int i = 0; i < sums.length; i++) {
8 //逻辑处理
9 //若是当前值大于target咱们就不要选了
10 if (target < sums[i])
11 continue;
12 //不然咱们就把他加入到集合中
13 cur.add(sums[i]);
14 //递归调用
15 combinationSum(cur, sums, target - sums[i]);
16 }
咱们还用上面的数据打印测试一下
1public static void main(String[] args) {
2 new Recursion().combinationSum(new ArrayList<>(), new int[]{2, 3, 5}, 8);
3}
运行结果以下
是否是很意外，咱们思路并无出错，结果为何不对呢，其实这就是典型的分支污染，咱们再来看一下图
当咱们选择2的时候是一个分支，当咱们选择3的时候又是另一个分支，这两个分支的数据应该是互不干涉的，但实际上当咱们沿着选择2的分支走下去的时候list中会携带选择2的那个分支的数据，当咱们再选择3的那个分支的时候这些数据还依然存在list中，因此对选择3的那个分支形成了污染。有一种解决方式就是每一个分支都建立一个新的list，也就是下面这样，这样任何一个分支的修改都不会影响到其余分支。
再来看下代码
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2 //终止条件必需要有
3 if (target == 0) {
4 System.out.println(Arrays.toString(cur.toArray()));
5 return;
6 }
7 for (int i = 0; i < sums.length; i++) {
8 //逻辑处理
9 //若是当前值大于target咱们就不要选了
10 if (target < sums[i])
11 continue;
12 //因为List是引用传递，因此这里要从新建立一个
13 List<Integer> list = new ArrayList<>(cur);
14 //把数据加入到集合中
15 list.add(sums[i]);
16 //递归调用
17 combinationSum(list, sums, target - sums[i]);
18 }
19}
咱们看到第13行是从新建立了一个list。再来打印一下看下结果，结果彻底正确，每一组数据的和都是8
上面咱们每个分支都建立了一个新的list，因此任何分支修改都只会对当前分支有影响，不会影响到其余分支，也算是一种解决方式。但每次都从新建立数据，运行效率不好。咱们知道当执行完分支1的时候，list中会携带分支1的数据，当执行分支2的时候，实际上咱们是不须要分支1的数据的，因此有一种方式就是从分支1执行到分支2的时候要把分支1的数据给删除，这就是你们常常提到的回溯算法，咱们来看下
1private void combinationSum(List<Integer> cur, int sums[], int target) {
2 //终止条件必需要有
3 if (target == 0) {
4 System.out.println(Arrays.toString(cur.toArray()));
5 return;
6 }
7 for (int i = 0; i < sums.length; i++) {
8 //逻辑处理
9 //若是当前值大于target咱们就不要选了
10 if (target < sums[i])
11 continue;
12 //把数据sums[i]加入到集合中，而后参与下一轮的递归
13 cur.add(sums[i]);
14 //递归调用
15 combinationSum(cur, sums, target - sums[i]);
16 //sums[i]这个数据你用完了吧，我要把它删了
17 cur.remove(cur.size() - 1);
18 }
19}
咱们再来看一下打印结果，彻底正确
递归分支污染对结果的影响
分支污染通常会对结果形成致命错误，但也不是绝对的，咱们再来看个例子。生成一个2^n长的数组，数组的值从0到(2^n)-1，好比n是3，那么要生成
[0, 0, 0][0, 0, 1][0, 1, 0][0, 1, 1][1, 0, 0][1, 0, 1][1, 1, 0][1, 1, 1]
咱们先来画个图看一下
这不就是个二叉树吗，对于递归前面已经讲的不少了，咱们来直接看代码
1private void binary(int[] array, int index) {
2 if (index == array.length) {
3 System.out.println(Arrays.toString(array));
4 } else {
5 int temp = array[index];
6 array[index] = 0;
7 binary(array, index + 1);
8 array[index] = 1;
9 binary(array, index + 1);
10 array[index] = temp;
11 }
12}
上面代码很好理解，首先是终止条件，而后是递归调用，在调用以前会把array[index]的值保存下来，最后再还原。咱们来测试一下
new Recursion().binary(new int[]{0, 0, 0}, 0);
看下打印结果
结果彻底正确，咱们再来改一下代码
1private void binary(int[] array, int index) {
2 if (index == array.length) {
3 System.out.println(Arrays.toString(array));
4 } else {
5 array[index] = 0;
6 binary(array, index + 1);
7 array[index] = 1;
8 binary(array, index + 1);
9 }
10}
再来看一下打印结果
和上面结果如出一辙，开始的时候咱们没有把array[index]的值保存下来，最后也没有对他进行复原，但结果丝绝不差。缘由就在上面代码第5行array[index]=0，这是由于，上一分支执行的时候即便对array[index]形成了污染，在下一分支又会对他进行从新修改。即便你把它改成任何数字也都不会影响到最终结果，好比咱们在上一分支执行完了时候咱们把它改成100，你在试试
1private void binary(int[] array, int index) {
2 if (index == array.length) {
3 System.out.println(Arrays.toString(array));
4 } else {
5 array[index] = 0;
6 binary(array, index + 1);
7 array[index] = 1;
8 binary(array, index + 1);
9 //注意，这里改为100了
10 array[index] = 100;
11 }
12}
咱们看到第10行，把array[index]改成100了，最终打印结果也是不会变的，因此这种分支污染并不会形成最终的结果错误。
总结
对递归的理解，看完这篇文章应该没有什么疑问了，记住上面模板，其实代码很好写的，后面也会再写一些关于递归的算法题的，让你完全搞懂递归。
长按上图，识别图中二维码以后便可关注。
若是以为有用就点个"赞"和“在看”吧
本文分享自微信公众号 - 数据结构和算法（sjjghsf）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。