《算法图解》学习笔记(三):递归和栈(附代码)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/TeFuirnever/article/details/100540898

python学习之路 - 从入门到精通到大师

递归——一种优雅的问题解决方法,定义是 在运行过程中调用自己。它将人分成三个截然不同的阵营:恨它的、爱它的以及恨了几年后又爱上它的,一般都是第一个,哈哈,就是这么真实。

一、递归

看一个例子,假设你在祖母的阁楼中翻箱倒柜,发现了一个上锁的神秘手提箱。
在这里插入图片描述
祖母告诉你,钥匙很可能在下面这个盒子里。
在这里插入图片描述
这个盒子里有盒子,而盒子里的盒子又有盒子。但是已经确定的是钥匙就在某个盒子中。为找到钥匙,你将使用什么算法?

方法一:
在这里插入图片描述
(1) 创建一个要查找的盒子堆。

(2) 从盒子堆取出一个盒子,在里面找。

(3) 如果找到的是盒子,就将其加入盒子堆中,以便以后再查找。

(4) 如果找到钥匙,则大功告成!

(5) 回到第二步。

方法二:
在这里插入图片描述
(1) 检查盒子中的每样东西。

(2) 如果是盒子,就回到第一步。

(3) 如果是钥匙,就大功告成!

这两种方法哪一个更容易呢?

  • 第一种方法使用的是while循环:只要盒子堆不空,就从中取一个盒子,并在其中仔细查找。伪代码如下:
def look_for_key(main_box):
	pile = main_box.make_a_pile_to_look_through()
	while pile is not empty:
		box = pile.grab_a_box()
		for item in box:
			if item.is_a_box():
				pile.append(item)
			elif item.is_a_key():
				print("found the key!")
  • 第二种方法使用递归——函数调用自己。伪代码如下:
def look_for_key(box):
	for item in box:
		if item.is_a_box():
			look_for_key(item)
		elif item.is_a_key():
			print("found the key!")

这两种方法的作用相同,实现的功能也是相同的。但第二种方法,即递归,要更清晰一些。递归只是让解决方案更清晰,并没有性能上的优势。 实际上,在有些情况下,使用循环的性能更好。但是 Leigh Caldwell 在 Stack Overflow 上说的一句话:“如果使用循环,程序的性能可能更高;如果使用递归,程序可能更容易理解。如何选择要看什么对你来说更重要。

很多算法都使用了递归,因此理解这种概念很重要。

二、基线条件和递归条件

由于递归函数调用自己,因此编写这样的函数时很容易出错,进而导致无限循环。例如,假设你要编写一个像下面这样倒计时的函数。

> 3...2...1

为此,你可以用递归的方式编写,如下所示。

def countdown(i):
	print(i)
	countdown(i-1)

print(countdown(2))

如果你运行上述代码,将发现一个问题:这个函数运行起来没完没了!!!这谁顶得住啊,多跑一会,估计你的电脑直接死机。。。哈哈

不过pycharm上会自动停止的 😃
在这里插入图片描述

在这里插入图片描述
> 3...2...1...0...-1...-2...

编写递归函数时,必须告诉它何时停止递归。正因为如此,每个递归函数都有两部分:基线条件(base case)递归条件(recursive case)。递归条件指的是函数调用自己,而基线条件则指的是函数不再调用自己,从而避免形成无限循环。基线条件很重要!基线条件很重要!!基线条件很重要!!!重要的事情说三遍。

我们来给函数countdown添加基线条件。

python版本代码如下:

def countdown(i):
	print(i)
	# 基本的情况
	if i <= 0:
		return
	# 递归的情况
	else:
		countdown(i-1)

print(countdown(2))

在这里插入图片描述

c++版本代码如下:

#include <iostream>

using std::cout;
using std::endl;

void countdown(const int& i) {
    cout << i << endl;
    
    // base case
    if (i <= 0) return;\
    
    // recursive case
    countdown(i - 1);
}

int main() {
    countdown(5);
}

现在,这个函数将像预期的那样运行,如下所示。
在这里插入图片描述

三、栈

下面将介绍一个重要的编程概念——调用栈(call stack)。调用栈最经常被用于 存放子程序的返回地址。在递归程序中,每一层次递归都必须在调用栈上增加一条地址,因此如果程序出现无限递归(或仅仅是过多的递归层次),调用栈就会产生栈溢出。调用栈不仅对编程来说很重要,使用递归时也必须理解这个概念。

还是举一个例子,假设你去野外烧烤,并为此创建了一个待办事项清单——一叠便条。
在这里插入图片描述
本书之前讨论数组和链表时,也有一个待办事项清单。
在这里插入图片描述
你可将待办事项添加到该清单的任何地方,还可删除任何一个待办事项。一叠便条要简单得多:插入的待办事项放在清单的最前面;读取待办事项时,你只读取最上面的那个,并将其删除。因此这个待办事项清单只有两种操作:压入(插入)弹出(删除并读取)
在这里插入图片描述
下面来看看如何使用这个待办事项清单。
在这里插入图片描述
这种数据结构称为 是一种简单的数据结构,刚才我们一直在使用它,却没有意识到!

1)调用栈

