1 # 阶乘
 2 
 3 def jiecheng(n):
 4    if n <= 1:
 5       return 1
 6    return jiecheng(n-1) * n 
 7 
 8 print(jiecheng(5))
 9 
10 
11 # 阶乘_尾递归
12 def jiecheng(n, val):
13     if n == 1:
14         return val
15     return jiecheng(n-1, val*n)
16 
17 res = jiecheng(5, 1)
18 print(res)

 1 # 斐波那契
 2 def fbnq(n):
 3     # 第一个数和第二个数是1
 4     if n == 1 or n == 2:
 5         return 1
 6     # 返回上一个数加上上上个数
 7     return fbnq(n-1) + fbnq(n-2)
 8     
 9 
10 # 斐波那契_尾递归
11 def fbnq(n, tem, total):
12    if n == 1:
13       return tem
14    return fbnq(n-1, total, tem+total)

 1 ‘‘‘
 2 一只青蛙要跳上n层高的台阶
 3 一次能跳一级,也可以跳两级
 4 请问这只青蛙有多少种跳上这个n层高台阶的方法?
 5 ‘‘‘
 6 
 7 
 8 def tiao(n):
 9    # 当n为1 的时候只有一种方法条台阶
10    if n == 1:
11       return 1
12    # 当n为2 的时候有两种方法上台阶 
13    if n == 2:
14       return 2
15    # 与斐波那契相似, 这次台阶的次数是:上次台阶的次数加上上次台阶的次数
16    return tiao(n-2) + tiao(n-1)
17 
18 print(tiao(6))

‘‘‘
底层递归反转字符串 "将14235 反转成53241"
‘‘‘

def fanzhuan(s):
   if len(s) == 0:
      return s
   else:
      # s[1:]传入下个递归函数, s[0]保留在本层递归函数
      # 等递归开始return, 内层递归依次+=外层递归的s[0], 实现反转
      return fanzhuan(s[1:]) + s[0]

      
      
# 翻转字符串_尾递归
# s: 需要翻转的字符串
# re_s: 递归结束后return的翻转字符

def fanzhuan(s, re_s=‘‘):

    # 如果传入的str长度为0, 证明str已经被翻转完毕, 返回re_s
    if len(s) <= 0:
        return re_s
        
    # 除最后一个外, 其余字符串全部传入下层递归函数
    # 本层最后一个str与上一层函数最后一个str相加
    return fanzhuan(s[:-1], re_s+s[-1])

print(fanzhuan(‘abdce‘))


def fanzhuan(s):
    # 传入的str长度为0返回空str, 等待 += 上层的s[0]
    if len(s) <= 0:
        return ‘‘
    # 切片除第一个str外都传入下层递归函数, 
    # 然后等待下层递归函数返回 += s[0]
    return fanzhuan(s[1:]) + s[0]
    
print(fanzhuan(‘abcdef‘))

 1 ‘‘‘
 2 猴子吃桃
 3 并吃了一半,又多吃了一个
 4 又将剩下的桃吃一半,又多吃了一个
 5 都吃了剩下的一半又多一个
 6 到了第10天早上在吃时,却发现只剩下一个桃
 7 问!第一天共摘了多少?
 8 ‘‘‘
 9 
10 def houzi(day):
11     # 如果是第十天就返回1(1个桃子)
12     if day == 10:
13         return 1
14     else:
15         return (houzi(day+1) +1) * 2
16         
17         
18 def houzi(day, n):
19     if day == 1:
20         return n
21     else:
22         return houzi(day-1, (n+1)*2)