python版数据结构3、栈和队列

龙妞

已于 2023-09-12 11:46:59 修改

阅读量129

点赞数

分类专栏： python版数据结构文章标签：数据结构 python

于 2023-08-11 15:49:23 首次发布

本文链接：https://blog.csdn.net/qq_43573570/article/details/132233212

版权

python版数据结构专栏收录该内容

14 篇文章 0 订阅

订阅专栏

栈
- 只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（top）和输出数据（pop）的线性表
- 确定了一种默认的访问顺序
  - 任何时候可以访问、删除的元素都是此前最后存入的那个元素
- 后进先出（LIFO，Last In First Out）的原理运作
- 操作
  - push(item)（入栈）,O(1)
  - pop()（出栈）,O(1)
  - peek()（返回栈顶元素）,O(1)
  - is_empty()（判断栈是否为空）,O(1)
  - size()（返回栈元素个数）,O(1)
- 不同线性表存储性能分析
  - 链表
    - 入栈
      - add(item)，O(1)
      - append(item)，O(N)
    - 出栈
      - pop()，O(N)
      - del_init()，O(1)
    - 组合：add+del_init，O(1)
  - 列表
    - 入栈
      - append(item)，O(1)
      - insert(0, item)，O(N)
    - 出栈
      - pop(0)，O(N)
      - pop()，O(1)
    - 组合：append+pop，O(1)
  - 总结
    - 不管是链表还是列表，出入栈的时间复杂度均为O(1)
  - 栈python实现

class Stack(object):
    """使用列表/链表均可进行栈的操作，由于栈的操作都是在尾部进行，列表的尾部操作比链表的时间复杂度要低，因此此处使用列表"""

    def __init__(self):
        """初始化一个新栈"""
        self.__list = []  # type: list

    def is_empty(self):
        return not self.__list  # 等价于self.__list == []

    def push(self, item):
        """入栈"""
        self.__list.append(item)

    def pop(self):
        """出栈"""
        if self.__list:
            return self.__list.pop()
        else:
            return

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def size(self):
        """返回栈元素个数"""
        return len(self.__list)


if __name__ == '__main__':
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    s.push(5)
    s.push(6)
    print(s.pop())

队列
- 只允许在一端进行插入操作，而在另一端进行删除操作的线性表
- 先进先出（FIFO）的原理运作
- 允许插入的一端为队尾，允许删除的一端为队头，队列不允许在中间部位进行操作
- 操作
  - enqueue(item)（入队）
  - dequeue()（出队）
  - is_empty()（判断队列是否为空）,O(1)
  - size()（返回队列元素个数）,O(1)
- 不同线性表存储性能分析
  - 链表
    - 入队
      - add(item)，O(1)
      - append(item)，O(N)
    - 出队
      - pop()，O(N)
      - del_init()，O(1)
    - 组合方法
      - 方法1：add(item)+pop()
        从左往右入队，左入右出
        入队多可选
      - 方法2：append(item)+del_init()
        从右往左入队，右入左出
        出队多可选
  - 列表
    - 入队的方式
      - append(item)，O(1)
      - insert(0, item)，O(N)
    - 出队方式
      - pop(0)，O(N)
      - pop()，O(1)
    - 组合方法
      - 方法1：append(item)+pop(0)
        右入左出
        入队多可选
      - 方法2：insert(0, item)+pop()
        左入右出
        出队多可选
  - 总结
    - 不管链表还是列表，时间复杂度均为O(N)
    - 最终选择哪种方式，需要考虑数据是出队多还是入队多
- 队列python实现
- ```
class Queue(object):
    """由于队列是尾进头出的数据结构
    此处为简化操作，使用列表"""

    def __init__(self):
        self.__list = []  # type: list

    def enqueue(self, item):
        """入队"""
        self.__list.append(item)

    def dequeue(self):
        """出队"""
        return self.__list.pop(0)

    def is_empty(self):
        return not self.__list

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


if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    q.enqueue(5)
    q.enqueue(6)
    print(q.dequeue())
```
- 扩展：双端队列
  - 同时具有队列和栈的性质的数据结构
  - 双端队列可以在队列任意一端入队和出队（栈）
  - 但是，它限定插入和删除操作在表的两端进行
  - 操作
    - add_head(item)，头部添加
    - add_tail()，尾部添加
    - pop_head(item)，头部删除
    - pop_tail()，尾部删除
    - is_empty()
    - size()
双端队列python实现

class Dequeue(object):
    """双端队列，以列表为数据存储方式，以左为头，以右为尾"""
    def __init__(self):
        self.__list = []  # type: list

    def add_head(self, item):
        self.__list.insert(0, item)

    def add_tail(self, item):
        self.__list.append(item)

    def pop_head(self):
        if self.__list:
            return self.__list.pop(0)
        else:
            return None

    def pop_tail(self):
        if self.__list:
            return self.__list.pop()
        else:
            return None

    def is_empty(self):
        return not self.__list

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


if __name__ == '__main__':
    q = Dequeue()
    q.add_head(1)
    q.add_head(2)
    q.add_head(3)
    q.add_head(4)
    q.add_head(5)
    print(q.pop_head())