递归的本质

本篇文章深入剖析了递归的核心原理及其在编程实践中的广泛应用。文章首先围绕三个核心主题展开讨论：链表的构建、二叉树的构建、以及链表的反转，通过这些具体案例，生动展示了递归方法在处理数据结构时的高效性和简洁性。随后，文章详细解读了递归算法的设计原则和逻辑思维方式，旨在帮助读者不仅理解递归操作的技术层面，更重要的是领会其背后的思想精髓。通过对这些关键方面的系统分析和示例演示，我们期望读者能够全面掌握递归的概念，提升使用递归解决问题的能力，进而在软件开发和算法设计的各个领域中，更加灵活和自信地应用递归技术。

1. 链表的构建

*以不带头节点、基于尾插法的方式构建链表，本小节将通过用户输入获取每个节点的值，并逐步展示如何在链表的尾部添加新节点，从而实现一个顺序存储数据的单向链表。

1.1 常规构建链表的做法：首先确定链表的长度和头节点，然后利用for循环按照指定长度逐个创建并链接节点以构建完整的链表。

以长度为3的链表举例

实现代码如下： 

typedef ListNode* LinkList; // LinkList 是指向ListNode的指针的别名
 
void createList(LinkList &L, int n) {
    L = NULL; 
    LinkList tail = NULL; 
    int value = 0;
 
    for (int i = 0; i < n; ++i) {
        cin >> value; 
 
        if (L == NULL) { // 如果链表为空，则新节点即为头节点
            L = new ListNode(value); 
            tail = L; 
        } else { // 如果链表不为空，则在尾部插入新节点
            tail->next = new ListNode(value); 
            tail = tail->next; 
        }
    }
}

 1.2 递归构建链表的做法：基于递归算法的核心原理，通过自我调用函数实现节点的逐一创建和链接，从而高效地构建链表结构。

主要构建思想

将一个链表看作由两个部分构成：头节点和其后的所有节点形成的子链表，这种视角便于我们采用递归思想进行构建。首先创建链表的头节点，随后将构建剩余部分的任务递归地委托给相同的构建过程，直至构建完成整个链表。

构建的本质

构建链表的核心过程在于构建每一个节点，并将它们连接起来，这一过程可以通过调用createList(L->next, n - 1)函数递归地实现。该函数的作用是以当前节点为头节点，构建包含剩余所有节点的子链表，并通过指针连接起来，从而完成整个链表的构建。

图解如下：

 

递归函数的构建

首先，我们定义一个名为createList的函数，该函数假定具有构建链表的功能，虽然在当前阶段它的实现体为空，但我们将其视为能够完成链表构建的完整过程。

构建函数如下：

​​​​​​​void createList(LinkList &L, int n)

既然我们假设createList函数具有构建链表的功能，那么调用createList(L->next, n - 1);便能够负责构建头节点之后的所有节点所形成的子链表，从而实现整个链表的递归构建过程。

具体实现代码如下所示：

