文章目录
- 递归
- 合并两个有序链表
- 题解
- 代码
- 反转链表
- 题解
- 代码
- 两两交换链表中的节点
- 题解
- 代码
- Pow(x, n)（快速幂）
- 题解
- 代码
- 汉诺塔
- 题解
- 代码
- 总结
递归
1. 重复的子问题+宏观看待递归问题
合并两个有序链表
题目链接
题解
1. 重复的子问题 -> 函数头的设计
合并两个有序链表，Node* dfs(l1,l2)
2. 只关心某个子问题在做什么事情 -> 函数体的设计
主问题是合并两个链表，这样可以拆成一个节点和它后面的链表，它后面的链表和另一个链表可以合并为一个链表，之后问题可以再拆成子问题
1、链表中的值比大小，选小的那个，这里随便写的 l1
2、l1->next = dfs(l1->next,l2)
3、返回 l1，把链表连起来
3. 递归的出口
只要其中一个节点为空，返回另一个节点，如果两个节点都为空，返回空
代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
// 递归的时候l1和2的顺序可以变
ListNode* dfs(ListNode* a,ListNode* b)
{
// 子问题
// 可以分成一个头结点+剩余的链表和另一个链表合并
if(a == nullptr) return b;
if(b == nullptr) return a;
// 不能这样写,会出现a != nullptr和b != nullptr的情况return a
// if(a == nullptr) return b;
// else return a;
if(a->val > b->val)
{
b->next = dfs(a,b->next);
return b;
}
else
{
a->next = dfs(a->next,b);
return a;
}
}
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
{
return dfs(list1,list2);
}
};
反转链表
题目链接
题解
1. 宏观上看待递归
1、把第一个节点后面的链表反转，并且返回最后一个节点作为头节点返回，然后把第一个节点和链表链接起来，你就相信dfs可以完成链表的逆置并且返回最后一个节点作为头节点
2. 将链表看成一棵树
代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* reverseList(ListNode* head)
{
if(head == nullptr || head->next == nullptr) return head;
// 不用实现内部的代码,把它想象为一个黑盒
// 宏观看待递归
// 把head->next的一段链表逆置,返回这段链表的头节点
ListNode* newhead = reverseList(head->next);
head->next->next = head;
head->next = nullptr;
return newhead;
}
};
两两交换链表中的节点
题目链接
题解
1. 宏观上使用递归
1、将前两个节点看成一个整体，后面的链表看成一个整体，相信后面的链表可以完成任务，返回头节点
2、先将head->next存为cur，防止后面找不到，
head->next = dfs(head->next->next)，cur->next = head，就完成了链表的交换
代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* swapPairs(ListNode* head)
{
if(head == nullptr || head->next == nullptr) return head;
ListNode* cur = head->next;
head->next = swapPairs(head->next->next);
cur->next = head;
return cur;
}
};
Pow(x, n)（快速幂）
题目链接
题解
1. 用暴力会超时
2. 快速幂的时间复杂度是O(logN)，每次都分解为幂的一半相乘，比如 2^n = 16，如果n是偶数，tmp * tmp即为答案，n是奇数，tmp * tmp * x是答案
代码
class Solution
{
public:
double myPow(double x, int n)
{
return n < 0 ? 1 / Pow(x,-(long long)n) : Pow(x,n);
}
double Pow(double x,long long n)
{
if(n == 0) return 1;
double tmp = Pow(x,n/2);
return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;
}
};
汉诺塔
题目链接
题解
1. 汉诺塔可以分解为相同的子问题，
n-1个盘子通过C柱移动到B柱，A柱上的盘子移动到C柱，B柱上n-1个盘子通过A柱移动到C柱，下图中N = 2，N = 3，N = 4个盘子都是相同的子问题
2. 如何写代码？
1、重复的子问题->函数头
dfs(x,y,z,n)，x柱上的盘子借助y柱移动到z柱上
2.只关心每一个子问题怎么处理->函数体的设计
dfs(x,z,y,n-1)
x.back() -> z
dfs(y,x,z,n-1)
3.递归的出口
n == 1，只有一个盘子的时候，直接把x柱上的盘子移动到z柱上，x.back() -> z
代码
class Solution
{
public:
// void dfs(vector<int>& a,vector<int>& b,vector<int>& c,int n)
// {
// if(n == 1)
// {
// c.push_back(a.back());
// a.pop_back();
// return;
// }
// dfs(a,c,b,n-1);
// c.push_back(a.back());
// a.pop_back();
// dfs(b,a,c,n-1);
// }
void hanota(vector<int>& A, vector<int>& B, vector<int>& C)
{
// int n = A.size();
// dfs(A,B,C,n);
C = A;
}
};
总结
1.什么时候使用递归？
一个问题可以分成相同类型的子问题
2. 怎么使用递归？
1、重复的子问题->函数头的设计
2、只关心某个子问题在做什么事情->函数题的设计
3、递归的出口->返回条件
