前言

我们知道递归是一类比较巧妙但是理解难度有点大的算法，对于工作中需要用到数据结构和高级算法的人需要牢固掌握递归算法。今天就以实际的案例来带大家一起学习和理解如何用Python实现递归算法。

升序列表合并

题目：

将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
?
示例：
?
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

对于这一道关于链表的问题，由于要求新的链表是通过改变原来两个链表，所以我们不可以新建一个链表来搭建新的链表而是在原来链表基础上改变链表节点中的指向。

我们发现，合并两个链表可以拆解成合并一个链表的指向以及链表的一个节点。由于原问题和子问题具有相同的结构，因此我们可以考虑使用自上而下的递归来解决：

class Solution:
    def mergeTwoLists(self, l1, l2):
        if l1 is None:
            return l2
        elif l2 is None:
            return l1
        elif l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

值得注意的是，这里的mergeTwolists函数在类中，调用的话需要在前面加上self。可以代码看出来递归写起来形式非常简单。

对称二叉树

题目：

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
 

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3
 

对于二叉树，我们其实有两种遍历方法：广度优先搜索以及深度优先搜索。从字面的意思就可以理解，广度优先是一层层搜索，需要用到“队列”这种数据结构。而深度优先是一条道走到黑，走到最深处后再搜索另一条路径，可以用递归的方法来完成：

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root: 
            return True
        else:
            return self.isSymmetricTree(root.left, 
            root.right)
?
    def isSymmetricTree(self, left, right):
        if left is None and right is None: return True   #同时为空
        if left is None or right is None : return False  #一个为空 
        if left.val != right.val : return False          # 值不相等 ！！
        return self.isSymmetricTree(left.left, right.right)
         and self.isSymmetricTree(left.right, right.left)

在第一个函数isSymmetric中，我们考虑到一种特殊情况就是树为空，同时由于题目给定的函数输入只有一个节点，不适合作为递归函数，因此我们需要额外定义一个新的函数isSymmetricTree来实现递归。

二叉树的最大深度

题目：

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
?
示例：
给定二叉树 [3,9,20,null,null,15,7]，
?
    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

这道题和上面对称二叉树都是针对二叉树的，因此也适合用递归实现深度优先搜索来计算二叉树的最大深度：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        
        left = self.maxDepth(root.left)
        right = self.maxDepth(root.right)
        return 1+max(left,right)

这里我们本身定义的函数的输入是一个节点，可以用来作为递归函数。