一、栈
A、顺序存储结构
# 自定义异常
class StackUnderflow(ValueError): # 栈下溢（空栈访问）
pass
# 列表头作为栈底，列表尾作为栈顶
# 缺点：1、扩大存储需要做一次高代价的操作 2、需要完整的大块存储区域
# 使用list作为栈来使用
# lst = []
# lst.append() # 压入
# lst[-1] # 访问栈顶
# lst.pop() # 弹出
class SStack:
def __init__(self):
self._elems = []
def is_empty(self):
'''判断栈是否为空'''
return self._elems == []
# return not self._elems
def peek(self):
'''返回栈顶元素'''
if self._elems == []:
raise StackUnderflow("空栈异常：in SStack.top()")
return self._elems[-1]
def push(self,elem):
'''追加一个新的元素elem到栈顶'''
self._elems.append(elem)
# 从尾部添加时间复杂度为O（1）
# self._elems.insert(0,elem)
# 如果从列表第一个位置开始添加，时间复杂度是O（n）,链表正相反
def pop(self):
'''弹出栈顶元素'''
if self._elems == []:
raise StackUnderflow("空栈异常：in SStack.pop()")
return self._elems.pop()
if __name__ == "__main__":
st1 = SStack()
st1.push(3)
st1.push(7)
st1.push(5)
while not st1.is_empty():
print(st1.pop()) # 5 7 3
B、链式存储结构
# 表头作为栈顶，表尾作为栈底
# 优点：解决了顺序表的缺点-->新增节点开销小，不需要连续锋内存
# 缺点：1、依赖解释器的存储管理 2、每个节点开销
class Node(object):
def __init__(self,val): # 定位的点的值和一个指向
self.val=val # 指向元素的值,原队列第二元素
self.next=None
class stack(object):
def __init__(self):
self.__head=None # 初始化最开始的位置
def is_empty(self):
'''判断栈是否为空'''
return self.__head is None
def peek(self):
'''返回栈顶元素'''
if self.__head!=None: # 如果栈顶不为空
return self.__head.val # 返回栈顶元素的值
else:
return None
def push(self,n):
'''追加一个新的元素elem到栈顶'''
node = Node(n) # 实例化节点
node.next = self.__head
self.__head = node
return node.val
def pop(self):
'''弹出栈顶元素'''
if self.__head == None:
return None
else:
tmp = self.__head.val
self.__head = self.__head.next #下移一位，进行
return tmp
if __name__=="__main__":
s=stack()
s.push(1)
s.push(2)
s.push(3)
print (s.pop()) # 3
print (s.pop()) # 2
print (s.pop()) # 1
二、队列
A.顺序存储结构实现
1.单端队列
# 入队操作频繁选择 列表尾部添加元素O(1) 列表头部弹出元素
# 出队操作频繁选择 列表尾部弹出元素O(1) 列表头部添加元素
class Queue(object):
def __init__(self):
self.__list = []
def is_empty(self):
'''判断一个队列是否为空'''
return self.__list == []
def enqueue(self, item):
'''进入队列'''
self.__list.append(item)
def dequeue(self):
'''退出队列'''
return self.__list.pop(0)
def size(self):
return len(self.__list)
if __name__=="__main__":
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())
2.双端队列
class Deque(object):
def __init__(self):
self.__list = []
def is_empty(self):
'''判断一个队列是否为空'''
return self.__list == []
def add_front(self, item):
'''队列头部添加元素'''
self.__list.insert(0, item)
def add_rear(self, item):
'''队列尾部添加元素'''
self.__list.append(item)
def pop_front(self):
'''从队列头部删除一个元素'''
return self.__list.pop(0)
def pop_rear(self):
'''从队列尾部删除一个元素'''
return self.__list.pop()
def size(self):
return len(self.__list)
if __name__=="__main__":
q = Deque()
q.add_front(1)
q.add_rear(2)
q.add_rear(3)
print(q.pop_front())
print(q.pop_rear())
B.链式存储结构实现
class Node(object):
def __init__(self,val):
self.next = None #指针的下一个，用于指向内容，先给初始化设置为空
self.val = val #val是它原本的值，
class Queue(object):
def __init__(self, node=None):
'''空队列，记录队头位置'''
self.__head = node
def is_empty(self):
'''判断队列是否为空'''
return self.__head == None
def enqueue(self, item):
'''入队列，链表尾部添加节点'''
node = Node(item)
if self.is_empty():
self.__head = node
else:
cur = self.__head
while cur.next:
cur = cur.next
cur.next = node
def dequeue(self):
'''出队列，删除头结点'''
if self.is_empty():
return None
else:
cur = self.__head
self.__head = cur.next
def travel(self):
'''遍历队列'''
if self.is_empty():
return
else:
cur = self.__head
while cur:
print(cur.val,end=" ")
cur = cur.next
print("\n")
if __name__=="__main__":
q=Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.travel()
