递归算法实战：从汉诺塔到快速幂与链表操作

函数头

void hanoi(vector<int>& A, vector<int>& B, vector<int>& C, int n);

• 返回值：无
• 参数：三个柱子上的盘子，当前需要处理的盘子个数（当前问题规模）
• 函数作用：将 A 中的上面 n 个盘子挪到 C 中

递归函数流程

1. 当前问题规模为 n=1 时，直接将 A 中的最上面盘子挪到 C 中并返回；
2. 递归将 A 中最上面的 n-1 个盘子挪到 B 中；
3. 将 A 中最上面的一个盘子挪到 C 中；
4. 将 B 中上面 n-1 个盘子挪到 C 中。

解题过程

算法实现（C++）

class Solution {
public:
    void hanota(vector<int>& a, vector<int>& b, vector<int>& c) {
        dfs(a, b, c, a.size());
    }
    
    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);
    }
};

如果是笔试题且允许直接赋值，也可以简化处理：

class Solution {
public:
    void hanota(vector<int>& a, vector<int>& b, vector<int>& c) {
        c = a;
    }
};

2 合并两个有序链表

题目描述

解题过程

算法实现（C++）

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // 递归出口
        if (l1 == nullptr) return l2;
        if (l2 == nullptr) return l1;
        
        // 比大小
        if (l1->val <= l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

3 反转链表

题目描述

解题过程

算法实现（C++）

// 将链表看成一棵树
/**
 * 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;
        
        // 主逻辑
        ListNode* newhead = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        
        // 最终返回结果
        return newhead;
    }
};

4 两两交换链表中的节点

题目描述

解题过程

算法实现（C++）

/**
 * 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;
        
        // 节点为空或者是个尾节点，就不能交换
        // 宏观角度看待
        auto tmp = swapPairs(head->next->next);
        auto ret = head->next;
        head->next->next = head;
        head->next = tmp;
        
        // 返回最终结果
        return ret;
    }
};

5 Pow(x, n)

题目描述

解题过程

算法实现（C++）

class Solution {
public:
    double myPow(double x, int n) {
        // 主函数
        // 细节问题：n 可能是负数
        return n < 0 ? 1.0 / Pow(x, -(long long)n) : Pow(x, n);
    }
    
    double Pow(double x, long long n) {
        // 快速幂
        // 递归出口
        if (n == 0) return 1.0;
        
        // x ^ 0 = 1
        // 递归
        double tmp = Pow(x, n / 2);
        return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;
    }
};