数据结构与算法（11）—递归

• 递归问题

将问题分解为更小的相同问题——>用非常简单直接地方式解决——>调用自身。

例子：数列求和问题

def listsum(numList):
    if len(numList) ==1:
        return numList[0]
    else:
        return numList[0] + listsum(numList[1:]) #送进去listsum的是一个list
print(listsum([1,2,3,4,5,9]))

• 递归三定律

1.递归算法必须有一个基本结束条件

2.递归算法必须能改变状态向基本结束条件演进（减小问题规模）

3.递归算法必须调用自身

• 递归应用

　　1.整数任意进制转换

def toStr(n,base):
    '''
    :param n: 要转换的十进制整数
    :param base: 转换成的n进制
    :return: 转换结果
    '''
    convertString = '0123456789ABCDEF'
    if n < base:
        return convertString[n]
    else:
        return toStr(n//base, base) + convertString[n%base]
print(toStr(76989,16))

　注：这里需要理解下递归的调用时依赖栈的。如toStr函数，当每次调用递归函数，toStr(n)入栈，但此时还没返回，最先入栈的在栈底，最后入栈的在栈顶。 最先返回的是toStr(1)，此时调用顺序和返回顺序是相反的。

即：每次调用，压入栈的现场数据为栈帧，当函数返回时，要从调用栈的栈顶取得返回地址，恢复现场，弹出栈帧，按地址返回。

　　2.递归作图

import turtle
#画箭头
t = turtle.Turtle()
t.forward(100)
turtle.done()

#画正方形
for i in range(4):
    t.forward(100)
    t.right(90)
turtle.done()

#画五角星
t = turtle.Turtle()
t.pencolor('red')
t.pensize(3)
for i in range(5):
    t.forward(100) #长度
    t.right(144) #右转角144°
t.hideturtle()
turtle.done()

t = turtle.Turtle()
def drawSpiral(t,lineLen):
    '''
    画螺旋，从外向内画
    '''
    if lineLen > 0:
        t.forward(lineLen)
        t.right(90)#右转90°
        drawSpiral(t, lineLen - 5)
drawSpiral(t, 100)
turtle.done()

　　3.画分形树

def tree(branch_len):
    if branch_len > 5:#树干太短不画
        t.forward(branch_len) #画树干
        t.right(20) #右倾斜20°
        tree(branch_len - 15) #画右小树，树干减15
        t.left(40) #向左倾斜20°
        tree(branch_len - 15) #画左小树，树干减15
        t.right(20) #向右回20°，回正
        t.backward(branch_len) #海龟退回原位置
t = turtle.Turtle()
t.left(90)
t.penup()
t.backward(100)
t.pendown()
t.pencolor('green')
t.pensize(2)
tree(75)
t.hideturtle()
turtle.done

 注：分形树对于我来说挺难理解的，全靠debug帮我理清逻辑，首先一定要记住递归函数栈的进栈顺序和函数调用顺序，这里很关键。

　　4.谢尔宾斯基三角形

 就长这个样子，自己领会吧。它是由3个尺寸减半的谢尔宾斯基三角形按照品字形状叠拼起来的。

 画谢尔宾斯基三角形代码：

import turtle

def sierpinski(degree, points):
    colormap= ['blue','red','green','white','yellow','orange']
    drawTriangle(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']})
# 绘制填充等边三角形
def drawTriangle(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) #((x1+x2)/2,(y1+y2)/2)

t = turtle.Turtle()

points = {'left':(-200,-100),#外轮廓三个顶点坐标
          'top':(0,200),
          'right':(200,-100)}
sierpinski(5,points) #画5阶三角形
turtle.done()

效果图：

 　　5.汉诺塔问题

问题表述是这样的：（懒得码字，直接截图啦）

 如果说要把64个盘片搬完，需要2^64 -1=18 446 744 073 709 551 615次。

首先先看下3个大中小盘，3根柱子，初始在1号柱，挪动方法：首先将小盘挪到3号柱子，中盘挪到2号柱，再将在3号的小盘挪到2号中盘上，再将1号大盘挪到3号柱，再将2号小盘挪到1号柱，再将2号重盘挪到3号柱，最后将1号小盘挪到3号柱，则完成。

对于有4个盘子，3根柱子问题可以考虑先将上面3个挪到2号柱，再将第4个挪到3号柱。

对于有5个盘子，3根柱子问题则考虑现将上面4个挪到2号柱，再将第5个挪到3号柱。

可以看到，这其实就是个递归问题。

将盘片从开始柱，经由中间柱，移动到目标柱的解决思路：

(1)将上层N-1个盘子的从开始柱(fromPole)，经由目标柱(toPole)，移动到中间柱(withPole)；

(2)将第N个(最大的那个)，从开始柱(fromPole)，移动到目标柱(toPole)；

(3)将放置在中间柱N-1个盘子的盘子塔，从中间柱(withPole)，经由开始柱(fromPole)，移动到目标柱(toPole)。

(4)递归

看下代码：

def moveTower(height,fromPole,withPole,toPole):
    '''
    :param height: 汉诺塔高度
    :param fromPole: 起始移动所在柱子
    :param withPole:中间柱子
    :param toPole:目的柱子
    :return:
    '''
    if height >=1:
        moveTower(height-1,fromPole,toPole,withPole)
        moveDisk(height,fromPole,toPole)
        moveTower(height-1,withPole,fromPole,toPole)
#直接从fromPole到toPole
def moveDisk(disk,fromPole,toPole):
    print(f'moving disk[{disk}] from {fromPole} to {toPole}')

moveTower(5,'#1','#2','#3')

运行结果：

moving disk[1] from #1 to #3
moving disk[2] from #1 to #2
moving disk[1] from #3 to #2
moving disk[3] from #1 to #3
moving disk[1] from #2 to #1
moving disk[2] from #2 to #3
moving disk[1] from #1 to #3
moving disk[4] from #1 to #2
moving disk[1] from #3 to #2
moving disk[2] from #3 to #1
moving disk[1] from #2 to #1
moving disk[3] from #3 to #2
moving disk[1] from #1 to #3
moving disk[2] from #1 to #2
moving disk[1] from #3 to #2
moving disk[5] from #1 to #3
moving disk[1] from #2 to #1
moving disk[2] from #2 to #3
moving disk[1] from #1 to #3
moving disk[3] from #2 to #1
moving disk[1] from #3 to #2
moving disk[2] from #3 to #1
moving disk[1] from #2 to #1
moving disk[4] from #2 to #3
moving disk[1] from #1 to #3
moving disk[2] from #1 to #2
moving disk[1] from #3 to #2
moving disk[3] from #1 to #3
moving disk[1] from #2 to #1
moving disk[2] from #2 to #3
moving disk[1] from #1 to #3

Process finished with exit code 0

　　6.递归可视化，探索迷宫

迷宫的数据结构：用矩阵方式来实现。

class Maze:
    def __init__(self,mazeFileName):
        columnsInmaze = 0
        self.mazelist = []
        mazeFile = open(mazeFileName,'r')
        rowsInMaze = 0
        for line in mazeFile:
            rowList = []
            col = 0
            for ch in line[:-1]:
                rowList.append(ch)
                if ch == 's': #海龟投放点S
                    self.startRow = rowsInMaze
                    self.startCo = col
                col = col+1
            rowsInMaze = rowsInMaze + 1
            self.mazelist.append(rowList)
            columnsInmaze = len(rowList)
maze = Maze('maze.txt')

探索思路为：将海龟从原位置向北移东一步，以新位置递归调用探索迷宫寻找出口，并边走边洒面包屑，如果向北找不到出口，则海龟从原始位置向南移动，更新迷宫位置，如向南找不到出口，则从原始位置向西移动一步，更新迷宫位置，如向西找不到出口，则从原始位置向东移动一步，如果都找不到，则迷宫没有出口，但如果一旦发现某前进方格上有面包屑，则立即从递归调用返回上一级。

递归结束的基本条件为：

海龟碰到墙壁方格，递归调用结束，返回失败；

海龟碰到面包屑方格，递归调用结束，返回失败；

海龟碰到出口方格，递归调用结束，返回成功；

海龟在四个方向上探索都失败，递归调用结束，返回失败。

探索迷宫的核心代码：

def searchFrom(selfmaze,startRow,startColumn):
        #1.碰到墙壁，返回失败
        maze.updatePosition(startRow,startColumn)
        if maze[startRow][startColumn] == OBSTACLE:
            return False
        #2.碰到面包屑，或者死胡同，返回失败
        if maze[startRow][startColumn] == TRIED or maze[startRow][startColumn] == DEAD_END
            return False
        #3.碰到了出口，返回成功
        if maze.isExis(startRow,startColumn):
            maze.updatePosition(startRow,startColumn,TRIED)
        #4.洒面包屑，继续探索
        maze.uodataPosition(startRow,startColumn,TRIED)

        #向北南东4个方向依次探索，or操作符具有短路效应
        found = searchFrom(maze, startRow-1, startColumn) or
            searchFrom(maze, startRow+1, startColumn) or
            searchFrom(maze, startRow, startColumn-1) or
            searchFrom(maze, startRow, startColumn+1)
        if found:
            maze.updatePosition(startRow,startColumn,PART_OF_PATH)
        else:
            maze.updatePosition(startRow,startColumn,DEAD_END)
        return found