前情提要
上一篇递归算法讲解在这里
递归算法讲解(结合内存图)
没看过的小伙伴可以进去瞅一眼,谢谢!
递归算法的重要性
递归算法是非常重要的,如果想要进大厂,以递归算法为基础的动态规划是必考的,所以我们一定要好好学习递归算法!
本篇博客继续讲解一些递归的经典demo
demo01
递归实现求int类型的数组arr中前n项和,其中arr.length>=n,并且arr当中的元素总和在[-2147483648, 2147483647]之间
还记得递归三步走吗,我们来回顾一下
1. 明确递归的参数和返回值
很显然递归的参数有两个:数组arr + 要求和的序列长度n;
递归的返回值是我们求得的和,不会超过int类型的取值范围,所以数组求和很明显还是int
2. 明确递归的终止条件
我们已知的部分当中,n最小的情况就是递归的终止条件
我们目前已知的,sum(1)肯定是知道的,等于arr[0];sum(2)也是知道的,等于arr[0]+arr[1];
1比较小,所以n==1就是递归的终止条件
递归就是循环,递归的终止条件就是循环的中止条件
还有一些诸如i==j,i>j,都可能称为递归中止条件
3. 明确递归的单层递归逻辑
递归的单层递归逻辑是最难想到的
其实明确单层递归逻辑,很像是中学数学中,让我们求数列的通项公式,我们需要找规律
假设arr = {3,4,7,1,8,12,47......}
sum(1) = 3,sum(2) = 7,sum(3) = 14,sum(4) = 15......
那么sum(n) = ?
差不多是这样的一个过程
当然,本题目是比较简单的,一眼就能看出来,sum(n) = sum(n-1) + arr[n - 1]
递归难就难在,我们很多时候看不出来这个递归逻辑,此时就需要罗列出来找规律
从结束到开始,从部分到整体,从具象到抽象......
代码
java
public static void main(String[] args) {
int[] arr = {3, 4, 7, 1, 8, 12, 47};
System.out.println(sum(arr, 5));
}
// 返回类型是int, 参数类型是arr和n
public static int sum(int[] arr, int n) {
// 前0项和显然是0
if (n == 0) {
return 0;
}
// 递归终止条件,返回arr[0]
if (n == 1) {
return arr[0];
}
// 单层递归逻辑,需要注意要加上arr[n-1]而不是arr[n],因为数组的下标是[0, arr.length - 1]
return sum(arr, n - 1) + arr[n - 1];
}
输出结果
demo02
递归实现折半查找
1. 明确递归的参数和返回值
递归参数是数组arr和要查找的值val
以及left,mid,right三个arr下标,用于判断后的移动
返回类型,可以返回找到的数值的下标(int),也可以什么都不返回(void)
2. 明确递归的终止条件
很明显是arr[i] = val,但是我们用谁去充当这个i指针呢?
熟悉折半查找的同学都知道,折半查找需要至少3个指针:left,mid,right
每一个指针都有可能在移动过程中直接指向val,我们应该选择谁当指针i呢?
很明显是mid,mid可以代表所有情况,left和right就不一定,而且可能陷入死循环
比如arr[mid]正好指向val,但是arr[left] != val,那么就会出现,arr[mid]既不大于val,也不小于
mid,但是无法跳出while循环的情况,也就是死循环
3. 明确递归的单层递归逻辑
当arr[mid] != val时执行递归
如果arr[mid]>val,说明val在mid左边,递归到左区间寻找;
如果arr[mid]<val,说明val在mid右边,递归到右区间寻找。
代码
java
public static void main(String[] args) {
// 折半查找的前提是数组有序
int[] arr = {1, 4, 34, 51, 432, 1111, 2776};
halfSearch(arr, 4, 0, 3, arr.length - 1);
}
public static void halfSearch(int[] arr, int val, int left, int mid, int right) {
if (val == arr[mid]) {
System.out.println(val + "找到了,下标是:" + mid);
return; }
if (val > arr[mid]) {
halfSearch(arr, val, mid, (right + mid) / 2, right);// mid + 1也行
} else if (val < arr[mid]) {// else即可
halfSearch(arr, val, left, (mid + left) / 2, mid);// mid - 1也行
}
}
此时就会有聪明的小伙伴问了,如果没找到呢,你这种写法会栈溢出啊
其实我们只需要给left和right加一个判断就可以了
java
public static void main(String[] args) {
// 折半查找的前提是数组有序
int[] arr = {1, 4, 34, 51, 432, 1111, 2776};
halfSearch(arr, 432, 0, 3);
}
public static int halfSearch(int[] arr, int val, int left, int right) {
int mid = (left + right) / 2;
if (val == arr[mid]) {
System.out.println(val + "找到了,下标是:" + mid);
return mid;
}
if (left <= right) {
if (val > arr[mid]) {
return halfSearch(arr, val, mid + 1, right);// mid + 1也行
} else {// else即可
return halfSearch(arr, val, left, mid - 1);// mid - 1也行
}
} else {
System.out.println(val + "没找到!");
return -1;
}
}
如果left都大于right了,arr[mid]还是不等于val,那就说明真的没有这个值
demo03
二叉树的中序遍历
左,根,右---------------->中序遍历
如果一个要访问的结点,存在左子树,那么先访问左子树的最左结点
1. 明确递归的参数和返回值
递归参数是二叉树TreeNode,我们叫它root
返回类型,void即可,我们在遍历途中打印每一个结点的val值即可
2. 明确递归的终止条件
root不断遍历,只要不是空,就可以一直遍历
3. 明确递归的单层递归逻辑
上图这棵树,中序遍历的结果是7,37,13,46,3,19,76,48
因为树是链式结构,我们要遍历一棵树,只能先从根节点开始遍历,不能跨越访问,只能root.left.left......这样访问,这样就令很多同学犯难,我要怎么先从7开始访问呢?
这里其实非常简单,不要想的太复杂
我们仍然先从根节点开始访问,然后访问左子树,最后访问右子树
但是我们在访问左子树结束后再打印,我们只需要保证打印顺序是左根右即可
伪代码(不能运行!!!)
java
public static void middle(TreeNode root) {
if (root == null) {
return;
}
// root不是null,先判断左孩子是不是null,再判断右孩子是不是null
middle(root.left);
System.out.println(left.val);
middle(root.right);
}