递归和分治

一、递归和分治基本的模式（代码）

1、递归

def recursion(self,level,param1,param2,...):

　　# 递归终止条件（base case）

　　if level > MAX_LEVEL:

　　　　print result

　　　　return

 

　　# 处理当前level需要处理的逻辑

　　process_data(level,data,...)

 

　　# 递归到下一个level

　　self.recursion(level+1,new_param1,new_param2,...)

 

　　# 返回当前level的状态（视情况，可能需要，可能不需要）

 

 

2、分治 （divide and conquer）：将一个大问题分解问若干个容易处理的小问题，分别解决

class Solution(object):

　　# 分治，一般都有一个待处理的问题----problem

　　def divide_conquer(self,problem,param1,param2,...):

　　　　# 终止条件

　　　　if problem == None:

　　　　　　print_result

　　　　　　return

　　

　　　　# 准备数据，将problem切分为子问题

　　　　data = prepare_data()

　　　　subProblems = split_problem(problem,data)

　　　　

　　　　# 分别的处理子问题

　　　　subResult1 = self.divide_conquer(subProblem1,new_param1,...)

　　　　subResult2 = self.divide_conquer(subProblem2,new_param1,...)　

　　　　......

 

　　　　# 处理 并 生成最终的结果

　　　　result = process_result(subResult1,subResult2,...)

二、举例

 

1、求pow(x,n) ,x的n次方。

暴力循环：

class Solution(object):

　　def pow(self,x,n):

　　　　if n==0:

　　　　　　return 1

　　　　if n<0:

　　　　　　x = 1/x

　　　　　　n = -n

　　　　pow = 1

　　　   while n:

　　　　　　pow *= x

　　　　return x

时间复杂度：O(n)

空间复杂度：O(1)

分治加递归：

class Solution(object):

　　def pow(self,x,n):

　　　　#终止条件，如果n为0，则返回1

　　　　if not n:

　　　　　　return 1

　　　　# 如果n为负数，则计算倒数，并将n变为正数

　　　　if n < 0:

　　　　　　return 1/pow(x,-n)

 

　　　　# n为奇数，则增加一次递归

　　　　if n % 2:

　　　　　　return x*self.pow(x,n-1)

 

　　　　# n为偶数，则分解为两个相等的子问题，计算(x**(n/2)) * (x**(n/2))

　　　　return self.pow(x*x,n/2)

时间复杂度：O(logn)

空间复杂度：O(logn)

循环：

class Solution(object):

　　def pow(self,x,n):

　　　　if x == 0:

　　　　　　return 0

　　　　if n<0:

　　　　　　x = 1/x

　　　　　　n = -n

　　　　pow = 1

　　　　while n:

　　　　　　# n为奇数的情况

　　　　　　if n & 1:

　　　　　　　　pow *= x

　　　　　　# n为偶数，x加倍，n减半

　　　　　　x*=x

　　　　　　n >>1

　　　　return pow

时间复杂度:O(logn)

空间复杂度：O(1)