数据结构与算法(Python版) | (8) 递归(上)

本专栏主要基于北大的数据结构与算法教程(Python版)进行整理，包括课程笔记和OJ作业。

课程链接

1. 什么是递归

定义

• 递归是一种解决问题的方法，其精髓在于：
  1）将问题分解为规模更小的相同问题，
  2） 持续分解，直到问题规模小到可以用非常简单直接的方式来解决。
  3） 递归的问题分解方式非常独特，其算法方面的明显特征就是:在算法流程中调用自身。
• 递归为我们提供了一种对复杂问题的优雅解决方案，精妙的递归算法常会出奇简单 ，令人赞叹。

初识递归:数列求和

• 问题:给定一个列表，返回所有数的和：
  列表中数的个数不定，需要一个循环和一个累加 变量来迭代求和。
• 程序很简单，但假如没有循环语句?
  既不能用for，也不能用while。 还能对不确定长度的列表求和么?

def listsum(numList):
	theSum = 0
	for i in numList:
		theSum = theSum + i
	return theSum

• 我们认识到求和实际上最终是由一次次的加法实现的，而加法恰有2个操作数，这个是确定的。
• 看看怎么想办法，将问题规模较大的列表求和，分解为规模较小而且固定的2个数求和(加法)?
  同样是求和问题，但规模发生了变化，符合递归解决问题的特征!
• 换个方式来表达数列求和:全括号表达式 (1+(3+(5+(7+9))))
• 上面这个式子，最内层的括号(7+9)，这 是无需循环即可计算的，实际上整个求和 的过程是这样(每次只计算两个数的和):
  
• 观察上述过程中所包含的重复模式，可以把求和问题归纳成这样:
  数列的和=“首个数”+“余下数列”的和
• 如果数列包含的数少到只有1个的话，它的和就是这个数了
  这是规模小到可以做最简单的处理
  
• 上面的递归算法变成程序

def listsum(numList):
	if len(numList) == 1:  #最小规模
		return numList[0]
	else:
		return numList[0] + listSum(numList[1:]) #分解问题 减小规模（列表切片）； 调用自身。

• 要点
  1）问题分解为更小规模的相同问题，并表现为 “调用自身”
  2）对“最小规模”问题的解决:简单直接

递归程序如何被执行?

• 递归函数调用和返回过程的链条
  

递归“三定律”

• 为了向阿西莫夫的“机器人三定律”致敬 ，递归算法也总结出“三定律”
  1）递归算法必须有一个基本结束条件(最小规 模问题的直接解决)
  2）递归算法必须能改变状态向基本结束条件演 进(减小问题规模)
  3）递归算法必须调用自身(解决减小了规模的相同问题)

• 数列求和问题首先具备了基本结束条件: 当列表长度为1的时候，直接输出所包含的唯一数

• 数列求和处理的数据对象是一个列表，而基本结束条件是长度为1的列表，那递归算法就要改变列表并向长度为1的状态演进。
  我们看到其具体做法是将列表长度减少1。

• 调用自身是递归算法中最难理解的部分，实际上我们理解为“问题分解成了规模更小的相同问题”就可以了。
  在数列求和算法中就是“更短数列的求和问题”

2. 递归的应用:任意进制转换

整数转换为任意进制

• 这个在数据结构栈里讨论过的算法，又回来了!
  递归和栈，一定有关联

• 如果上次你被“入栈”“出栈”搞得挺晕乎的话，这次递归算法一定会让你感到清新
  而且这次我们要解决从二进制到十六进制的任意进制转换

• 我们用最熟悉的十进制分析下这个问题
  1）十进制有十个不同符号:convString = “0123456789”
  2）比十小的整数，转换成十进制，直接查表就可以 了:convString[n]
  3） 想办法把比十大的整数，拆成一系列比十小的整数，逐个查表：比如七百六十九，拆成七、六、九，查表得到 769就可以了。

• 所以，在递归三定律里，我们找到了“基 本结束条件”，就是小于十的整数
  拆解整数的过程就是向“基本结束条件”演进的 过程

