【队列 & 栈】(一) 队列：先入先出的数据结构

最新推荐文章于 2023-08-10 21:22:55 发布
最新推荐文章于 2023-08-10 21:22:55 发布
阅读量651 收藏 1
点赞数
分类专栏： 【LeetCode笔记】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39478403/article/details/106858468
版权

目录

一、先入先出的数据结构 

二、队列 - 实现

三、循环队列

四、设计循环队列

4.1 题目要求

4.2 解决过程

五、循环队列 - 实现

六、队列 - 用法

七、数据流中的移动平均值 (PLUS 会员专享)

一、先入先出的数据结构 

 

文章链接：https://leetcode-cn.com/explore/learn/card/queue-stack/216/queue-first-in-first-out-data-structure/862/ 

二、队列 - 实现

// C++ implementation
#include <iostream>

class MyQueue {
    private:
        // store elements
        vector<int> data;       
        // a pointer to indicate the start position
        int p_start;            
    public:
        MyQueue() {p_start = 0;}
        /** Insert an element into the queue. Return true if the operation is successful. */
        bool enQueue(int x) {
            data.push_back(x);
            return true;
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        bool deQueue() {
            if (isEmpty()) {
                return false;
            }
            p_start++;
            return true;
        };
        /** Get the front item from the queue. */
        int Front() {
            return data[p_start];
        };
        /** Checks whether the queue is empty or not. */
        bool isEmpty()  {
            return p_start >= data.size();
        }
};

int main() {
    MyQueue q;
    q.enQueue(5);
    q.enQueue(3);
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
}

 

文章链接：https://leetcode-cn.com/explore/learn/card/queue-stack/216/queue-first-in-first-out-data-structure/863/ 

三、循环队列

四、设计循环队列

4.1 题目要求

 

4.2 解决过程

法一：在构造函数中初始化三个属性成员：self._data 表示元素全初始化为 None 的 k 长度循环队列主体，使用列表推导式 [None for _ in range(k)] 会比使用 [None] * k 更高效且安全些；self._size 表示循环队列当前有效长度，初始长度为 0；self._front 表示循环队列当前队首的索引，从 0 开始。

除了题目要求实现的各方法，再附带一个 __len__() 方法用于 len() 函数查看循环队列长度。此外，还可在构造函数中增加属性成员 self.capacity = k 来取代 len(self._data) 获取循环队列容限 k，两种操作的复杂度均为 O(1)。

2020/06/22 - 96.67% - 最佳

# Python implementation
class MyCircularQueue:
    def __init__(self, k: int):
        """
        Initialize your data structure here. Set the size of the queue to be k.
        """
        self._data = [None for _ in range(k)]  # 初始化固定长度为k的队列
        self._size = 0  # 当前队列元素数
        self._front = 0  # 队首 index   
    
    def __len__(self) -> int:
        """
        Return the number of elements in the queue.
        """
        return self._size
    
    def isEmpty(self) -> bool:
        """
        Checks whether the circular queue is empty or not.
        """
        return self._size == 0

    def isFull(self) -> bool:
        """
        Checks whether the circular queue is full or not.
        """
        return self._size == len(self._data)

    def enQueue(self, value: int) -> bool:
        """
        Insert an element into the circular queue. Return true if the operation is successful.
        """
        if not self.isFull():
            end = (self._front + self._size) % len(self._data)  # 队尾后一位 index
            self._data[end] = value  # 入队
            self._size += 1  # 当前队列元素数 + 1
            return True  # 成功插入则返回 True
        else:
            return False
        
    def deQueue(self) -> bool:
        """
        Delete an element from the circular queue. Return true if the operation is successful.
        """
        if not self.isEmpty():
            self._data[self._front] = None  # 队首元素删除
            self._front = (self._front + 1) % len(self._data)  # 队首 index 后移一位
            self._size -= 1  # 当前队列元素数 - 1
            return True  # 成功删除则返回 False
        else:
            return False
        
    def Front(self) -> int:
        """
        Get the front item from the queue.
        """
        if not self.isEmpty():
            return self._data[self._front]  # 返回队首元素
        else:
            return -1  # 队列为空返回 -1
        
