十、Python语言中简单数据结构的应用(之一)
----From a high school student's view to learn Python
关键字:
python 列表 堆栈 数据结构 递归调用 函数 组合问题 后缀表达式 前缀表达式 逆波兰表达式 运算符 优先级
本篇我们将简单介绍一下数据结构中的堆栈(stack),以及在Python中利用堆栈所实现的一些应用。
一、堆栈介绍
堆栈是一个后进先出(LIFO)的数据结构,其工作方式就像往弹夹里面填子弹,在填好子弹之后,如果你要取出一颗子弹,那么你去除的这颗子弹一定是你最后填进去的,如果将子弹全部取出,那最后取出的那颗子弹一定是你最先填进去的那颗。把子弹当成我们程序中操作的元素,那么弹夹就是一个堆栈的模型了。
在栈上"push"元素是个常用术语,意思是把一个对象添加到堆栈中;反之,要删除一个元素,你可以把它"pop"出堆栈。此外,还有”empty”来判断堆栈是否为空状态。
很明显,使用Python中的List非常容易实现堆栈的模型,我们先复习一下List中有哪些内置的方法,在terminal窗口输入:
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
内容很多,介绍一些常用的:
s[i] = x
item i of s is replaced by x
s[i:j] = t
slice of s from i to j is replaced by the contents of the iterable t
del s[i:j]
same as s[i:j] = []
s[i:j:k] = t
the elements of s[i:j:k] are replaced by those of t
del s[i:j:k]
removes the elements of s[i:j:k] from the list
s.append(x)
same as s[len(s):len(s)] = [x]
s.extend(x)
same as s[len(s):len(s)] = x
s.count(x)
return number of i‘s for which s[i] == x
s.index(x[, i[, j]])
return smallest k such that s[k] == x and i <= k < j
s.insert(i, x)
same as s[i:i] = [x]
s.pop([i])
same as x = s[i]; del s[i]; return x
s.remove(x)
same as del s[s.index(x)]
s.reverse()
reverses the items of s in place
s.sort([cmp[, key[, reverse]]])
sort the items of s in place
我们使用List的append()来实现堆栈的push,使用pop()不带参数的情况来实现堆栈的pop,使用len(list)==0来实现empty。
举例:
>>> stack=[]
>>> len(stack)==0
True
>>> stack.append('1')
>>> stack.append('2')
>>> for a in '3456789': stack.append(a)
...
>>> stack
['1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> stack.pop()
'9'
>>> stack
['1', '2', '3', '4', '5', '6', '7', '8']
>>> len(stack)==0
False
>>>
二、如何使用堆栈来模拟递归函数调用
看下面的程序,还是一个组合问题的程序:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | def comb(iterable, r, order=1): print "\ncomb-----" comb1=comb(tuple('123456'),4) for e in comb1: print e print len(comb1) |
这个程序就不像之前一句一句的详细介绍了,因为使用的方法和之前的没有根本的变化,简单说明如下:
- 函数和之前相比,增加了一个参数,并且使用1作为缺省参数值,当该参数不为1时,我们将按照列表中元素的倒序来列出组合
- 递归函数为subcomb(),请注意,这个函数的定义和调用都在函数comb()中,这也是一种合法的方式
- 递归函数subcomb(N, m, n, B)实现的方式和前一篇介绍的稍有不同,前一篇是从后往前开始列出组合结果的,而这个是从前往后来列的,所以在参数中还额外的加了一个B用来表示递归子序列的起始位置;参数N表示最终组合中元素的个数,m、n分别表示当前所求的元素个数和组合中元素个数,递归调用时,m、n、B会变化
程序的运行结果:
comb-----
('1', '2', '3', '4')
('1', '2', '3', '5')
('1', '2', '3', '6')
('1', '2', '4', '5')
('1', '2', '4', '6')
('1', '2', '5', '6')
('1', '3', '4', '5')
('1', '3', '4', '6')
('1', '3', '5', '6')
('1', '4', '5', '6')
('2', '3', '4', '5')
('2', '3', '4', '6')
('2', '3', '5', '6')
('2', '4', '5', '6')
('3', '4', '5', '6')
15
介绍这个程序不是主要目的,主要的目的是想说明,递归是可以通过使用堆栈来模拟的,而且最终运行的结果也一模一样。先看程序:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | def combusestack(iterable, r, order=1): print "comb use stack-----" comb1=combusestack(tuple('123456'),4) for e in comb1: print e print len(comb1) |
运行结果:
comb use stack-----
('1', '2', '3', '4')
('1', '2', '3', '5')
('1', '2', '3', '6')
('1', '2', '4', '5')
('1', '2', '4', '6')
('1', '2', '5', '6')
('1', '3', '4', '5')
('1', '3', '4', '6')
('1', '3', '5', '6')
('1', '4', '5', '6')
('2', '3', '4', '5')
('2', '3', '4', '6')
('2', '3', '5', '6')
('2', '4', '5', '6')
('3', '4', '5', '6')
15
这个程序使用一个List来模拟堆栈,进入堆栈中的元素,也是一个List,我们在原来递归函数进行递归调用的地方,将函数的其中3个参数(N除外,因为在过程中不会改变)以及循环变量i,push到堆栈中,在原来函数结束的地方,在堆栈中pop一个List出来,直到堆栈空为止。
在程序中也出现了一些比较奇特的语句,如line21、line27。
这个程序的目的只是为了验证,递归调用可以通过堆栈来模拟函数调用,变换为非递归的函数;其实这个程序可读性不是很高,而且在line21由于堆栈的弹出,会改变循环变量i的值,在调试程序和理解程序方面会带来困惑。
三、堆栈的简单应用举例
介绍两个例子,一是利用堆栈的特性,反转字符串,另一是利用堆栈,检查表达式中的()是否匹配。
堆栈所具有的这种后进先出(LIFO)协议的特性,它可以作为一个通用的办法用于反转数据序列。例如,如果按照1,2,3的顺序把值压入一个堆栈,那么从堆栈中将它们弹出时的顺序为3,2,1。
看下面字符窜反转的例子:
1 2 3 4 5 6 7 8 9 10 11 12 | def rev(s): print rev('123456789') print rev('') |
运行结果如下:
987654321
None
下面是关于检查括号是否匹配的例子
文字说明的部分摘录于<<Data Structures and Algorithms in Python>>
In the following application, we consider arithmetic expressions that may contain various pairs of grouping symbols, such as
• Parentheses: “(” and “)” • Braces: “{” and “}”
• Brackets: “[” and “]”
Each opening symbol must match its corresponding closing symbol. For example, a left bracket, “[,” must match a corresponding right bracket, “],” as in the expression [(5+x)-(y+z)]. The following examples further illustrate this concept:
• Correct: ()(()){([()])}
• Correct: ((()(()){([()])})) • Incorrect: )(()){([()])}
• Incorrect: ({[])}
- Incorrect: (
程序如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | def is_matched(expr): print is_matched('[(5+x)-(y+z)]') print is_matched('{(5+x)-(y+z)]') print is_matched('[(5+x)-(y+z))') |
运行结果分别显示为:True False False
做一些说明:
我们仍然使用List来模拟堆栈,所以push和empty的形式和真正的堆栈有差异。
程序的流程大致是这样:
for循环扫描表达式,如果遇到的字符是’({[‘中的任一个,则将该字符压入堆栈;否则如果字符是’)}]’中的任一个,程序先判断当前堆栈是否为空,为空则返回错误,然后判断符号是否匹配,line13的语句就是检查是否匹配,这是本程序中唯一比较难的语句。
- (2013-10-06 22:57:35)
- (2013-10-03 22:18:28)
- (2013-10-02 22:15:46)
- (2013-10-02 22:10:41)
- (2013-09-21 23:37:27)
- (2013-09-21 23:32:54)
- (2013-09-20 23:09:39)
- (2013-09-20 23:09:10)
- (2013-09-08 09:16:19)
- (2013-09-02 19:26:01)