栈和队列: Python语言描述

最新推荐文章于 2024-10-02 10:53:34 发布

Dream_wave

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量112

点赞数

文章标签： python 栈队列

本文链接：https://blog.csdn.net/Dream_wave/article/details/119803921

版权

本文详细介绍了栈和队列两种基本数据结构的实现，包括栈的顺序表和链接表实现，以及队列的顺序存储结构。栈的顺序表实现中，利用列表后端操作实现压栈和弹栈操作，而链接表实现则通过前端操作。队列的顺序存储使用双指针管理首尾元素，动态扩容以适应入队和出队需求。

摘要由CSDN通过智能技术生成

1. 栈

Stack(self)	# 创建空栈
is_empty(self)	# 判断栈是否为空
push(self, elem)	# 压栈
pop(self)	# 弹栈
top(self)	# 取得栈里最后压入的元素，不删除

1.1 栈的顺序表实现

对于顺序表，后端插入和删除是O(1)操作，应该用这一端为栈顶.

class SStack(object):
        def __init__(self):
            self._elems = []

        
        def is_empty(self):
            return self._elems == []


        def top(self):
            if self._elems == []:
                raise StackUnderflow("in SStack.top()")
            return self._elems[-1]

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

        def pop(self):
            if self._elems == []:
                raise StackUnderflow("in SStack.pop()")
            return self._elems.pop()

1.2 栈的链接表实现

对于链接表，前端插入和删除是O(1)操作，应该用这一端为栈顶.

class LStack(object):
        def __init__(self):
            self._top = None

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


        def top(self):
            if self._top is None:
                raise StackUnderflow("in LStack.top()")
            return self._top.elem

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

        def pop(self):
            if self._top is None:
                raise StackUnderflow("in LStack.pop()")
            p = self._top        #暂存
            self._top = p.next   #更新
            return p.elem        #返回值

2. 队列

Queue(self)	# 创建空队列
is_empty(self)	# 判断队列是否为空
enqueue(self, elem)	# 入队
dequeue(self)	# 出队
peek(self)	# 查看队列里最早进入的元素，不删除

【数据不变式】

1）_elems属性引用着队列的元素存储区，它是一个list对象，_len属性记录存储区的有效容量；

2）_head是队列中首元素（当时在队列里最早存入的元素）下标，_num始终记录着队列中元素的个数；

3）当时队列里的元素总保存在_elems里从_head开始的连续位置中，新入队的元素存入由_head + _num算出的位置，但如果需要把元素存入下标_len的位置时，改为在下标0位置存入该元素；

4）在_num == _len的情况下出现入队列操作，就扩大存储区.

【队列类的实现】

队列首元素 self._elems[self._head]

下一个空位 self._elems[(self._head + self._num) % self._len]

队列空 self._num == 0

队列满 self._num == self._len

class SQueue(object):
    def __init__(self, init_len = 8):
        self._len = init_len
        self._elems = [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 QueueUnderflow
        return self._elems[self._head]


    def dequeue(self):
        if self._num == 0:
            raise QueueUnderflow
        e = self._elems[self._head]
        self._head = (self._head + 1) % self._len
        self._num -= 1
        retun e 


    def enqueue(self, e):
        if self._num == self._len:
            self.__extend()
        self._elems[ (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._elems[ (self._head + i) % old_len ]
        self._elems = new_elems
        self._head = 0