Python使用列表实现栈与队列，最小栈问题实现，用栈实现队列

先说Python语言的list的两个方法：list.append() list.pop()
append()方法用于在列表末尾添加新的对象 。

list1 = ['Google','Runoob','Taobao']
list1.append('Baidu')
print('更新后的列表：',list1)

更新后的列表： ['Google', 'Runoob', 'Taobao', 'Baidu']

pop()用于移除列表中的一个元素，默认为最后一个，并返回该元素值。

list1 = ["Google", "Runoob", "Taobao"]
list_pop = list1.pop()
print("删除的项：",list_pop)
print("列表现在是：",list1)
list_pop = list1.pop(1)
print("删除的项",list_pop)
print("列表现在是：",list1)

删除的项： Taobao
列表现在是： ['Google', 'Runoob']
删除的项： Taobao
列表现在是： ['Google', 'Runoob']

一、Python 栈和队列的实现（列表实现）
栈和队列是两种基本的数据结构，同为容器类型，两者根本的区别在于：
stack（栈）：后进先出

append()方法可以实现进栈操作，pop()可以实现出栈操作，list[-1]可以实现查看目前栈顶元素操作

class Stack(object):
	def __init__(self)：
		self.stack = []
	def push(self,val): # 进栈
		self.stack.append(val)
	def pop(self): # 出栈
		if self.stack:
			self.stack.pop()
		else:
			raise LookupError('Stack is empty')
	def is_empty(self):	#如果栈为空
		return bool(self.stack)
	def top(self):
		# 取出目前stack中最新的元素
		return self.stack[-1]

queue（队列）：先进先出


append()方法可以实现进队列操作，pop(0)可以实现出队列操作

class Queue(object):
	def __init__(self):
		self.queue = []
	def enqueue(self, val): # 往队尾添加一个元素
		self.queue.append(val)
	def dequeue(self): # 队列头部删除一个元素，出队操作
		return self.queue.pop(0)
	def __len__(self):
		# 返回队列大小
		return len(self.queue)
	def is_empty(): # 判断队列是否为空
		return self.queue == []

二、最小栈实现（力扣155.最小栈）


方法一：使用辅助栈：
写法一：

class MinStack:

    def __init__(self):
    	# 使用一个栈，栈顶表示原栈此时所有值的最小值
    	self.min_stack = []
    	self.stack = []
    def push(self, val: int) -> None:
		self.stack.append(val)
		if self.min_stack == []:
			self.min_stack.append(val)
			return
		if self.min_stack[-1] >=val:
			self.min_stack.append(val)
    def pop(self) -> None:
		if self.stack[-1] == self.min_stack[-1]:
			self.min_stack.pop()
		return self.stack.pop()
    def top(self) -> int:
    	return self.stack[-1]
    def getMin(self) -> int:
    	return self.min_stack[-1]
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

写法二：

import math 
class MinStack:

    def __init__(self):
    	self.stack = []
    	self.min_stack = [math.inf] # 传入一个正无穷大的数
    def push(self, val: int) -> None:
    	self.stack.append(x)
    	self.min_stack.append(min(x, self.min_stack[-1]))
    def pop(self) -> None:
    	self.stack.pop()
		self.min_stack.pop()
    def top(self) -> int:
		return self.stack[-1]
    def getMin(self) -> int:
    	return self.min_stack[-1]
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

方法二：列表中传入元组实现最小栈

class MinStack:

    def __init__(self):
    	self.stack = []
    def push(self, val: int) -> None:
		if not self.stack: # 如果栈为空
			self.stack.append((val,val))
		else:
			self.stack.append((val, min(val, self.stack[-1][1])))
    def pop(self) -> None:
		self.stack.pop()

    def top(self) -> int:
		return self.stack[-1][0]

    def getMin(self) -> int:
		return self.stack[-1][1]


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

三、用栈实现队列 力扣232.用栈实现队列


方法一：使用主栈和辅助栈

class MyQueue:
	def __init__(self):
		self.stack1 = [] #主要栈
		self.stack2 = [] # 辅助栈
	def push(self,x:int): # 入队操作
		self.stack1.append(x)
	def pop(self): # 出队操作，由于栈是后进先出(LIFO)结构，所以需要有以下操作
		while len(self.stack1) !=1:
			self.stack2.append(self.stack1.pop())
		r = self.stack1.pop()
		while self.stack2:
			self.stack1.append(self.stack2.pop())
		return r
	def peek(self):
		return self.stack1[0]
	def empty(self):
		return len(self.stack1) == 0

方法二：使用deque，pop时只需要popleft即可，很方便

class MyQueue:
	def __init__(self):
		self.stack = collections.deque([])
	def push(self, x):
		self.stack.append()
	def pop(self):
		return self.stack.popleft()
	def peek(self):
		return self.stack[0]
	def empty(self):
		return len(self.stack) == 0