栈与队列的理论基础

qq_42859625

已于 2023-03-13 10:39:59 修改

阅读量72

点赞数

分类专栏：算法文章标签： python 数据结构链表

于 2023-03-13 10:36:26 首次发布

本文链接：https://blog.csdn.net/qq_42859625/article/details/129487213

版权

算法专栏收录该内容

6 篇文章 0 订阅

订阅专栏

栈与队列的理论基础

1.栈与队列的区别

（1）python中列表是通过链表的形式实现的，因此，在Python列表的创建中，不需要指定数据结构，也不需要指定列表的长度，
相对应的，数组必须在创建的时候声明它的数据类型，也必须指定数组的长度

（2）内存地址：
列表：不连续
数组：连续

（3）数据类型
列表：里面的元素可以使任何数据类型
数组：相同的类型

由于数组中的数据类型都是一样的，因此数组中的所有项都具有相同的数据类型，所以操作在每个元素上的行为方式相同。因此，在处理大量同类数据类型时，数组非常有用。因为Python不必单独记住每个元素的数据类型细节，与列表相比，数组可能更快并且使用更少的内存

栈和队列是两种基本的数据结构，同为容器类型。两者区别如下：
stack: 后进先出

queue:先进先出
在这里插入图片描述

Note: stack 和 queue 是不能通过查询具体某一个位置的元素而进行操作的。但是他们的排列是按顺序的。

2.python中栈的实现

对于stack我们可以使用python内置的list实现，因为list属于线性数组，在末尾插入和删除一个元素所使用的时间都是O(1)，这非常符合stack的要求。当然也可以使用列表来实现。stack的实现代码（使用python内置的list），实现简单，代码如下：

class Stack(object):
    def __init__(self):
        self.stack = []
    
    def push(self,value):  #进栈
        self.stack.append(value)
    
    def pop(self):   #出栈
        if self.stack:
            self.stack.pop()
        else:
            raise LookupError('stack is empty') #无效数据查询
    
    def is_empty(self): ##判断栈是否为空
        return bool(self.stack)
    
    def top(self): #取出栈中最新的元素
        return self.stack[-1]

3.队列的实现

我们定义如下的链表来实现队列数据结构
在这里插入图片描述

定义一个头节点，左边指向队列的开头，右边指向队列的末尾，这样就可以保证我们插入一个元素和取出一个元素都是O(1)的操作，使用这种链表实现queue也是非常的方便，代码实现如下：

class Head(object):
    def __init__(self):
        self.left = None
        self.right = None

    def Node(object):
        def __init__(self,value):
            self.value = value
            self.next = None

class queue(object):
    def __init__(self):
        #初始化节点
        self.head = Head()
    
    def enqueue(self,value):
        #插入一个元素
        newnode = Node(value)
        p = self.head
        if p.right:
            #如果head节点的右边不为None,
            #说明队列中有其他元素
            temp = p.right
            temp.next = newnode
            p.right = newnode
        else:
            #此时说明队列为空
            p.right = newnode
            p.left = newnode
    
    def dequeue(self):
        #取出一个元素
        p = self.head
        if p.left and (p.left == p.right):
            #说明队中只有一个元素
            temp = p.left
            p.left = p.right = None
            return temp.value
        elif p.left and (p.left != p.right):
            #说明队中不只一个元素
            temp = p.left
            p.left = temp.next
            return temp.value
        else:
            #说明队列为空
            raise LookupError('queue is empty!')
    
    def is_empty(self):
        if self.head.left:
            return False
        else:
            return True
    
    def top(self):
        #查询队列中最先入队的元素
        if self.head.left:
            return self.head.left.value
        else:
            raise LookupError('queue is empty!')

4.python内置的堆、栈和队列

summary

在这里插入图片描述

具体使用

heapq 堆队列

heapq 是一个内置堆结构，一种特殊形式的完全二叉树，其中父节点的值总是大于子节点，根据其性质，python可以用一个满足 heap[k] <= heap[2 * k + 1] <= heap[2 * k + 2] 的列表来实现。heapq是最小堆，如果要实现最大堆，可以使用一些小诀窍，例如在heappush的时候，填进去的是数据 * -1，然后heappop的时候，将弹出的元素乘以-1即可

import heapq

heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 2)
heapq.heappush(heap, 1)
print(heap)  # 输出为 [1, 3, 2]

# 要想有序输出 堆的元素
heapq.heappop(heap) # 输出1
heapq.heappop(heap) # 输出2
heapq.heappop(heap) # 输出3

# 要想输出前n个最大值，前n个最小值，可以使用
heapq.nlargest(n, heap)
heapq.nsmallest(n, heap)

deque 双端队列

from collections import deque 可以实现栈也可以实现队列的功能，因为双端队列可以在队列的头部和尾部进行编辑，所以我们如果想要在python中实现栈的功能的话，最好的选择是deque，当然我们也可以使用普通的数组结构。

普通的队列操作，就是在队尾插入元素，然后队头弹出元素：

dq = queue()
dq.append(3)  # deque([3])
dq.append(4)  # deque([3, 4])
dq.popleft() # 弹出 3，并且dq为 deque([4])
如果设置为一个栈的话，FILO，那么就是如下的代码

dq = queue()
dq.append(3)  # deque([3])
dq.append(4)  # deque([3, 4])
dq.pop() # 弹出 4，并且dq为 deque([3])

queue

queue队列是一个线程安全的包，这个包里面有很多的结构，比如栈 LifoQueue ，如果要在并发环境下使用的话，最好使用这个结构，因为如果栈为空的情况下，去弹出栈顶元素的话，会出现阻塞现象，知道栈不为空为止

LifoQueue

LifoQueue 是一个栈结构，有入栈和出战操作，方法分别是 put() 和 get()，并且 get() 在 LifoQueue() 为空时会阻塞

from queue import LifoQueue

s = LifoQueue()
s.put(3)
s.put(4)
print(s.get()) # 打印4
print(s.get()) # 打印3
print(s.get()) # 一直等待直到s中存在元素，然后就打印退出

Queue

Queue 是一个队列，有入队和出队操作，方法分别是 put() 和 get()，并且 get() 在 Queue 为空时会阻塞，另外也可以设置队列的长度，如果没有设置队列的长度，或者设置队列的长度为小于等于0的数，那么表示队列的长度为无限，可以通过 .maxsize 属性来获取队列的最大长度

from queue import Queue

q = Queue()
q.put(3)
q.put(4)
print(q.get()) # 打印3
print(q.get()) # 打印4
print(q.get()) # 一直等待直到q中存在元素，然后就打印退出
print(q.get_nowait()) # 如果队列q为空，那么不会等待，而是输出 Empty 的异常

PriorityQueue

PriorityQueue 是一个优先队列，队列的元素是排好序了的，所以针对一个排序的序列可以使用优先队列，它能高效获取最大或最小的元素。
在调度问题的场景中，经常用到优先级队列，它主要有获取最大值或最小值的操作和入队操作
优先队列，是内部封装了 heapq，不同的是优先队列是线程安全的，在并发环境下应该选择使用 PriorityQueue

from queue import PriorityQueue

pq = PriorityQueue()
pq.put((2, 'name'))
pq.put((1, 'age'))
pq.put((3, 'job'))
while not pq.empty():
    print(pq.get())

"""
输出内容如下
(1, "age")
(2, "name")
(3, "job")
"""