python之栈的实现
一、用列表模拟栈
栈并不是python的内建类型，可以通过使用list来模拟栈，将列表的末尾看做栈的顶。用这种方法的主要缺点是：所有其他的列表操作也可以操作这个栈，包括任意位置插入、替换和删除元素，这些操作就违反了栈作为一种抽象数据类型的本意。
1.1 栈方法：
| 栈方法 | 作用 |
| s.isEmpty() | 如果为空，返回True，否则返回False |
| s.size() | 返回s中项目的数目 |
| s.iter() | 从底部到顶部，访问s中的每一项 |
| s.push(item) | 在s的顶部添加一项 |
| s.pop() | 在s的顶部删除一项，并返回该项。先验条件：s必须不为空，如果栈为空，将抛出KeyError |
| s.peek() | 返回s的顶部的项，先验条件：s必须不为空，如果栈为空，将抛出KeyError |
| s.clear() | 将s清空 |
1.2 用列表模拟栈的实现代码：
#用列表模拟栈
class Stack:
"""A list_based stack implementation."""
# Constructor
def __init__(self):
"""Sets the initial state of self,and the initial state is []"""
self.items = []
# Accessor methods
def iter(self):
"""Supports iteration over a view of self.
Visits items from bottom to top of stack."""
for i in range(len(self.items)):
yield self.items[i]
def isEmpty(self):
"""Returns True if len(self) == 0, or False otherwise."""
return len(self.items)==0
def peek(self):
"""
Returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if the stack is empty."""
if self.isEmpty():
raise KeyError("The stack is empty.")
return self.items[len(self.items)-1]
def size(self):
"""return the len(self)"""
return len(self.items)
# Mutator methods
def clear(self):
"""Makes self become empty."""
self.items = []
def push(self, item):
"""Adds item to the top of the stack."""
self.items.append(item)
def pop(self):
"""
Removes and returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if the stack is empty.
Postcondition: the top item is removed from the stack."""
if self.isEmpty():
raise KeyError("The stack is empty.")
return self.items.pop()
1.3 栈操作效果
#测试
if __name__=='__main__':
s=Stack() #创建一个空栈
s.push('a')
s.push('b')
s.push('c')
print(list(s.iter())) #return:['a', 'b', 'c']
print(s.size()) #return:3
print(s.pop()) #return:c
print(s.peek()) #return:b
print(s.pop()) #return:b
print(s.pop()) #return:a
#若在此处添加一句：s.pop()或s.peek()，将报错："The stack is empty."
s.clear()
print(s.isEmpty()) #return:True
二、利用链表实现栈
2.1创建一个抽象集合类，并保存为abstractcollection.py文件
class AbstractCollection(object):
"""An abstract collection implementation."""
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._size = 0
if sourceCollection:
for item in sourceCollection:
self.add(item)
# Accessor methods
def isEmpty(self):
"""Returns True if len(self) == 0, or False otherwise."""
return len(self) == 0
def __len__(self):
"""Returns the number of items in self."""
return self._size
def __str__(self):
"""Returns the string representation of self."""
return "[" + ", ".join(map(str, self)) + "]"
def __add__(self, other):
"""Returns a new bag containing the contents
of self and other."""
result = type(self)(self)
for item in other:
result.add(item)
return result
def __eq__(self, other):
"""Returns True if self equals other,
or False otherwise."""
if self is other: return True
if type(self) != type(other) or \
len(self) != len(other):
return False
otherIter = iter(other)
for item in self:
if item != next(otherIter):
return False
return True
2.2 创建一个抽象栈类，保存为abstractstack.py
from abstractcollection import AbstractCollection
class AbstractStack(AbstractCollection):
"""An abstract stack implementation."""
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
AbstractCollection.__init__(self, sourceCollection)
# Mutator methods
def add(self, item):
"""Adds item to self."""
self.push(item)
class Node(object):
"""Represents a singly linked node."""
def __init__(self, data, next = None):
self.data = data
self.next = next2.4 用链表实现栈，保存为linkedstack.py
from node import Node
from abstractstack import AbstractStack
class LinkedStack(AbstractStack):
"""A link-based stack implementation."""
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._items = None
AbstractStack.__init__(self, sourceCollection)
# Accessor methods
def __iter__(self):
"""Supports iteration over a view of self.
Visits items from bottom to top of stack."""
def visitNodes(node):
"""Adds items to tempList from tail to head."""
if not node is None:
visitNodes(node.next)
tempList.append(node.data)
tempList = list()
visitNodes(self._items)
return iter(tempList)
def peek(self):
"""
Returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if the stack is empty."""
if self.isEmpty():
raise KeyError("The stack is empty.")
return self._items.data
# Mutator methods
def clear(self):
"""Makes self become empty."""
self._size = 0
self._items = None
def push(self, item):
"""Adds item to the top of the stack."""
self._items = Node(item, self._items)
self._size += 1
def pop(self):
"""
Removes and returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if the stack is empty.
Postcondition: the top item is removed from the stack."""
if self.isEmpty():
raise KeyError("The stack is empty.")
data = self._items.data
self._items = self._items.next
self._size -= 1
return data
三、用数组实现栈
3.1 创建一个数组类，保存为arrays.py
"""
File: arrays.py
An Array is a restricted list whose clients can use
only [], len, iter, and str.
To instantiate, use
= array(, )
The fill value is None by default.
"""
class Array(object):
"""Represents an array."""
def __init__(self, capacity, fillValue = None):
"""Capacity is the static size of the array.
fillValue is placed at each position."""
self._items = list()
for count in range(capacity):
self._items.append(fillValue)
def __len__(self):
"""-> The capacity of the array."""
return len(self._items)
def __str__(self):
"""-> The string representation of the array."""
return str(self._items)
def __iter__(self):
"""Supports iteration over a view of an array."""
return iter(self._items)
def __getitem__(self, index):
"""Subscript operator for access at index."""
return self._items[index]
def __setitem__(self, index, newItem):
"""Subscript operator for replacement at index."""
self._items[index] = newItem
3.2 创建一个抽象栈类，保存为abstractstack.py (同上)
3.3用数组实现栈，保存为arraystack.py
from arrays import Array
from abstractstack import AbstractStack
class ArrayStack(AbstractStack):
"""An array-based stack implementation."""
# Class variable
DEFAULT_CAPACITY = 10
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._items = Array(ArrayStack.DEFAULT_CAPACITY)
AbstractStack.__init__(self, sourceCollection)
# Accessor methods
def __iter__(self):
"""Supports iteration over a view of self.
Visits items from bottom to top of stack."""
cursor = 0
while cursor < len(self):
yield self._items[cursor]
cursor += 1
def peek(self):
"""Returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if stack is empty."""
if self.isEmpty():
raise KeyError("The stack is empty")
return self._items[len(self) - 1]
# Mutator methods
def clear(self):
"""Makes self become empty."""
self._size = 0
self._items = Array(ArrayStack.DEFAULT_CAPACITY)
def push(self, item):
"""Inserts item at top of the stack."""
# Resize array here if necessary
self._items[len(self)] = item
self._size += 1
def pop(self):
"""Removes and returns the item at the top of the stack.
Precondition: the stack is not empty.
Raises: KeyError if stack is empty.
Postcondition: the top item is removed from the stack."""
if self.isEmpty():
raise KeyError("The stack is empty")
oldItem = self._items[len(self) - 1]
self._size -= 1
# Resize the array here if necessary
return oldItem
四、测试链表栈或数组栈
from arraystack import ArrayStack
from linkedstack import LinkedStack
def test(stackType):
# Test any implementation with same code
s = stackType()
print("Length:", len(s))
print("Empty:", s.isEmpty())
print("Push 1-10")
for i in range(10):
s.push(i + 1)
print("Peeking:", s.peek())
print("Items (bottom to top):", s)
print("Length:", len(s))
print("Empty:", s.isEmpty())
theClone = stackType(s)
print("Items in clone (bottom to top):", theClone)
theClone.clear()
print("Length of clone after clear:", len(theClone))
print("Push 11")
s.push(11)
print("Popping items (top to bottom): ", end="")
while not s.isEmpty(): print(s.pop(), end=" ")
print("\nLength:", len(s))
print("Empty:", s.isEmpty())
#test(ArrayStack)
test(LinkedStack)