• 我们用整数除，和求余数两个计算来将整数一步步拆开：
  1）除以“进制基base”(// base)
  2）对“进制基”求余数(% base)

• 问题就分解为:
  1）余数总小于“进制基base”，是“基本结束条件 ”，可直接进行查表转换
  2）整数商成为“更小规模”的相同问题，通过递归调用自身解决。
  

• 代码

def toStr(n,base):
convertString = "0123456789ABCDEF"
	if n<base:
		return covertString[n] #最小规模
	else:
		return toStr(n//base,base) + covertString[n%base] #减小规模，调用自身

3. 递归调用的实现

递归调用实现

• 当一个函数被调用的时候，系统会把调用时的现场数据压入到系统调用栈；每次调用，压入栈的现场数据称为栈帧；当函数返回时，要从调用栈的栈顶取得返回地址
  ，恢复现场，弹出栈帧，按地址返回（后进先出）。
  

Python中的递归深度限制

• 在调试递归算法程序的时候经常会碰到这样的错误:RecursionError
  递归的层数太多，系统调用栈容量有限
  
• 这时候要检查程序中是否忘记设置基本结 束条件，导致无限递归
  或者向基本结束条件演进太慢，导致递归层数太多，调用栈溢出。

def tell_story():
	print("从前有座山，山里有座庙，庙里有个老和尚，他在讲：")
	tell_story()
print("给你讲个故事")
tell_story()

• 在Python内置的sys模块可以获取和调整最大递归深度
  

递归的故事

4. 递归可视化:分形树

递归可视化:图示

• 前面的种种递归算法展现了其简单而强大 的一面，但还是难有个直观的概念
• 下面我们通过递归作图来展现递归调用的 视觉影像
• Python的海龟作图系统turtle module
  1）Python内置，随时可用，以LOGO语言的创意为 基础
  2）其意象为模拟海龟在沙滩上爬行而留下的足迹：
  爬行:forward(n); backward(n)
  转向:left(a); right(a)
  抬笔放笔:penup(); pendown()
  笔属性:pensize(s); pencolor©
• 示例代码

import turtle
t = turtle.Turtle()

#开始做图
t.forward(100) #前行100 （默认向右）
turtle.done() #作图结束

import turtle

t = turtle.Turtle()

for i in range(4):
	t.forward(100) #当前方向前进100
	t.right(90) #右转90度
turtle.done()

import turtle

t = turtle.Turtle()

t.pencolor('red')
t.pensize(3) 

for i in range(5):
	t.forward(100) #当前方向前进100
	t.right(144) #右转144度
t.hideturtle()
turtle.done()

一个递归作图的例子:螺旋

import turtle
t = turtle.Turtle()

def drawSpiral(t,linelen):
	if linelen > 0: #最小规模，0直接退出
		t.forward(linelen)
		t.right(90)
		drawSpiral(t,linelen-5)   #减小规模 长度-5 调用自身
drawSpiral(t,100)

turtle.done()

分形树:自相似递归图形

• 分形Fractal，是1975年由Mandelbrot 开创的新学科
  “一个粗糙或零碎的几何形状，可以分成数个部 分，且每一部分都(至少近似地)是整体缩小后 的形状”，即具有自相似的性质。
  
• 自然界中能找到众多具有分形性质的物体
  海岸线、山脉、闪电、云朵、雪花、树
  http://paulbourke.net/fractals/googleearth/
  http://recursivedrawing.com/
  

自然界不是平滑的

分形树:自相似递归图形

• 自然现象中所具备的分形特性，使得计算机可以通过分形算法生成非常逼真的自然场景(如游戏中的场景)
• 分形是在不同尺度上都具有相似性的事物
  我们能看出一棵树的每个分叉和每条树枝，实际 上都具有整棵树的外形特征(也是逐步分叉的)
• 这样，我们可以把树分解为三个部分:树 干、左边的小树、右边的小树（左右小树，又可以分为树干，左边的小小树，右边的小小树…）
  分解后，正好符合递归的定义:对自身的调用
  
• 代码

import turtle

def tree(branch_len):
	if branch_len > 5: #树干长度<=5就不再继续画了 即递归结束条件
		t.forward(branch_len) #画树干 
		t.right(20) #右倾斜20度
		tree(branch_len - 15) #画右边的小树 树干长度-15
		t.left(40) #向左回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) #画树干长度75的二叉树
t.hideturtle()
turtle.done()

5. 递归可视化:谢尔宾斯基三角形

谢尔宾斯基Sierpinski三角形

• 分形构造，平面称谢尔宾斯基三角形，立体称谢尔宾斯基金字塔
  实际上，真正的谢尔宾斯基三角形是完全不可见 的，其面积为0，但周长无穷，是介于一维和二 维之间的分数维(约1.585维)构造。(谢尔宾斯基金字塔体积为0，表面积无穷)
  

谢尔宾斯基三角形:作图思路

• 根据自相似特性，谢尔宾斯基三角形是由 3个尺寸减半的谢尔宾斯基三角形按照品字形拼叠而成。
  由于我们无法真正做出谢尔宾斯基三角形( degree->∞，看不到了)，只能做degree有限的近似图形。
  

• 在degree有限的情况下，degree=n的三角形，是由3个degree=n-1的三角形按照品字形拼叠而成。
  同时，这3个degree=n-1的三角形边长均为 degree=n的三角形的一半(规模减小)。
  当degree=0，则就是一个等边三角形，这是递 归基本结束条件

• 代码

import turtle
def sierpinski(degree,points):
	colormap = ['blue','red','green','white','yellow','orange']
	drawTriangle(points,colormap[degree]) #绘制等边三角形 points字典 存储三个顶点坐标
	if degree > 0: #最小规模 0 直接退出；结束条件
		#减小规模 getMid边长减半（原来的两个顶点取中点）
		#调用自身 左、上、右次序
		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.up()
    t.goto(points['top'])
    t.down()
    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)

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

6. 递归的应用:汉诺塔

复杂递归问题:汉诺塔

• 汉诺塔问题是法国数学家Edouard Lucas于 1883年，根据传说提出来的。
• 传说在一个印度教寺庙里，有3根柱子，其中 一根套着64个由小到大的黄金盘片，僧侣们 的任务就是要把这一叠黄金盘从一根柱子搬 到另一根，但有两个规则:
  1）一次只能搬1个盘子
  2）大盘子不能叠在小盘子上
• 神的旨意说一旦这些盘子完成迁移：寺庙将会坍塌，世界将会毁灭…神的旨意是千真万确的!

汉诺塔问题

• 虽然这些黄金盘片跟世界末日有着神秘的联系，但我们却不必太担心，据计算，要搬完这64个盘片（宇宙至今的寿命才170亿年）:
  
• 我们还是从递归三定律来分析汉诺塔问题
  基本结束条件(最小规模问题)，如何减小规模，调用自身

汉诺塔问题:分解为递归形式

• 假设我们有5个盘子，穿在1#柱，需要挪 到3#柱
  1）如果能有办法把最上面的一摞4个盘子统统挪到 2#柱，那问题就好解决了:
  2）把剩下的最大号盘子直接从1#柱挪到3#柱
  3）再用同样的办法把2#柱上的那一摞4个盘子挪到3#柱，就完成了整个移动
  

汉诺塔问题:分析

• 接下来问题就是解决4个盘子如何能从1# 挪到2#?
  1）此时问题规模已经减小!
  2）同样是想办法把上面的一摞3个盘子挪到3#柱，
  3）把剩下最大号盘子从1#挪到2#柱，
  4）再用同样的办 法把一摞3个盘子从3#挪到2#柱
• 一摞3个盘子的挪动也照此:分为上面一摞2个，和下面最大号盘子
• 那么2个盘子怎么移动?
• 不行，就再分解为1个盘子的移动（直接移动即可）

汉诺塔问题:递归思路

• 将盘片塔从开始柱，经由中间柱，移动到 目标柱:
  1）首先将上层N-1个盘片的盘片塔，从开始柱，经由目标柱，移动到中间柱;
  2）然后将第N个(最大的)盘片，从开始柱，（直接）移动到目标柱;
  3）最后将放置在中间柱的N-1个盘片的盘片塔，经 由开始柱，移动到目标柱。

• 基本结束条件，也就是最小规模问题是:1个盘片的移动问题

• 代码（ 上面的思路用Python写出来，几乎跟语 言描述一样）

def moveTower(height,fromPole,withPole,toPole):
	if height >=1:
		moveTower(height-1,fromPole,toPole,withPole)
		moveDisk(height,fromPole,toPole)
		moveTower(height-1,withPole,fromPole,toPole)

def moveDisk(disk,fromPole,toPole):
	print(f"Moving Disk[{disk}] from {fromPole} to {toPole}") #格式化字符串

moveTower(3,"#1","#2","#3")

7. 递归的应用:探索迷宫

探索迷宫

• 将海龟放在迷宫中间，如何能找到出口
• 首先，我们将整个迷宫的空间(矩形)分 为行列整齐的方格，区分出墙壁和通道。
  给每个方格具有行列位置，并赋予“墙壁”、“ 通道”的属性

迷宫的数据结构

• 考虑用矩阵方式来实现迷宫数据结构

1. 采用“数据项为字符列表的列表”这种两级列表 的方式来保存方格内容
2. 采用不同字符来分别代表“墙壁+”、“通道(空格)” 、“海龟投放点S”
   3）可以在一个文本文件中编辑一个迷宫，然后再从文本文件逐行读入迷宫数据

• Maze Class

class Maze:
	def __init__(self,mazeFileName):
		rowsInMaze = 0
		columnsInMaze = 0
		self.mazelist = []
		mazeFile = open(mazeFileName,'r')
		for line in mazeFile: #遍历每一行
			rowList = []
			col = 0
			for ch in line[:-1]: #遍历每一行字符列表中的每个字符（：-1 除去末尾换行符）
				rowList.append(ch)
				if ch == 'S':
					self.startRow = rowsInMaze
					self.startCol = col
				col = col + 1
			rowsInMaze = rowsInMaze + 1
			self.mazelist.append(rowList)
			columnsInMaze = len(rowList)

• 读入数据文件成功后
  mazelist如下图示意:
  

探索迷宫:算法思路

• 确定了迷宫数据结构之后，我们知道，对 于海龟来说，其身处某个方格之中

1. 它所能移动的方向，必须是向着通道的方向
2. 如果某个方向是墙壁方格，就要换一个方向移动
   

• 这样，探索迷宫的递归算法思路如下:

1. 将海龟从原位置向北移动一步，以新位置递归调 用探索迷宫寻找出口;
2. 如果上面的步骤找不到出口，那么将海龟从原位置向南移动一步，以新位置递归调用探索迷宫;
3. 如果向南还找不到出口，那么将海龟从原位置向西移动一步，以新位置递归调用探索迷宫;
4. 如果向西还找不到出口，那么将海龟从原位置向东移动一步，以新位置递归调用探索迷宫;
5. 如果上面四个方向都找不到出口，那么这个迷宫 没有出口!

• 思路看起来很完美，但有些细节至关重要

1. 如果我们向某个方向(如北)移动了海龟，那么 如果新位置的北正好是一堵墙壁，那么在新位置 上的递归调用就会让海龟向南尝试
2. 可是新位置的南边一格，正好就是递归调用之前的原位置，这样就陷入了无限递归的死循环之中
   

• 所以需要有个机制记录海龟所走过（探索过）的路径
  沿途洒“面包屑”，一旦前进方向发现“面包屑 ”，就不能再踩上去，而必须换下一个方向尝试
  对于递归调用来说，就是某方向的方格上发现“面包屑”，就立即从递归调用返回上一级。

• 递归调用的“基本结束条件”归纳如下:
  1）海龟碰到“墙壁”方格，递归调用结束，返回失 败;
  2）海龟碰到“面包屑”方格，表示此方格已访问过，递归调用结束，返回失败;
  3）海龟碰到“出口”方格，即“位于边缘的通道”方格，递归调用结束，返回成功!
  4） 海龟在四个方向上探索都失败，递归调用结束，返回失败

探索迷宫:辅助的动画过程

• 为了让海龟在迷宫图里跑起来，我们给迷宫数据结构Maze Class添加一些成员和方法
  
• 探索函数

def searchFrom(maze,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.isExit(startRow,startColumn):
		maze.updatePosition(startRow,startColumn,PART_OF_PATH)
		return True
	
	#4. 洒一下面包屑，继续探索
	maze.updatePosition(startRow,startColumn,TRIED)
	
	#向北南西东4个方向依次探索 or具有短路效应（第一个表达式为True其余表达式都不会计算，第一个为False时，才会计算第二个...）
	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

• 完整代码

import turtle

PART_OF_PATH = 'O'
TRIED = '.'
OBSTACLE = '+'
DEAD_END = '-'

class Maze:
    def __init__(self,mazeFileName):
        rowsInMaze = 0
        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':
                    self.startRow = rowsInMaze
                    self.startCol = col
                col = col + 1
            rowsInMaze = rowsInMaze + 1
            self.mazelist.append(rowList)
            columnsInMaze = len(rowList)

        self.rowsInMaze = rowsInMaze
        self.columnsInMaze = columnsInMaze
        self.xTranslate = -columnsInMaze/2
        self.yTranslate = rowsInMaze/2
        self.t = turtle.Turtle()
        self.t.shape('turtle')
        self.wn = turtle.Screen()
        self.wn.setworldcoordinates(-(columnsInMaze-1)/2-.5,-(rowsInMaze-1)/2-.5,(columnsInMaze-1)/2+.5,(rowsInMaze-1)/2+.5)

    def drawMaze(self):
        self.t.speed(10)
        for y in range(self.rowsInMaze):
            for x in range(self.columnsInMaze):
                if self.mazelist[y][x] == OBSTACLE:
                    self.drawCenteredBox(x+self.xTranslate,-y+self.yTranslate,'orange')
        self.t.color('black')
        self.t.fillcolor('blue')

    def drawCenteredBox(self,x,y,color):
        self.t.up()
        self.t.goto(x-.5,y-.5)
        self.t.color(color)
        self.t.fillcolor(color)
        self.t.setheading(90)
        self.t.down()
        self.t.begin_fill()
        for i in range(4):
            self.t.forward(1)
            self.t.right(90)
        self.t.end_fill()

    def moveTurtle(self,x,y):
        self.t.up()
        self.t.setheading(self.t.towards(x+self.xTranslate,-y+self.yTranslate))
        self.t.goto(x+self.xTranslate,-y+self.yTranslate)

    def dropBreadcrumb(self,color):
        self.t.dot(10,color)

    def updatePosition(self,row,col,val=None):
        if val:
            self.mazelist[row][col] = val
        self.moveTurtle(col,row)

        if val == PART_OF_PATH:
            color = 'green'
        elif val == OBSTACLE:
            color = 'red'
        elif val == TRIED:
            color = 'black'
        elif val == DEAD_END:
            color = 'red'
        else:
            color = None

        if color:
            self.dropBreadcrumb(color)

    def isExit(self,row,col):
        return (row == 0 or
                row == self.rowsInMaze-1 or
                col == 0 or
                col == self.columnsInMaze-1 )

    def __getitem__(self,idx):
        return self.mazelist[idx]


def searchFrom(maze, startRow, startColumn):
    # try each of four directions from this point until we find a way out.
    # base Case return values:
    #  1. We have run into an obstacle, return false
    maze.updatePosition(startRow, startColumn)
    if maze[startRow][startColumn] == OBSTACLE :
        return False
    #  2. We have found a square that has already been explored
    if maze[startRow][startColumn] == TRIED or maze[startRow][startColumn] == DEAD_END:
        return False
    # 3. We have found an outside edge not occupied by an obstacle
    if maze.isExit(startRow,startColumn):
        maze.updatePosition(startRow, startColumn, PART_OF_PATH)
        return True
    maze.updatePosition(startRow, startColumn, TRIED)
    # Otherwise, use logical short circuiting to try each direction
    # in turn (if needed)
    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


myMaze = Maze('maze2.txt')
myMaze.drawMaze()
myMaze.updatePosition(myMaze.startRow,myMaze.startCol)

searchFrom(myMaze, myMaze.startRow, myMaze.startCol)

迷宫文件maze2.txt