【手把手教你刷力扣14】递归recursion（含力扣真题）

递归recursion

基本概念

定义：函数直接或者间接调用自己

func():
	func();

四个要素：

• 接收的参数
• 返回值
• 终止的条件
• 递归拆解：如何递归下一层

recursion (int n) ->int:
	if(n<2):
		return n==1?1:0
	m=recursion(n-1)+recursion(n-2);
	return m

参数：n
终止条件：0/1
返回值：f(n-1)+f(n-2)
拆解：f(n-1), f(n-2)

时间复杂度：O(N)
空间复杂度：O(N)

为什么空间复杂度是O(N)?

可以发现这是一个先进后出的结构，f(1)和f(0)后进先出，即栈结构。
程序会隐设一个递归栈来存储之前的函数，存储空间大小就是其高度，即N。

509. 斐波那契数

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

class Solution {
public:
    int fib(int n) {
        if(n < 2){
            return n == 1?1:0;
        }
        return fib(n - 1) + fib(n - 2);
    }
};

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr||head->next==nullptr){
            return head;
        }
        ListNode *p=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        return p;
    }
};

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

class Solution {
public:
    void recursion(vector<char>& s,int left,int right){
        if(left >= right){
            return;
        }
        recursion(s,left + 1,right - 1);
        int temp = s[left];
        s[left] = s[right];
        s[right] = temp;
    }
    void reverseString(vector<char>& s) {
        if(s.size() == 0){
            return;
        }
        int left = 0,right = s.size() - 1;
        recursion(s,left,right);
    }
};