【leetcode记录02】递归

（一）相关原理

1.减治思想：

在拆分子问题的时候，只将原问题转化成一个规模更小的子问题，因此子问题的结果就是上一层原问题的结果，每一步只需要解决一个规模更小的子问题，相比较于「分治思想」而言，它没有「合并」的过程。

「减治思想」思想的典型应用是「二分查找」「选择排序」「插入排序」「快速排序」算法。

2.递归与迭代

2.1「自顶向下」与「递归」

「自顶向下」是直接面对我们要解决的问题，逐层拆分，直到不能拆分为止，再按照拆分的顺序的逆序逐层解决，直至原问题得到了解决，这是「递归」。

2.2「自底向上」与「迭代」

如果我们非常清楚一个问题最开始的样子，并且也清楚一个问题是如何从它最开始的样子逐步演变成为我们想要求解的问题的样子，我们就可以通过「递推」的方式，从小规模的问题开始逐步「递推」得到最终要解决的大问题的解。

（很关键一点是，使用迭代必须要 能正确且全面地抽取出其实行逻辑，否则的话可能会出现逻辑不完善，边界条件不能完全考虑到等问题，可能会需要很多条件判断等步骤，但是想起来可能更加符合人思考的逻辑。）

（二）关键例题

1.归并排序

使用了减治的思想，通过递归地二分操作来进行处理，首先递归地将数组一分为二，然后没有其他操作直到触底，但是在回溯的过程中，需要进行一个逐个检验并合并数组的操作（这个过程实际是自底向上的），从数据形式上，传入的始终都是数组形式。

def mergeSort(self,alist):#触底条件if len(alist)<=1:return alist#递归主体 （基于下行过程中的二分操作，只是将它改成了递归式，从而可以在回溯的过程中进行后面写的那个操作）mid=len(alist)//2 #这里思考的时候一开始想到要分奇偶，而且每隔一个都会奇偶交替，但实际模拟一下发现并不需要分，毕竟就算不等分也没关系，等分并不是硬性要求，最后都能顺利触底就好left=self.mergeSort(alist[:alist])right=self.mergeSort(alist[alist:])#回溯过程中的操作merged=[]while left and right:if left[0]<=right[0]: #这里一定程度上可以认为是用了双指针（但它仅仅是用了两个指针而已）merged.append(left.pop(0)) #非常pythonic，所以不会真实地用到类似指针的东西else:merged.append(right.pop(0))merged.extend(left if left else right)return merged

2.快速排序

①自己想的常方法（要用到额外空间）

也是使用了减治的思想，只是之前是按照序号进行二分，这次选择的是一个数字，然后按照数值大小来排，也是一种可实现的方法，递归实现。

def quickSort(self,alist):#触底条件（递归结束条件）if len(alist)<=1:return alist#写出每一次顺利二分的操作a=alist[0] #选择参考数值为最左侧数据l=[]l.append(a)cnt=0for i in alist[1:]:if i<a:l.insert(0,i)cnt+=1else:l.append(i)return l #这样可以得到一个成功左都更小右都更大的“进步了的”数组#写递归主体（基于上行过程中的合并操作）left=self.quickSort(alist[:cnt+1]) #这里必须要是cnt+1,之所以+1是因为一定要把参考数据划分到左边去作为最右元素，不然它要是在右侧，就又会变成右半部分的参考元素，但是事实上已经不需要了，我一开始只是觉得它重复作为参考元素没有意义，但我仔细一想，重复作为参考元素会导致右半边无法顺利递归下去，大问题，所以必须得注意。right=self.quickSort(alist[cnt+1:])return left.extend(right)

②双指针（对撞指针）（不需要额外空间）

def quickSort(self,alist):#触底条件（递归结束条件）if len(alist)<=1:return alist#写出每一次顺利二分的操作a=alist[0]lefthand=1righthand=len(alist)-1done=Falsewhile not done:while lefthand<=righthand and alist[lefthand]<=a:lefthand+=1while lefthand<=righthand and alist[righthand]>=a:righthand-=1if lefthand>righthand:done=Trueelse:temp=alist[lefthand]alist[lefthand]=alist[righthand]alist[righthand]=temptemp=alist[righthand]alist[righthand]=alist[0]alist[0]=tempreturn alist#写递归主体self.quickSort(alist[:righthand])self.quickSort(alist[righthand+1:])#这边要return吗

3.二分查找

3.1 二分查找

①自己写的递归：

