数据结构笔记3
来自《Python数据结构学习笔记》（张清云 编著）
第五章 队列和栈
5.2 栈
又称堆栈，是一种运算受限的线性表。
5.2.2 入栈和出栈
- Stack()：建立一个空的栈对象
- push()：把一个元素添加到栈的最顶层
- pop()：删除栈顶层的元素，并返回这个元素
- peek()：返回顶层的元素，并不删除它
- isEmpty()：判断栈是否为空
- size()：返回栈中元素的个数
class Stack(object):
"""栈"""
def __init__(self):
self._list=[]
def push(self,item):
"""添加一个新的元素item到栈顶"""
self._list.append(item)
def pop(self):
"""弹出栈顶元素"""
return self._list.pop()
def peek(self):
"""返回栈顶元素"""
if sellf._list:
return self._list[-1]
else:
return None
def is_empty(self):
"""判断栈是否为空"""
return self._list==[]
def size(self):
"""返回栈的元素"""
return len(self._list)
if __name__=="__main__":
s=Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())输出：
4
3
2
15.2.3 顺序栈
- 顺序栈中的元素用向量存放
- 栈底位置固定不变，可以设置在向量两端的任意一个端点
- 栈顶位置随着进栈和退栈操作而变化，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置
1.顺序栈的基本操作
（1）进栈操作
S->top加1
注意：S->top==StackSize-1表示栈满；进行“上溢”现象，即当栈满时，再进行进栈运算产生空间溢出的现象。上溢是一种出错状态，应设法避免。
（2）退栈操作
S->top减1
S->top<0表示此栈是一个空栈。如果进行退栈运算，则将会产生溢出现象。下溢是一种正常的现象，常用作程序控制转移的条件。
2.顺序栈运算
（1）使用python判断栈是否为空的算法
#判断栈是否为空，返回布尔值
def is_empty(self):
return self.items==[]（2）使用python返回栈顶元素的算法
def peek(self):
return self.items[len(self.items)-1]（3）使用python返回栈的大小的算法
def size(self):
return len(self.items)（4）使用python把新的元素堆进栈里面（也称压栈、入栈或进栈）
def push(self,item):
self.items.append(item)（5）使用python把栈顶元素丢出去（也称出栈）
def pop(self,item):
return self.items.pop()实例：
class Stack(object):
#初始化栈为空列表
def __init__(self):
self.items=[]
#判断栈是否为空，返回布尔值
def is_empty(self):
return self.items==[]
#返回栈顶元素
def peek(self):
return self.items[len(self.items)-1]
#返回栈的大小
def size(self):
return len(self.items)
#把新的元素堆进栈里面（入栈）
def push(self,item):
self.items.append(item)
#把栈顶元素丢出去（出栈）
def pop(self,item):
return self.items.pop()
if __name__=="__main__":
#初始化一个栈对象
my_stack=Stack()
#把'h'丢进栈里
my_stack.push('a')
my_stack.push('c')
my_stack.push('d')
my_stack.push('e')
#看一下栈的大小（有几个元素）
print(my_stack.size())
#打印栈顶元素
print(my_stack.peek())
#把栈顶元素丢进去，并打印出来
#print(my_stack.pop())
#再看一下栈顶元素是谁
print(my_stack.peek())
#这个时候栈的大小是多少？
print(my_stack.size())
#再丢一个栈顶元素
print(my_stack.pop())
#看一下栈的大小
print(my_stack.size())5.2.4 链栈
用链表的方式实现栈。
- 定义LinkStack结构类型的目的是为了更加便于在函数体中修改指针top
- 如果要记录栈中元素个数，将属性放在LinkStack中定义
（1）判断链栈是否为空
def is_empty(self):
return self._top is None（2）返回栈顶元素
def top(self):
if self.is_empty():
raise StackUnderflow("in LStack.top()")
return self._top.elem（3）把新的元素放进栈里面
def push(self,elem):
self._top=Node(elem,self._top)（4）把栈顶元素丢出去（出栈）
def pop(self):
if self.is_empty():
raise StackUnderflow("in LStack.pop()")
result=self._top.elem
self._top=self._top.next
return result实例：
#链表节点
class Node(object):
def __init__(self,elem,next_=None):
self.elem=elem
self.next=next_
#顺序表实现栈
class SStack(object):
def __init__(self):
self._elems=[]
def is_empty(self):
return self._elems=[]
def top(self):
if self.is_empty():
raise StackUnderflow
return self._elems[-1]
def push(self,elem):
self._elems.append(elem)
def pop(self):
if self.is_empty():
raise StackUnderflow
return self._elems.pop()
#链表实现栈
class LStack(object):
def __init__(self):
self._top=None
def is_empty(self):
return self._top is None
def top(self):
if self.is_empty():
raise StackUnderflow("in LStack.top()")
def push(self,elem):
self._top=Node(elem,self._top)
def pop(self):
if self.is_empty():
raise StackUnderflow("in LStack.pop()")
result=self._top.elem
self._top=self._top.next
return result
if __name__=="__main__":
st1=SStack()
st1.push(3)
st1.push(5)
while not st1.is_empty():
print(st1.pop())
print("==========")
st2=LStack()
st2.push(3)
st2.push(5)
while not st2.is_empty():
print(st2.pop())输出：
5
3
==========
5
3