再谈递归

　　我们似乎记得有这么一个观点”递归都可以通过迭代(循环)实现，但是迭代不一定能够通过递归实现“。那么我们是否思考过这其中的道理呢？

一、递归概念

　　对于什么是递归，众说纷纭。我个人比较认可的一种简单直接的文字描述是：先递进，再回归；还有一种是动图描述：一只兔子拿着一面镜子，镜子里面和镜子的镜子的...镜子里面还是相同的场景，循环不止。当然，递归可不能这么无限下去，容易栈溢出，所以，递归得有出口。

二、什么时候用递归

　　第一次接触递归的例子是斐波拉契函数:F(n) = F(n - 1) + F(n - 2), F(1) = F(0) = 1; n >= 2。对该函数进行分析不难发现，如果我们想求解一个大的斐波拉契函数值m，我们必须得先不断递进到我们能够获取到的函数值，例如：F(1) = F(0) = 1。然后再回归，依次求解F(2) = F(1) + F(0); F(3) = F(2) + F(1); ... ....; F(m)  = F(m - 1) + F(m - 2)。

　　代码如下：

int F(int n)
{
     if(n == 0 || n == 1){
         return 1; 
     }
      return F(n - 1) + F(n - 2);   
}

　　所以，斐波拉契拥有完美的递归性，非常适合使用递归实现。此时，递归出口：n = 0 或 n = 1的时候返回1，递归条件：F(n - 1) + F(n - 2)；当然迭代也能够完美实现该函数。到这里，我们就明白了，能够迭代实现的不一定拥有递归性，比如：递归出口。我们可以这么通俗的理解递归：递归是一种将复杂问题逐步分解为小的相同问题，直到分解到我们能够求解的最小问题为止，每个次小问题的解都给予更小问题的解，最后回归到复杂问题的解的方法。一般能够用数学公式表示的，可通过数学公式知道是否具有递归性；但是有时候我们的问题并不能单纯的通过数学公式表示，也可能具有递归性，比如汉诺塔。

三、哪些数据结构拥有递归性

　　拥有完美递归性的数据结构里面想到的是二叉树。例如：

                      A
                   /      \
                  B       C
                /   \    /   
               D    E   F

　　从根节点A看，就是一个二叉树；从A的左子节点B或右子节点C向下看都是一颗二叉树。其实，链表也拥有递归性。例如：

-----------    -----------   -----------
| A | next|--> | B | next|-->| C | null|
-----------    ------------  -----------

　　当我们继续向尾部插入节点D的时候，我们可以将A --> B -->Ｃ这个链表当成一个头节点head，只有找到这个头节点，然后head->D即可。

四、二叉树和链表递归实现

　　二叉树数的很多操作都可以直接用递归实现，代码逻辑简单，最典型的就是深度遍历，如下：

// Root-Left-Right
void PrevOrder(Node* root)
{
    if(root == nullptr){
        return;
    }
    std::cout  << root->data << ",";
    PrevOrder(root->left);
    PrevOrder(root->right);
}

// Left-Root-Right
void Inorder(Node* root)
{
    if(root == nullptr){
        return;
    }
    Inorder(root->left);
    std::cout << root->data << ",";
    Inorder(left->right);
}

// Left-Right-Root
int PostOrder(Node* root)
{
    if(root == nullptr){
        return;
    }
    PostOrder(root->left);
    PostOrder(root->right);
    std::cout << root->data << ",";
}

　　单链表尾插递归算法：

Node* PushBack(Node* head, int data)
{
    // 带头结点的链表
    if(head->next == nullptr){
       return new Node(data);
    }
    head->next = PushBack(head->next, data);
    return head;
}

　　单链表倒置递归算法：

Node* Invert(Node* head)
{
    if(head->next == nullptr){
        return head;
    } 
    auto newHead = Invert(head->next); // head--> newHead
   
    newHead->next = head;  // head <--> newHead
    head->next = nullptr;      // head<-- newHead
    return newHead;
}

　　上面迭代法的逻辑也相对比较简单，感兴趣的同学可以自行实现。

　　上面是我们对递归算法的个人看法，主要是方便个人回顾之用，也希望其他读者能够对递归的认识起到一点理解的作用！