数据结构03：队列（单链表、数组实现）、双端队列、栈（Python实现）

队列

先进先出 型数据结构。
基本操作：入队（push），出队（pop）。
采用单链表实现队列

class FullError(Exception):
    pass
class EmptyError(Exception):
    pass

class Queue(object):
    #初始化函数
    def __init__(self, maxsize=None):
        self.maxsize = maxsize
        self._item_linked_list = Linkedlist()
    
    def __len__(self):
        return len(self._item_linked_list)
    
    def push(self, value):
        if self.maxsize is not None and len(self) >= self.maxsize:
            raise FullError('queue full')
        return self._item_linked_list.append(value)
    
    def pop(self):
        if len(self) <= 0:
            raise EmptyError('queue empty')
        return self._item_linked_list.popleft()

#测试脚本    
def test_queue():
    q = Queue()
    q.push(0)
    q.push(1)
    q.push(2)
    
    assert len(q) == 3
    
    assert q.pop() == 0
    assert q.pop() == 1
    assert q.pop() == 2

用数组实现队列

需要两个指针：head=0，tail=0。push操作时，head前移，pop操作时，tail前移。
采用前面写好的数组类

class FullError(Exception):
    pass
            
class ArrayQueue(object):
    def __init__(self, maxsize):
        self.maxsize = maxsize
        self.array = Array(maxsize)
        self.head = 0
        self.tail = 0
    
    def push(self, value):
        if len(self) >= self.maxsize:
            raise FullError('queue full')
        self.array[self.head % self.maxsize] = value
        self.head += 1
        
    def pop(self):
        value = self.array[self.tail % self.maxsize]
        self.tail += 1
        return value
    
    def __len__(self):
        return self.head - self.tail

#单元测试    
def test_arrau_queue():
    size = 5
    q = ArrayQueue(size)
    for i in range(size):
        q.push(i)
    
    assert len(q) == size
    assert q.pop() == 0

双端队列

采用双端链表，实现双端队列，添加操作，pop与popleft

#继承的方式，实现双端队列Deque
class Deque(CircualDoubleLinedList):
    
    #出队
    def pop(self):
        if len(self) == 0:
            raise Exception('Empty')
        #取出最后一个节点
        tailnode = self.tailnode()
        #获取最后节点的值
        value = tailnode.value
        #调用remove方法删除节点
        self.remove(tailnode)
        #返回值
        return value
    
    #左侧出队
    def popleft(self):
        if len(self) == 0:
            raise Exception('empty')
        headnode = self.headnode()
        value = headnode.value
        self.remove(headnode)
        return value

栈（stack）

先入后出 的数据结构。操作：push、pop
在双端队列的基础下实现栈

class Stack():
    def __init__(self):
        self.deque = Deque() #或者用Collections.deque
        
    def push(self, value):
        return self.deque.append(value)
    
    def pop(self):
        return self.deque.pop()
    
    def __len__(self):
        return len(self.deque)
    
    def is_empty(self):
        return len(self) == 0

#单元测试
def test_stack():
    s = Stack()
    for i in range(3):
        s.push(i)
    
    assert len(s) == 3
    assert s.pop() == 2
    assert s.pop() == 1
    assert s.pop() == 0
    
    assert s.is_empty()

在Python内置的collection.deque也可以实现栈

栈溢出

函数的临时变量是存储在栈区的，如果写了一个没有出口的递归函数，则会报错：RecursionError:maximum recursion depth exceeded。