文章目录
-
- [1. 汉诺塔问题](#1. 汉诺塔问题)
- [2. 合并两个有序链表](#2. 合并两个有序链表)
- [3. 反转链表](#3. 反转链表)
- [4. 两两交换链表中的节点](#4. 两两交换链表中的节点)
- [5. 快速幂](#5. 快速幂)
1. 汉诺塔问题
题目链接：汉诺塔问题
题目描述：
题解思路：递归
将 n 个盘子从 A 柱移到 C 柱（以 A 为起点、C 为目标、B 为辅助）拆分为三个步骤，其中包含两个结构完全相同的子问题：
- 子问题一：将上面 n-1 个盘子从 A 柱移到 B 柱（以 A 为起点、B 为目标、C 为辅助）
- 独立操作：将最底层唯一的最大盘子从 A 柱直接移到 C 柱
- 子问题二：将n-1 个盘子从 B 柱移到 C 柱（以 B 为起点、C 为目标、A 为辅助）
两个子问题与原问题的解题逻辑完全一致，仅盘子数量、柱子角色不同，符合递归的拆分要求。
每一层递归只处理固定数量的盘子移动，执行完整的三步流程：
- 先递归调用自身，完成上层 n-1 个盘子的转移，为最大盘子腾出移动空间
- 执行唯一的直接移动操作，将当前最底层的最大盘子移到目标柱
- 再次递归调用自身，将之前转移走的 n-1 个盘子，从辅助柱移到目标柱，叠在最大盘子之上
递归过程自顶向下拆分问题，自底向上逐步完成移动，最终合并为完整解。当盘子数量 n = 1 时，无需再拆分，直接将这一个盘子从起始柱移到目标柱即可。
示例代码：
java
class Solution {
public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
movePlant(A,B,C,A.size());
}
public void movePlant(List<Integer> start, List<Integer> temp, List<Integer> target, int size){
if(size == 1){
target.add(start.remove(start.size() - 1));
return;
}
// a 借助 c 将n-1个盘子放到b
movePlant(start,target,temp,size-1);
// a 剩下的一个盘子 放到c
target.add(start.remove(start.size()-1));
// b 借助a 将 n-1 个盘子放到c
movePlant(temp,start,target,size-1);
}
}2. 合并两个有序链表
题目链接：21. 合并两个有序链表
题目描述：
题解思路：递归
- 递归函数：接收两个有序链表的头节点，将它们合并为一个新的有序链表，并返回合并后链表的头节点。
- 函数体逻辑 ：比较两个链表当前头节点的值，选择值较小的节点作为合并后链表的头节点，然后将该节点的
next指针指向「剩余两个链表」递归合并后的结果。 - 递归出口：当其中一个链表为空时，直接返回另一个非空链表（空链表也会被正确处理）。
示例代码：
java
class Solution {
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
if(list1 == null) return list2;
if(list2 == null) return list1;
if(list1.val <= list2.val) {
list1.next = mergeTwoLists(list1.next,list2);
return list1;
}
else {
list2.next = mergeTwoLists(list2.next,list1);
return list2;
}
}
}3. 反转链表
题目链接：206. 反转链表
题目描述：
题解思路：递归
- 递归函数：接收一个链表的头指针，完成链表逆序操作，并返回逆序后链表的头节点。
- 函数体逻辑：先递归处理「当前节点之后的子链表」并完成逆序，再将当前节点添加到已逆序的子链表末尾。
- 递归出口：当当前节点为空，或当前链表仅含一个节点时，无需逆序，直接返回当前节点。
示例代码：
java
class Solution {
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode newNode = reverseList(head.next);
head.next.next = head;
head.next = null;
return newNode;
}
}4. 两两交换链表中的节点
题目链接：24. 两两交换链表中的节点
题目描述：
题解思路：递归
- 递归函数：接收一个链表，完成链表节点的两两交换，并返回交换后链表的头节点。
- 函数体逻辑：先递归处理「第二个节点之后的子链表」，再将当前的两个节点进行交换，最后将交换后的当前节点组与已处理好的后续子链表连接。
- 递归出口：当当前节点为空，或当前链表仅含一个节点时，无需交换，直接返回当前节点。
示例代码：
java
class Solution {
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null) return head;
ListNode newNode = swapPairs(head.next.next);
ListNode temp = head.next;
temp.next = head;
head.next = newNode;
return temp;
}
}5. 快速幂
题目链接：50. Pow(x,n)
题目描述：
题解思路：快速幂
这道题递归的核心是：不直接算 xⁿ，而是把它拆成规模更小、解法完全相同的子问题，递归解决后再合并答案。
就是求 x 的 n 次方 = 求 x 的 n/2 次方 × 自己（再根据奇偶决定是否多乘一个 x，n是奇数则多乘一个 x）
负数处理：
x 的负 n 次方 = 1 / (x 的正 n 次方)，先把负指数变成正指数，仍然用上面完全相同的递归逻辑计算，最后取倒数即可。
示例代码：
java
class Solution {
public double myPow(double x, int n) {
return n < 0 ? 1.0 / pow(x,-n) : pow(x,n);
}
public double pow (double x, int n){
if(n == 0) return 1.0;
double tmp = pow(x,n/2);
return n % 2 == 0 ? tmp*tmp : tmp*tmp*x;
}
}