算法与数据结构 之 递归，回溯

什么叫递归：
函数在运行时调用自己，这个函数就叫递归函数，调用的过程叫做递归；

递归的特点：
1、递归函数必须要有终止条件，否则会出错；
2、递归函数先不断调用自身，直到遇到终止条件后进行回溯，最终返回答案

例题1：
https://leetcode-cn.com/problems/merge-two-sorted-lists/ 21. 合并两个有序链表

思路：
1、终止条件：当两个链表都为空时，表示我们对链表已合并完成。
2、如何递归：我们判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。（调用递归）

时间复杂度： O（m+n）
空间复杂度： O（m+n）

代码实现：

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l2.next, l1)
            return l2

例题2： https://leetcode-cn.com/problems/swap-nodes-in-pairs/ 两两交换链表中的节点

思路：
1、返回值：交换完成的子链表
2、调用单元：设需要交换的两个点为 head 和 next，head 连接后面交换完成的子链表，next 连接 head，完成交换
3、终止条件：head 为空指针或者 next 为空指针，也就是当前无节点或者只有一个节点，无法进行交换

代码实现：

class Solution:
    def swapPairs(self, head):
        if not head or not head.next:
            return head
        first, second = head, head.next
        first.next = self.swapPairs(second.next)
        second.next = first
        return second

image.png

什么叫回溯法：
采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况：
1、找到一个可能存在的正确的答案；
2、在尝试了所有可能的分步方法后宣告该问题没有答案。

例题3 https://leetcode-cn.com/problems/permutations/ 全排列

思路：回溯法，这个问题可以看作有 n 个排列成一行的空格，我们需要从左往右依此填入题目给定的 n 个数，每个数只能使用一次。那么很直接的可以想到一种穷举的算法，即从左往右每一个位置都依此尝试填入一个数，看能不能填完这 n个空格，在程序中我们可以用回溯法来模拟这个过程。
时间复杂度：O(N×N!)
空间复杂度：O(N×N!)

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []
        def backtrack(nums, tmp):
            if not nums:
                res.append(tmp)
                return
            for i in range(len(nums)):
                backtrack(nums[:i] + nums[i+1:], tmp + [nums[i]])
        backtrack(nums, [])
        return res

image.png

例题4 括号生成 https://leetcode-cn.com/problems/generate-parentheses/

思路：
终止条件：插入的数量等于2*n
搜索条件：
1、插入数量不超过n
2、可以插入 ） 的前提是 ( 的数量大于 ）

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        result = []
        def dfs(left, right, tmp):
            if len(tmp) == n * 2:
                result.append(tmp)
                return
            if left < n:
                dfs(left + 1, right, tmp + '(')
            if right < left:
                dfs(left, right + 1, tmp + ')')
        dfs(0, 0, '')
        return result

image.png

例题5 77. 组合 https://leetcode-cn.com/problems/combinations/

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

思路：
递归，每次把整数拆解成 当前值i的数组列表tmp，和 i+1的计数进行递归，如果列表tmp的长度达到k，则加入至结果集中。
1、终止条件：数组组合的长度等于k
2、递归参数：参数1：当前元素 + 1， 参数2：当前元素的数组

T：O（n！） S：O（1）

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def dfs(i, tmp):
            if len(tmp) == k:
                res.append(tmp)
            for j in range(i, n + 1):
                dfs(j + 1, tmp + [j])
        res = []
        for i in range(1, n - k + 2):
            dfs(i + 1, [i])
        return res

撰写记录
2020.12.04-15:08:01-第一次撰写
2020.12.29-19:25:10-第二次撰写