Python实现数据结构，栈，队列（单向队列，双向队列，环形队列），链表

栈：last in first out 先进后出的原则，只能在一端进行插入和删除操作

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):
if self.items:
return self.items.pop()
return None

a = Stack()
a.push(1)
a.push(2)
a.push(3)
print(a.size())  # 3
print(a.is_empty())  # False
print(a.peek())  # 3
print(a.pop())  # 3
print(a.pop())  # 2
print(a.pop())  # 1
print(a.pop())  # None

如果希望items[]是Stack类私有的属性，这样做：

def __init__(self):
self.__items = []

如果希望限定Stack类的成员只有items，这样做：

class Stack(object):
__slots__ = ('__items')

def __init__(self):
self.__items = []

队列：先进先出原则，一端进行插入操作，另一端进行删除操作

单向队列（顺序表实现）

class Queue(object):
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def enqueue(self,item):
return self.items.insert(0, item)
def dequeue(self):
return self.items.pop()
def size(self):
return len(self.items)

b = Queue()
b.enqueue(1)
b.enqueue(2)
b.enqueue(3)
print(b.is_empty())  # False
print(b.size())  # 3
print(b.dequeue())  # 1
print(b.dequeue())  # 2
print(b.dequeue())  # 3

双向队列（double-ended-queue：deque）

从该队列的头部或尾部插入或移除一个元素，时间复杂度为O（1）

而对内置的list类型，从list尾部插入或删除元素，时间复杂度也是O（1），但是从list头部插入或移除元素，时间复杂度就是O（n），这与deque相比，要慢得多

from collections import deque
# 创建双端队列
d = deque()
# 右边添加元素
d.append(1)
# 清空队列
d.clear()
# 左边添加元素
d.appendleft(3)
d.appendleft(4)
# 右边弹出元素
d.pop()
# 左边弹出元素
d.popleft()
# 右边扩展一个列表的元素
d.extend(['a','b'])
# 左边扩展一个列表的元素
d.extendleft(['hh','xx'])
# 返回指定元素的出现个数
print(d.count('hh'))  # 1
# 查找某个元素的索引位置，可指定区间
print(d.index('b',0,4))  # 3
# 在指定位置插入元素
d.insert(2,'insert')  # deque(['xx', 'hh', 'insert', 'a', 'b'])
# 删除指定元素
d.remove('a')  # deque(['xx', 'hh', 'insert', 'b'])
# 队列反转
d.reverse()  # deque(['b', 'insert', 'hh', 'xx'])
# 旋转 默认为1
d.rotate()  # deque(['xx', 'b', 'insert', 'hh'])
d.rotate(2)  # deque(['insert', 'hh', 'xx', 'b'])
d.rotate(-1)  # deque(['hh', 'xx', 'b', 'insert'])

环形队列

class AnnulusQueue(object):
def __init__(self, capacity=10):
self.capacity = capacity
self.size = 0
self.front = 0
self.rear = 0
self.array = [0]*capacity

def is_empty(self):
return 0 == self.size

def is_full(self):
return self.size == self.capacity

def enqueue(self,element):
if self.is_full():
raise Exception('queue is full')
self.array[self.rear] = element
self.size += 1
self.rear = (self.rear + 1) % self.capacity

def dequeue(self):
if self.is_empty():
raise Exception('queue is empty')
self.size -= 1
self.front = (self.front + 1) % self.capacity

def get_front(self):
return self.array[self.front]

class Queue(object):
def __init__(self,size):