class Solution(object):def search(self, nums, target):""":type nums: List[int]:type target: int:rtype: int"""#递归结束条件if len(nums)==0:return -1if len(nums)==1 and nums[0]!=target:return -1#内部实现逻辑+递归主体mid=len(nums)//2if nums[mid]==target:return midelif nums[mid]>target:return self.search(nums[:mid],target)else:res=self.search(nums[mid+1:],target)if res==-1:return reselse:return mid+1+res

②迭代（使用双指针）

class Solution(object):def search(self, nums, target):""":type nums: List[int]:type target: int:rtype: int"""if len(nums)==0:return -1left=0right=len(nums)-1while left<=right: #必须是带=，不然只剩两个并且是右边那个的时候会漏掉mid=(left+right)/2if nums[mid]==target:return midelif nums[mid]>target:right=mid-1else:left=mid+1return -1

3.2类似的题：x的平方根

①迭代的二分查找（用到双指针）

class Solution(object):def mySqrt(self, x):""":type x: int:rtype: int"""left=1right=xmid=(left+right)//2while left<=right:if mid**2==x:return midelif mid**2<x:left=mid+1else:right=mid-1return right

因为它不是列表，所以不能直接切片之类的操作，所以即使是递归也是需要用到双指针的。但是我想了一下，好像因为这个返回值就是它的根，没办法用递归。

②牛顿迭代法

有时间再说吧。

3.3 可以深入理解二分的题：搜索旋转排序数组

① 自己写的：分步法（使用了递归）

整体思路大概是：1.找到两个有序的分界处（使用普通的迭代法）；2.最后一个元素是分界元素，可以通过比较最后一个元素和target的大小来判断是在哪半个序列里； 3.在确定的序列中再进行常规的二分查找。

整体将近50行，且在分界取切片和在其中二分查找的接口处容易出现很多忽略的边界情况（也直接导致提交了好几次都不对，调试了半个多小时才顺利通过。）

class Solution(object):#常规的二分查找def s(self,nums,target):if len(nums)==0:return -1if len(nums)==1 and nums[0]!=target:return -1mid=len(nums)//2if target==nums[mid]:return midelif target<nums[mid]:return self.s(nums[:mid],target)else:r=self.s(nums[mid+1:],target)if r==-1:return relse:return mid+1+r#主体函数def search(self, nums, target):""":type nums: List[int]:type target: int:rtype: int"""if nums==[]:return -1if len(nums)==1:return 0 if nums[0]==target else -1cur=0l=len(nums)while cur<l-1:if nums[cur]<=nums[cur+1]:cur+=1else:breakif cur==l-1:return self.s(nums, target)cur+=1a=nums[-1]if target>a:return self.s(nums[:cur], target)else:#return cur+self.s(nums[cur:],target)res=self.s(nums[cur:],target)if res==-1:return reselse:return cur+res

②官方题解：二分变体【迭代】

这个一方面可以理解为把那个寻找断点的操作集成到了二分里面，不过这也证明了二分所要求的“有序”，其实也没有那么死板；另一方面可以理解为二分的变种进化，有一种递归的感觉，但是答案使用的是迭代，不一定非要有序，只要最后最底层的那个是有序的就行。

class Solution(object):def search(self, nums, target):""":type nums: List[int]:type target: int:rtype: int"""left=0right=len(nums)-1while left<=right:mid=(left+right)//2if nums[mid]==target:return midif nums[left]<=nums[mid]:if nums[left]<=target<=nums[mid]:right=mid-1else:left=mid+1else:if nums[mid]<=target<=nums[right]:left=mid+1else:right=mid-1return -1

③自己仿写的：二分变体【递归】

class Solution(object):def search(self, nums, target):""":type nums: List[int]:type target: int:rtype: int"""if not nums:return -1mid=len(nums)//2if nums[mid]==target:return midif len(nums)==1 and nums[0]!=target:return -1if nums[mid]>=nums[0]:if nums[0]<=target<nums[mid]:return self.search(nums[:mid],target)else:res=self.search(nums[mid+1:],target)if res==-1:return reselse:return mid+1+resif nums[mid]<=nums[-1]:if nums[mid]<target<=nums[-1]:res=self.search(nums[mid+1:],target)if res==-1:return reselse:return mid+1+res               else:return self.search(nums[:mid],target)

3.4 整理几个关键点！！

当迭代时，用的就是while left<=right，使用双指针这样循环；当递归时，就是以下面那个作为终止条件：
```
if len(nums)==0:return -1
if len(nums)==1 and nums[0]!=target:return -1
```
用到递归时，如果要返回下标，涉及右半部分的时候要注意判断并加上上一步的mid（即得到的是相对坐标，要加上参考系坐标），可以使用如下方式：
```
res=self.search(nums[mid+1:],target)
if res==-1:return res
else:return mid+1+res
```