    def Rear(self) -> int:
        """
        Get the last item from the queue.
        """
        if not self.isEmpty():
            rear = (self._front + self._size - 1) % len(self._data)  # 队尾 index, 注意区别于 end
            return self._data[rear]  # 返回队尾元素
        else:
            return -1  # 队列为空返回 -1
        
# ----------------------------------------------------------------------------------------------------
# Your MyCircularQueue object will be instantiated and called as such:
# obj = MyCircularQueue(k)
# param_1 = obj.enQueue(value)
# param_2 = obj.deQueue()
# param_3 = obj.Front()
# param_4 = obj.Rear()
# param_5 = obj.isEmpty()
# param_6 = obj.isFull()

五、循环队列 - 实现

// C++ implementation
class MyCircularQueue {
private:
    vector<int> data;
    int head;
    int tail;
    int size;
public:
    /** Initialize your data structure here. Set the size of the queue to be k. */
    MyCircularQueue(int k) {
        data.resize(k);
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    bool enQueue(int value) {
        if (isFull()) {
            return false;
        }
        if (isEmpty()) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    bool deQueue() {
        if (isEmpty()) {
            return false;
        }
        if (head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    int Front() {
        if (isEmpty()) {
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    bool isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    bool isFull() {
        return ((tail + 1) % size) == head;
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * bool param_1 = obj.enQueue(value);
 * bool param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * bool param_5 = obj.isEmpty();
 * bool param_6 = obj.isFull();
 */

文章链接：https://leetcode-cn.com/explore/learn/card/queue-stack/216/queue-first-in-first-out-data-structure/866/

六、队列 - 用法

// C+ implementation
#include <iostream>

int main() {
    // 1. Initialize a queue.
    queue<int> q;
    // 2. Push new element.
    q.push(5);
    q.push(13);
    q.push(8);
    q.push(6);
    // 3. Check if queue is empty.
    if (q.empty()) {
        cout << "Queue is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.
    q.pop();
    // 5. Get the first element.
    cout << "The first element is: " << q.front() << endl;
    // 6. Get the last element.
    cout << "The last element is: " << q.back() << endl;
    // 7. Get the size of the queue.
    cout << "The size is: " << q.size() << endl;
}

以上是 C++ 实现队列，关于 Python 可参照 pythonds 模块中的基本实现，以下是 pythonds.basic.queue 源码：

# Python implementation

>>> import pythonds.basic.queue as Queue
>>> help(Queue)  # 导入模块并查看基本接口
Help on module pythonds.basic.queue in pythonds.basic:

NAME
    pythonds.basic.queue

DESCRIPTION
    # Bradley N. Miller, David L. Ranum
    # Introduction to Data Structures and Algorithms in Python
    # Copyright 2005
    # 
    #queue.py

CLASSES
    builtins.object
        Queue
    
    class Queue(builtins.object)
     |  Methods defined here:
     |  
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  dequeue(self)
     |  
     |  enqueue(self, item)
     |  
     |  isEmpty(self)
     |  
     |  size(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

FILE
    e:\python36\lib\site-packages\pythonds\basic\queue.py

>>> pythonds.basic.queue.__file__  # 找到文件位置查看源码
'E:\\Python36\\lib\\site-packages\\pythonds\\basic\\queue.py'
# Bradley N. Miller, David L. Ranum
# Introduction to Data Structures and Algorithms in Python
# Copyright 2005
# 
#queue.py

class Queue:
    def __init__(self):
        self.items = []

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

    def enqueue(self, item):
        self.items.insert(0,item)

    def dequeue(self):
        return self.items.pop()

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

七、数据流中的移动平均值 (PLUS 会员专享)

何处闻韶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
先进先出的数据结构--------队列（基于数组）
q793145253的博客
09-30 627
队列是一种限定存取位置的线性表，只允许在表的一段插入，在另一端删除 队列的存储表示也有两种，一种是基于数组，一种是基于链表 1、基于数组的队列会出现假溢出的情况，由于队列特性会导致数组前端可能还有空位置。 使用循环队列解决上述问题 使用基于数组的循环队列，首尾相接，当队头指针front和队尾指针rear进到maxSize-1后，再前进一个一个位置就自动到0。这可以利用除法求余的运算来实现： 队头的指针进1：front = （front + 1）% maxSize； 队尾的指针进1：rear = （rear
[leetcode] 学习记录:先入先出的数据结构-队列
一边努力一边摸鱼
08-28 350
FIFO FIFO也就是frist in first out，先入先出队列，这是一种传统的按序执行方法，先进入的指令先退出，跟着再执行第二条指令。简单的理解就好像在商场买东西，先排队的顾客先结账，可以先离开。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190828143232760.png) 插入操作称为入队，每次插入一个新的元素都会在队列的末尾插入。 ...
SPL数据结构之队列 First In First Out
Sinkiang的博客
08-20 208
//SPL数据结构之队列 $obj = new SplQueue(); $obj-&gt;enqueue('a'); $obj-&gt;enqueue('b'); $obj-&gt;enqueue('c'); print_r($obj);   echo "Bottom:" . $obj-&gt;bottom() . "\n"; echo "Top:" . $obj-&gt;top(...
【力扣】队列（先入先出）&& 栈（后入先出）
m0_73799537的博客
11-14 514
力扣笔记
数据结构之优先队列（priority_queue）的简单认识和使用
qq_51853681的博客
03-27 313
** 数据结构之优先队列（priority_queue）的简单认识和使用 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 (first in, largest out)的行为特征。通常采用堆数据结构来实现。 基本操作 top 访问队头元素 empty 队列是否为空 size 返回队列内元素个数 push 插入元素到队尾 (并排序) emplace 原地构造一个元素并插入队列 pop 弹出
队列：先入先出的数据结构
01-06
先入先出（FIFO） · 理解FIFO和队列的定义 · 实现队列 · 熟悉内置队列结构 · 使用队列解决简单的问题 在FIFO数据结构中，总是优先处理添加到队列中的第一个元素。 队列是典型的FIFO数据结构，插入（insert）...
C++ 数据结构实现两个栈实现一个队列
08-31
在计算机科学中，队列是一种基本的数据结构，遵循先进先出（FIFO）的原则。然而，在某些情况下，使用两个栈来实现一个队列是一种常见的解决方案。这种方法可以减少空间复杂度，并且提高队列的操作效率。 在这个方法...
Java模拟栈和队列数据结构的基本示例讲解
09-02
栈（Stack）遵循“后进先出”（Last In First Out, LIFO）原则，而队列（Queue）则遵循“先进先出”（First In First Out, FIFO）原则。 栈的主要操作包括压栈（Push）和弹栈（Pop）。压栈操作是将一个新的元素放入...
Java数据结构之链表、栈、队列、树的实现方法示例
08-26
队列是一种先入先出的数据结构，元素的添加在队尾，删除在队首。Java中可以使用链表来实现队列。队列的操作包括入队、出队、获取队首元素等。入队可以使用add方法，该方法将元素添加到队尾。出队可以使用remove方法...
【算法与数据结构 06】先进先出的队列 —— 顺序队列 || 循环队列 || 链式队列 大盘点
不积跬步，无以至千里！
08-22 2733
白话数据结构与算法，快速入门！
栈与队列的创建
weixin_52149834的博客
08-10 77
栈满足先进后出原则（FILO），包括初始化（Init）、入栈（Push）、出栈（Pop）、清空（clear）、销毁（Destroy）、栈顶（Top）、计数（count）、是否有剩余（IsEmpty）八个基本函数，下面具体编写一下这八个基本函数。队列满足先进先出原则（FIFO），基本功能与栈一致，这里我主要编写一下初始化（Init）、入栈（Push）、出栈（Pop）函数；首先定义一个链表结构体存储队列的数据data与下一个节点next，再定义一个链式的头节点与尾节点；
数据结构系列——先进先出队列queue
weixin_37620587的博客
09-12 1330
队列数据结构，使用非queue库来实现
C++学习日记之队列模拟
碗的成长记录
04-09 991
项目：
队列——先入先出的数据结构（FIFO）
weixin_45926367的博客
04-30 3818
队列是典型的 FIFO 数据结构。 插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素。 队列的实现 为了实现队列，我们可以使用动态数组和指向队列头部的索引。 如上所述，队列应支持两种操作：入队和出队。入队会向队列追加一个新元素，而出队会删除第一个元素。 所以我们需要一个索引来指出...
队列实现先进先出
Confident_ZYL的博客
03-05 3653
4.1.1分析论证：queue (队列）是一个容器的改编，它实现了一个先进先出的数据结构（FIFO） queue 模板类的定义在头文件中。 与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 定义queue 对象的示例代码如下： queue q1; queue q2; queue 的基本操作有...
队列的实现（JAVA）
wodengniyujiul的博客
03-19 2822
数据结构(JAVA) 中队列的实现
关于Unbounded queue 、 Bounded queue -整理
Fishandbearspaw的博客
10-29 714
可选是否有界队列（optionally-bounded） LinkedBlockingQueue 有界队列 无界队列 ConcurrentLinkedQueue 什么时候用无界队列？ 用无界队列的时候不用担心溢出吗？ 用有界队列的时候 ThreadPoolExecutor-相关 ThreadPoolExecutor的实现，可以使得队列是无界队列。 使用无界队列时，要注意， 核心线程数 X 最大线程数 Y 最大线程数不会生效，因为队列永远不会满。。 ...
【Qt】一文总结Qt高级数据结构【栈和队列】
iriczhao的博客
03-17 4372
一、QQueue ​ QQueue是Qt的一个通用容器类。该类为相同类型的项实现了队列数据结构。队列是先入先出(FIFO)结构。使用enqueue()将项目添加到队列的尾部，并使用dequeue()从头部检索项目。head()函数访问head项，而不需要删除它。 ​ 例如： #include <QCoreApplication> #include <QQueue> #include <QDebug> int main(int argc, char *argv[]) {
队列的链式存储 c++
卖核弹的小男孩 的博客
04-19 277
队列的链式存储 队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出，我们把它简称为链队列。 队头指针指向链队列的头结点，队尾指针指向终端节点。 #include<iostream> using namespace std; template<class T> class node { public: T data; node<T> * nex...
栈和队列是一种数据结构吗
最新发布
04-18
队列（Queue）也是一种具有特定操作规则的线性数据结构，它遵循"先进先出"（First In First Out，FIFO）的原则。队列的操作包括入队（enqueue）和出队（dequeue）。入队将元素放入队尾，出队将队首元素移除。 它们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值