Python递归 迷宫 python递归讲解

1、什么是递归

首先递归是一种解决问题的方法，其精髓在于将问题分解为规模更小的相同问题。我们将问题持续分解，知道问题规模小到可以用非常简单直接的方式来解决。递归的问题分解方式十分独特，其算法方面的明显特征就是：在算法流程中调用自身

2、递归算法三要素

A、递归算法必须有一个基本结束条件（即最小规模问题的直接解决）
B、递归算法必须能改变状态（向基本结束条件演讲即见效问题规模）
C、递归算法必须调用自身（解决见笑了规模的相同问题）

3、递归实战

----列表求和问题

def SUM(mylist):
    if len(mylist)==1:#递归结束条件，如果数列最后只剩下一个数就返回这个列表的第一个数（也就是这个数）
        return mylist[0]
    else:
        return mylist[0]+SUM(mylist[1:])#将列表求和问题转化为第一个数和剩下数的和的问题，从而不断调用自身实现递归求和
if __name__ == '__main__':
    print(SUM([1,3,5,7,9]))

----整数转换为任意进制问题

上图为转换过程。比如我们将整数转化为十进制数（代码可以实现整数转化为任意进制，这里只是举例）我们将需要转换的整数不断地整除10并且每次保留整数和10的余数，直到最后数字小于十，符合递归结束的条件。当然我们这里还要认为的创建一个字符串用来保留。具体代码如下

def zhuanhuan(num,base):
    mystring="0123456789ABCDEF"
    if num<base:
        return mystring[num]
    else:
        return zhuanhuan(num//base,base)+mystring[num%base]
if __name__ == '__main__':
    print(zhuanhuan(100,16))

----利用递归画树叶

import turtle
def tree(len):
    if len>5:#递归结束条件，树干太短就不画
        turtle.forward(len)#画树干
        turtle.right(20)#右转20度
        tree(len-15)#递归调用画右边的小树，树干-15
        turtle.left(40)#向左回40度，即向左倾斜20度
        tree(len-15)#递归调用，花左边的小树，树干-15
        turtle.right(20)#回正
        turtle.backward(len)#海龟退回原位
if __name__ == '__main__':
    turtle.left(90)
    turtle.penup()
    turtle.backward(300)
    turtle.pendown()
    turtle.pensize(2)
    turtle.pencolor("green")
    tree(125)
    turtle.hideturtle()
    turtle.done()

效果如上所示

----谢尔宾斯三角形的递归应用

import turtle as t
def traingle(points,color):
    t.fillcolor(color)
    t.penup()
    t.goto(points["top"])
    t.pendown()
    t.begin_fill()
    t.goto(points["left"])
    t.goto(points["right"])
    t.goto(points["top"])
    t.end_fill()
def getMid(p1,p2):
    return ((p1[0]+p2[0])/2,(p1[1]+p2[1])/2)

def sierpinski(degree,points):
    colormap=['blue','red','green','white','yellow','orange']
    traingle(points,colormap[degree])
    if degree>0:
        sierpinski(degree-1,
                   {
                       'left':points['left'],
                       'top':getMid(points['left'],points['top']),
                       'right':getMid(points['left'],points['right'])
                   })
        sierpinski(degree - 1,
                   {
                       'left': getMid(points['left'],points['top']),
                       'top': points['top'],
                       'right': getMid(points['top'], points['right'])
                   })
        sierpinski(degree - 1,
                   {
                       'left': getMid(points['left'],points['right']),
                       'top': getMid(points['top'], points['right']),
                       'right':  points['right']
                   })
if __name__ == '__main__':
    points = {'left': (-200, -100),
              'top': (0, 200),
              'right': (200, -100)}
    sierpinski(5,points)
    t.done()

–汉诺塔问题

def han_nuo_ta_1(height,frompole,withpole,topole):
    if height>=1:
        han_nuo_ta_1(height-1,frompole,withpole,topole)
        han_nuo_ta_2(height,frompole,topole)
        han_nuo_ta_1(height-1,withpole,frompole,topole)
def han_nuo_ta_2(disk,frompole,topole):
    print("Moving disk[{}] from {} to {}".format(disk,frompole,topole))
if __name__ == '__main__':
    han_nuo_ta_1(10,"#1","#2","#3")

思路：首先将上层N-1个盘片的盘片塔，从开始柱，经由目标柱，移动到中间柱；然后将第N个（最大的盘片）从开始柱，移动到目标柱；最后将放置在中间柱的N-1个盘片的盘片塔，由开始柱，移动到目标柱