typedef ListNode* LinkList; // LinkList 是指向ListNode的指针的别名
 
 
void createList(LinkList &L, int n)
{ 
   if (n == 0)return;
   else{  
        int value = 0;
        cin >> value;
        L = new ListNode(value);    
        L->next = NULL;   
       createList(L->next, n - 1);   //递归创建n-1个节点
}

 2. 二叉树的构建

主要构建思想(与链表递归构建思想类似)

将一个二叉树视为由三个基本部分构成：根节点、左子树和右子树。这种分解方法便于我们采用递归思想进行构建。首先，我们创建二叉树的根节点，作为整个树的起始点。接着，通过递归调用同一构建过程，分别负责左子树和右子树的构建任务，将它们与根节点相连。这样，通过不断地递归分解和构建，直至每个子树都被逐一实现，最终完成整个二叉树的构建。

构建的实质(与链表递归构建思想相同)

构建链表的核心过程在于构建每一个节点，并将它们连接起来。从递归构建二叉树的角度来看，这一过程可以通过调用CreateBiTree(T->lchild)和CreateBiTree(T->rchild)函数递归地实现。该函数的作用是以当前节点为根节点，分别负责左子树和右子树的构建任务，将它们与根节点相连。通过不断地递归分解和构建，直至每个子树都被逐一实现，最终完成整个二叉树的构建。

图解如下：

具体实现代码如下：(代码函数构建方法参考链表递归函数的构建) 

typedef TreeNode* BiTree; // BiTree 是指向TreeNode的指针的别名
 
void CreateBiTree(BiTree &T)
{
    char value;
    cin >> value;
    if (ch == '#')
        T = NULL;
    else
    {
        T = new BiNode(value);
        /*递归创建*/ 
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    
}
 

 3. 反转链表

leetcode题目链接

问题解决思路

通过上述对单链表和二叉树的构建，我们可以发现递归函数的基本条件是将一个问题划分为无数个小问题，并通过这些小问题之间的联系来解决原有问题。递归函数的核心思想在于假设给定的构建函数已经具备了实现所需功能的能力，然后通过逐步实现这个假设函数的功能，从而构建出我们需要的递归函数。

具体地说，我们首先要明确递归函数的输入和输出，也就是函数的参数和返回值。然后，我们假设这个递归函数已经能够正确地处理规模更小的子问题，并返回正确的结果。接下来，我们通过递归调用自身，将原问题转化为规模更小的子问题，并利用子问题的解来构建整个问题的解。在每一层递归中，我们都将问题分解为更小的部分，并通过假设函数的功能来解决这些子问题。

递归函数的构建(与链表递归函数构建思想相同)

因题目中给了一个名为ListNode* reverseList(ListNode* head)的函数，我们假设这个函数具有反转链表的功能。根据我们之前的分析，当调用reverseList(head->next)时，会得到除头节点以外的子链表反转后的头节点。这是因为该递归调用会不断地将当前节点的下一个节点作为参数传入reverseList函数，直至达到子链表的末尾。然后，通过反转指针的操作，将子链表中的节点依次连接起来，最终返回反转后的头节点。由于每次递归调用的参数都是当前节点的下一个节点，所以最终得到的头节点就是子链表反转后的头节点。

递归图解

1. 假设一个长度为4的链表

2. 调用reverseList(head->next)函数，此时我们得到的链表如下所示

3. 将其除头节点以外的完成反转的子链表看作一个整体，这里我们用值为else的结点进行表示，接下来我们将头节点与else结点进行反转，即可得到整个链表的反转。

实现代码 

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;
    }
};

测试完美通过 

总结

*递归函数的核心构造思想是将一个问题划分为无数个小问题，并通过假设给定的构建函数已经具备了实现所需功能的能力，从而逐步实现这个假设函数的功能，从而构建出我们需要的递归函数。

通过这种思想，我们可以将一个庞大且难以直接解决的问题细分为多个小问题。每个小问题都可以通过递归调用自身来解决，而递归调用的终止条件则是基本问题的解决方案。通过不断将问题划分为更小的子问题，并利用已解决的子问题的解来构建整体问题的解，我们最终可以得到原始问题的解。

例如，对于单链表的构建，我们可以将链表的每个节点看作一个小问题，通过递归调用构建函数来构建每个节点的子结构，从而构建出完整的链表。而对于单链表的反转，我们可以通过递归地将链表的头节点与剩余部分进行反转，然后将头节点放到反转后链表的末尾，从而实现整个链表的反转。

通过这种递归思想，我们能够简化复杂问题的求解过程，将问题分解为更小的子问题，并通过递归解决这些子问题，最终得到原始问题的解。递归函数的设计和实现中，重要的是定义好递归的边界条件和递归的参数传递方式，确保每次递归都能够处理一个更小规模的问题，直到达到终止条件并返回结果。这种递归思想在算法和数据结构中有广泛应用，并为解决复杂问题提供了一种有效的方法。