Python用数组实现普通队列、循环队列(LeetCode 622)，以及链表队列，

• 支持动态移动的普通数组队列

'''
	 用数组创建队列并支持动态移位操作

	 Author by: Lofues
'''

from typing import Optional

class ArrayQueue(object):
	def __init__(self,capacity : int):
		self._capacity = capacity
		self._items = []
		self._head, self._tail = 0, 0

	def enqueue(self,item : str) -> bool:
		# 判断是否已满
		if self._tail == self._capacity:
			if self._head == 0:
				return False
			else:
				for i in range(0,self._tail-self._head):
					self._items[i] = self._items[self._head + i]
				self._tail = self._tail - self._head
				self._head = 0
		self._items.insert(self._tail,item)
		self._tail += 1
		return True

	def dequeue(self) -> Optional[str]:
		# 从队头取出数据
		if self._head == self._tail:
			return None
		else:
			item = self._items[self._head]
			self._head += 1
			return item

	def __repr__(self):
		if self._head == self._tail:
			return None
		else:
			result = []
			cur = self._head
			while cur != self._tail:
				result.append(self._items[cur])
				cur += 1
		return '->'.join(str(x) for x in result)


def main():
	queue = ArrayQueue(10)
	for i in range(10):
		queue.enqueue(i)
	print(queue)
	for i in range(5):
		print(queue.dequeue())
	print(queue)

if __name__ == '__main__':
	main()

• LeetCode 622创建循环队列

'''
	用数组创建循环队列

	Author by: Lofues
'''

class CircularQueue(object):
	def __init__(self,capacity : int):
		self._head, self._tail = 0,0
		self._capacity = capacity + 1
		self._items = [None] *  self._capacity

	def is_full(self):
		return (self._tail + 1) % self._capacity == self._head

	def is_empty(self):
		return self._tail == self._head

	def dequeue(self) -> bool:
		if self.is_empty():
			return False
		else:
			self._items[self._head] = None
			self._head = (self._head + 1) % self._capacity
			return True

	def enqueue(self,val) -> bool:
		if self.is_full():
			return False
		else:
			self._items[self._tail] = val
			self._tail = (self._tail + 1) % self._capacity
			return True

	def __repr__(self):
		if self.is_empty():
			return None
		else:
			result = []
			cur = self._head
			while cur != self._tail:
				result.append(self._items[cur])
				cur = (cur + 1) % self._capacity
			return '->'.join(str(x) for x in result)

	def prior(self):
		return self._items[self._head] if not self.is_empty() else -1

	def tail(self):
		return self._items[(self._tail - 1 + self._capacity) % self._capacity] if not self.is_empty() else -1

def main():
	queue = CircularQueue(10)
	for i in range(10):
		queue.enqueue(i)
	print(queue)
	for i in range(5):
		queue.dequeue()
	print(queue)
	print(queue.prior(),queue.tail())
	for i in range(5):
		queue.enqueue(i)
	print(queue)

if __name__ == '__main__':
	main()

• 链表队列

'''
	用链表实现队列

	Author by: Lofues
'''

from typing import Optional

class Node(object):
	def __init__(self,val = None):
		self.val = val
		self.next = None

class LinkedQueue(object):
	def __init__(self):
		self._tail = None
		self._head = None

	def enqueue(self,val : Optional[str]):
		new_node = Node(val)
		if self._tail:
			self._tail.next = new_node
		else:
			self._head = new_node
		self._tail = new_node

	def dequeue(self) -> Optional[str]:
		if self._head:
			ans = self._head.val
			self._head = self._head.next
			if not self._head:
				self._tail = None
			return ans

	def __repr__(self) -> str:
		cur = self._head
		result = []
		while cur:
			result.append(cur.val)
			cur = cur.next
		return '->'.join(str(x) for x in result)


def main():
	lq = LinkedQueue()
	for i in range(10):
		lq.enqueue(i)
	print(lq)
	for i in range(5):
		lq.dequeue()
	print(lq)
	for i in range(5):
		lq.enqueue(i)
	print(lq)


if __name__ == '__main__':
	main()