队列和栈的python实现

使用python中的基本数据类型实现–队列和栈

内容来自读书笔记《数据结构与算法的python描述》

实现队列

class QueueUndeflow(ValueError):
    pass


class SQueue(object):
    def __init__(self, init_len=8):
    """初始化的时候包含信息为1.长度;2.模型;3.当前指针;4.当前数据量"""
        self._len = init_len
        self._elem = [0] * init_len
        self._head = 0
        self._num = 0

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

    def peek(self):
        """访问头元素"""
        if self._num == 0:
            raise QueueUndeflow
        return self._elem[self._head]

    def dequeue(self):
        if self._num == 0:
            raise QueueUndeflow
        e = self._elem[self._head]
        # 取出一个数据
        self._head = (self._head + 1) % self._len
        self._num -= 1
        return e

    def enqueue(self, e):
    	# 添加数据之前判断队列是否满了 
        if self._num == self._len:
            self.__extend()
        # 在正确的位置加入新的元素
        self._elem[(self._head + self._num) % self._len] = e
        self._num += 1

    def __extend(self):
        # 队列满了,需要扩充
        old_len = self._len
        self._len *= 2
        new_elems = [0] * self._len
        for i in range(old_len):
            new_elems[i] = self._elem[(self._head + i) % old_len]
        self._elem, self._head = new_elems, 0


if __name__ == '__main__':
    myqu = SQueue()
    myqu.enqueue(1)
    myqu.enqueue(2)
    myqu.enqueue(3)
    myqu.enqueue(4)
    while not myqu.is_empty():
        print(myqu.dequeue())

---

实现栈

# 这里使用到上个文章定义的链表内容
from l链表.Llnode import LNode


class StackUnderflow(ValueError):
    pass


class SStack_from_list(object):
    def __init__(self):
        self._elems = []  # 使用list实现栈

    def is_empty(self):
        """判断栈是否为空"""
        return self._elems == []

    def top(self):
        """访问栈顶元素"""
        if not self._elems:
            raise StackUnderflow("in SStack_from_list.top()")
        return self._elems[-1]

    def push(self, elem):
        self._elems.append(elem)

    def pop(self):
        """弹出栈顶元素"""
        if not self._elems:
            raise StackUnderflow("in SStack_from_list.pop()")
        return self._elems.pop()

    def depth(self):
    	# 栈的深度
        return len(self._elems)


class SStack_from_Linklist(object):
    """基于链表实现栈"""

    def __init__(self):
        self._top = None

    def is_empty(self):
        return self._top is None

    def top(self):
        if not self._top:
            raise StackUnderflow('in SStack_from_Linklist.top()')
        return self._top.val

    def push(self, val):
        self._top = LNode(val, self._top)

    def pop(self):
        if not self._top:
            raise StackUnderflow('in SStack_from_Linklist.pop()')
        p = self._top
        self._top = p.next
        return p.val


if __name__ == '__main__':
    st1 = SStack_from_list()
    st1.push(1)
    st1.push(2)
    st1.push(3)
    while not st1.is_empty():
        print(st1.pop())

    st2 = SStack_from_Linklist()
    st2.push(1)
    st2.push(2)
    st2.push(3)
    while not st2.is_empty():
        print(st2.pop())