递归
递归,去的时候叫“递”,回来的时候叫“归”;
递归的三个条件
- 一个问题的解可以分解为几个子问题的解;
- 这个问题与分解后的子问题,除了数据规模不同,求解思路完全相同
- 存在递归终止条件
写递归代码的关键就是找到如何将大问题分解为小问题的规律,并且基于此写出递推公式,然后再推敲终止条件,最后将递推公式和终止条件翻译成代码。
递归要注意的两点
1. 递归代码要警惕堆栈溢出
函数调用会使用栈来保存临时变量,每调用一次函数,都会将临时变量封装为栈帧压入内存栈,等函数执行完成返回时,才出栈。系统栈或者虚拟机栈空间一般都不大,如果递归要求解的数据规模很大,调用层次很深,一直压入栈,就会有堆栈溢出的风险。
当递归调用超过一定深度后,我们就不继续往下再递归了,直接返回保存
// 全局变量,表示递归的深度。
int depth = 0;
int f(int n) {
++depth;
if (depth > 1000) throw exception;
if (n == 1) return 1;
return f(n-1) + 1;
}
2. 递归代码要警惕重复计算
为了避免重复计算,我们可以通过一个数据结构(比如散列表)来保存已经求解过的f(k)
public int f(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
// hasSolvedList可以理解成一个Map,key是n,value是f(n)
if (hasSolvedList.containsKey(n)) {
return hasSolvedList.get(n);
}
int ret = f(n-1) + f(n-2);
hasSolvedList.put(n, ret);
return ret;
}
题目
1. 从尾到头打印链表
输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。
示例 1:
输入:head = [1,3,2]
输出:[2,3,1]
ArrayList<Integer> list = new ArrayList<Integer>();
public int[] reversePrint(ListNode head) {
reverse(head);
int[] nums = new int[list.size()];
for(int i =0;i<list.size();i++){
nums[i]=list.get(i);
}
return nums;
}
public void reverse(ListNode head){
if(head == null){
return;
}
reverse(head.next);
list.add(head.val);
}
2. pow(x,n)
实现 pow(x, n) ,即计算 x 的 n 次幂函数(即,xn)。
思路:由于正常思路会导致栈溢出,所以增加map函数,当之前遍历到的时候,就可以直接将结果拿来用。但是这样也是出现了栈溢出~~~
class Solution {
//递归如何规避栈溢出呢?????
public double myPow(double x, int n) {
if(n <0){
return mypow1(1/x,-n);
}else{
return mypow1(x,n);
}
}
HashMap<String,Double> map = new HashMap<String,Double>();
public double mypow1(double x,int n){
if(n == 0)
return 1;
if(map.containsKey(x+"\t"+n)){
return map.get(x+"\t"+n);
}
double res = mypow1(x,n-1)*x;
map.put(x+"\t"+n,res);
return res;
}
}
新的思路
class Solution {
//递归如何规避栈溢出呢?????
public double myPow(double x, int n) {
if(n <0){
return mypow1(1/x,-n);
}else{
return mypow1(x,n);
}
}
public double mypow1(double x,int n){
if(n == 0)
return 1;
double y = mypow1(x,n/2);
return n%2==0? y*y :y*y*x;
}
}
3. 递归乘法
递归乘法。 写一个递归函数,不使用 * 运算符, 实现两个正整数的相乘。可以使用加号、减号、位移,但要吝啬一些。
示例1:
输入:A = 1, B = 10
输出:10
示例2:
输入:A = 3, B = 4
输出:12
class Solution {
public int multiply(int A, int B) {
int minNum = Math.min(A,B);
int maxNum = Math.max(A,B);
return dfs(minNum,maxNum);
}
public int dfs (int minnum,int maxnum){
if(minnum == 0) return 0;
if(minnum == 1) return maxnum;
if(minnum == 2) return maxnum << 1;
return dfs(2,maxnum) + dfs(minnum-2,maxnum);
}
}