计算机在内部使用被称为 调用栈的栈。来看看计算机是如何使用调用栈的。下面是一个简单的函数:

python版本代码如下:

def greet(name):
	print("hello, " + name + "!")
	greet2(name)
	print("getting ready to say bye...")
	bye()

def greet2(name):
	print("how are you, " + name + "?")

def bye():
	print("ok bye!")

print(greet("maggie"))

在这里插入图片描述
c++版本代码如下:

#include <iostream>
#include <string>

using std::cout;
using std::endl;

void greet2(std::string name) {
    cout << "How are you, " + name + "?" << endl;
}

void bye() {
    cout << "Ok, bye!" << endl;
}


void greet(std::string name) {
    cout << "Hello, " + name + "!" << endl;
    greet2(name);
    cout << "Getting ready to say bye..." << endl;
}


int main() {
    greet("Adit");

    return 0;
}

下面我们来分析一下程序:

假设你调用 greet("maggie") ,计算机将首先为该函数调用分配一块内存。
在这里插入图片描述
我们来使用这些内存。变量 name 被设置为 maggie,这需要存储到内存中。
在这里插入图片描述
每当你调用函数时,计算机都像这样将函数调用涉及的所有变量的值存储到内存中。接下来,你打印 hello, maggie!,再调用greet2("maggie")。同样,计算机也为这个函数调用分配一块内存。
在这里插入图片描述
计算机使用一个栈来表示这些内存块,其中第二个内存块位于第一个内存块上面。你打印 how are you, maggie?,然后从函数调用返回。此时,栈顶的内存块被弹出。
在这里插入图片描述
现在,栈顶的内存块是函数 greet 的,这意味着你返回到了函数 greet。当你调用函数 greet2 时,函数 greet 只执行了一部分。这是本节的一个重要概念:调用另一个函数时,当前函数暂停并处于未完成状态。 该函数的所有变量的值都还在内存中。执行完函数 greet2 后,你回到函数 greet ,并从离开的地方开始接着往下执行:首先打印 getting ready to say bye…,再调用函数 bye
在这里插入图片描述
在栈顶添加了函数 bye 的内存块。然后,你打印 ok bye!,并从这个函数返回。
在这里插入图片描述
现在你又回到了函数 greet。由于没有别的事情要做,你就从函数 greet返回。这个栈用于存储多个函数的变量,被称为 调用栈

2)递归调用栈

递归函数也使用 调用栈!来看看递归函数 factorial 的调用栈。factorial(5) 写作 5!,其定义如下:5! = 5 * 4 * 3 * 2 * 1。同理,factorial(3)为3 * 2 * 1。下面是计算阶乘的递归函数:

python版本代码如下:

def fact(x):
	if x == 1:
		return 1
	else:
		return x * fact(x-1)

print(fact(3))

在这里插入图片描述
c++版本代码如下:

#include <iostream>

using std::cout;
using std::endl;

int fact(const int& x) {
    if (x == 1) return 1;
    return fact(x-1) * x;
}

int main() {
    cout << fact(3) << endl;
}

下面来详细分析调用 fact(3) 时调用栈是如何变化的。别忘了,栈顶的方框指出了当前执行到了什么地方。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
注意,每个 fact 调用都有自己的 x 变量。在一个函数调用中不能访问另一个的 x 变量。递归 中扮演着重要角色。不知道你还记不记得在开头的例子中,有两种寻找钥匙的方法。下面我们再次回头去列出了第一种方法。
在这里插入图片描述
使用这种方法时,你创建一个待查找的盒子堆,因此你始终知道还有哪些盒子需要查找。
在这里插入图片描述
但使用递归方法时,没有盒子堆。
在这里插入图片描述
既然没有盒子堆,那算法怎么知道还有哪些盒子需要查找呢?下面是一个例子。
在这里插入图片描述
此时,调用栈类似于下面这样。
在这里插入图片描述
原来“盒子堆”存储在了中!这个包含未完成的函数调用,每个函数调用都包含还未检查完的盒子。使用很方便,因为你无需自己跟踪盒子堆——替你这样做了。

使用虽然很方便,但是也要付出代价:存储详尽的信息可能占用大量的内存。每个函数调用都要占用一定的内存,如果栈很高,就意味着计算机存储了大量函数调用的信息。在这种情况下,你有两种选择:

  • 重新编写代码,转而使用循环。
  • 使用尾递归。这是一个高级递归主题,而且并非所有的语言都支持尾递归。

PS:

调用栈的主要功能是 存放返回地址。除此之外,调用栈还用于存放:

  • 本地变量:子程序的变量可以存入调用栈,这样可以达到不同子程序间变量分离开的作用。
  • 参数传递:如果寄存器不足以容纳子程序的参数,可以在调用栈上存入参数。

四、总结

  • 递归指的是调用自己的函数。
  • 每个递归函数都有两个条件:基线条件和递归条件。
  • 栈有两种操作:压入和弹出。
  • 所有函数调用都进入调用栈。
  • 调用栈可能很长,这将占用大量的内存。

参考文章

文章创建于: 2019-09-04 15:58:26
展开阅读全文

没有更多推荐了,返回首页