基础数据结构：栈、队列——Python实现

基础数据结构：栈、队列——Python实现

上一节我们重点介绍了数据结构的顺序与链式存储结构，那么这次我们来实现一下栈和队列这两种最基础的线性逻辑结构。

对栈和队列最简单的描述，也是它们最核心的性质，就是：

• 栈 —— 后进先出
• 队列 —— 先进先出

一个简单的比喻就是：
栈像是将书一本本依次平摞在一个箱子里，后放入箱子的将先被拿出。
队列就如排队，先来排队的人先被接待。

这是逻辑上的两种数据结构，对应我们前面所讲的顺序表和链表两种存储结构，我们在编程实现数据结构时又可以通过继承以上两种表，派生出顺序栈、顺序队列、链式栈、链式队列。或者单独实现栈和队列的基类，通过多重继承（c++\Python）或者组合(Java)两两结合得出以上四种数据结构。

---

使用Python的list实现顺序栈和顺序队列十分简单，我们只需要继承上一节中的顺序表，再添加一个出栈或出队列的函数即可：

# 基类：顺序表
class List:

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

    def __str__(self):
        return str(self.list)

    def put(self, item):
        self.list.append(item)

    def size(self):
        return len(self.list)

    def isEmpty(self):
        return self.list == []

# 子类：顺序栈
class ListStack(List):

    def pop(self):
        if self.isEmpty():
            return None
        else:
            return self.list.pop(-1)


# 子类：顺序队列
class ListQueue(List):

    def dequeue(self):
        if self.isEmpty():
            return None
        else:
            return self.list.pop(0)

使用了Python基本数据结构list中的方法append和pop来实现入和出的操作，我们只需要改变pop方法的index参数便可实现出栈和出队列的逻辑。

#测试
s=ListStack()
q=ListQueue()
for i in range(0,10):
    s.put(i)
    q.put(i)
print("Stack:",s)
print("Queue:",q)
for i in range(0,5):
    print("Stack pop:",s.pop())
    print("Queue dequeue:",q.dequeue())
print("Stack:",s)
print("Queue:",q)

#输出
Stack: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Queue: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Stack pop: 9
Queue dequeue: 0
Stack pop: 8
Queue dequeue: 1
Stack pop: 7
Queue dequeue: 2
Stack pop: 6
Queue dequeue: 3
Stack pop: 5
Queue dequeue: 4
Stack: [0, 1, 2, 3, 4]
Queue: [5, 6, 7, 8, 9]

继承链表基类，得到链式栈和链式队列：
上一篇提到了我们可以增加rear字段方便尾部插入,但是在删除时我们需要将rear向前移动一位，为了避免遍历全表，我们就需要双向链表，在node结构中增加last来指向前一个结点。但其实将链表首位相接构成双向循环链表的话，我们就不需要rear而是用head.last来查到尾结点。

以下双向循环列表基类的内部方法做了一点点修改，设计思路跟上面的顺序方法相比有所改变：

# 双向循环链表
class DoubleLoopLinked:

    class __Node:
        item = None
        next = None
        last = None

        def __init__(self, item, n, l):
            self.item = item
            self.next = n
            self.last = l

    def __init__(self):
        self.__head = self.__Node(None, None, None)
        self.__size = 0

    def __str__(self):
        p = self.__head.next
        l = []
        while p != self.__head:
            l.append(p.item)
            p = p.next
        return str(l)

    #Python只有公有和私有两种类型的成员，实际上并没有保护成员
    #这里将基类的插入删除操作定义为模拟的保护性方法（函数名前加单下划线def _function(self)）
    #只允许派生类内使用，而不能在外部（如主函数里）访问
    #但事实上只是模拟，经测试，pycharm虽然有提示为protected member,但实际上类外部依然可以访问
    # 尾插法
    def _insertToTail(self, item):
        if self.isEmpty():
            node = self.__Node(item, self.__head, self.__head)
            self.__head.next = node
            self.__head.last = node
        else:
            node = self.__Node(item, self.__head, self.__head.last)
            self.__head.last.next = node
            self.__head.last = node
        self.__size += 1

    # 头插法
    def _insertToHead(self, item):
        if self.isEmpty():
            node = self.__Node(item, self.__head, self.__head)
            self.__head.next = node
            self.__head.last = node
        else:
            node = self.__Node(item, self.__head.next, self.__head)
            self.__head.next.last = node
            self.__head.next = node
        self.__size += 1

    # 删除头结点
    def _popHead(self):
        if self.isEmpty():
            return None
        else:
            node = self.__head.next
            self.__head.next = node.next
            node.next.last = self.__head
            self.__size -= 1
            it = node.item
            del node
            return it

    # 删除尾结点
    def _popTail(self):
        if self.isEmpty():
            return None
        else:
            node = self.__head.last
            self.__head.last = node.last
            node.last.next = self.__head
            self.__size -= 1
            it = node.item
            del node
            return it

    def size(self):
        return self.__size

    def isEmpty(self):
        return self.__size == 0

我们在实现栈和队列时，只需要使用基类提供的方法：

# 子类：链式栈
class LinkedStack(DoubleLoopLinked):

    def push(self,item):
        self._insertToTail(item)

    def pop(self):
        return self._popTail()


# 子类：链式队列
class LinkedQueue(DoubleLoopLinked):

    def enqueue(self,item):
        self._insertToTail(item)

    def dequeue(self):
        return self._popHead()

测试结果与顺序存储方式相同。