一、递归和分治基本的模式（代码）
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)