3.2队列

最新推荐文章于 2024-10-12 20:00:42 发布
最新推荐文章于 2024-10-12 20:00:42 发布
阅读量158 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44897707/article/details/119956766
版权

队列

1.队列的定义

队列是一种先进先出的线性表，简称FIFO。

允许插入的一端为队尾（rear），允许删除的一端称为队头（front）。

队列的插入操作，叫做入队，在队头进行入队操作。队列的删除操作，叫做**出队，**在队尾进行出队操作。

栈有三种实现方式，顺序队列和循环队列是用数组实现的，链式队列使用链表实现的。

2.队列的抽象数据类型

队列的常用操作如下：

  • 出队：pop()
  • 入队：push(elem)
  • 获取队头元素：front()
  • 获取队尾元素:back()
  • 判断队列是否为空：empty()
  • 返回队列的大小:size()

2.1顺序队列

**顺序队列是用数组来实现的，数组下标为0的元素作为队头，最后一个元素作为队尾。由于入队是在数组最后一个元素位置进行插入元素不需要移动元素，出队是删除第一个元素后，还需要把后面的所有元素向前移动，**因此，定义一个front指针指向队头元素，rear指针指向队尾元素的下一个位置，当front等于rear时，此队列不是还剩一个元素，而是空队列。

入队的时间复杂度为O(1),出队的时间复杂度为O(n)。

顺序队列的C++实现：

const int SIZE = 100;      //默认构造队列创建的数组的大小
class SeqQueue {
public:
    SeqQueue();            //默认构造
    SeqQueue(int val);     //有参构造
    SeqQueue(const SeqQueue &s);  
    SeqQueue& operator=(const SeqQueue& s);
    ~SeqQueue();           //析构函数
    void pop();            //出队
    void push(int elem);   //入队
    int front();           //返回队头元素
    int back();            //返回队尾元素
    bool empty();          //判断队列是否为空
    int size();            //返回队列的大小
private:
    int* _arr;             //数组地址
    const int _front = 0;  //队头下标,始终是数组下标为0的元素
    int _rear;             //队尾元素下一个位置
};
SeqQueue::SeqQueue() {
    _arr = new int[SIZE];
    _rear = 0;
}
SeqQueue::SeqQueue(int val) {
    _arr = new int[val];
    _rear = 0;
}
SeqQueue::SeqQueue(const SeqQueue& s) {
    this->_arr = new int[s._rear];
    for (int i = 0; i < s._rear; i++) {
        this->_arr[i] = s._arr[i];
    }
    this->_rear = s._rear;
}
SeqQueue::~SeqQueue() {
    if (_arr != nullptr) {
        delete[]_arr;
        _arr=nullptr;
    }
}
SeqQueue& SeqQueue::operator=(const SeqQueue& s) {
    delete[] this->_arr;
    this->_arr = new int[s._rear];
    this->_rear = s._rear;
    for (int i = 0; i < s._rear; i++) {
        this->_arr[i] = s._arr[i];
    }
    return *this;
}
void SeqQueue::pop() {
    if (_front != _rear) {
        for (int i = 0; i < _rear - 1; i++) {
            _arr[i] = _arr[i + 1];
        }
        _arr[_rear--] = 0;
    }
}
void SeqQueue::push(int elem) {
    if (_front == _rear) {
        _arr[0] = elem;
        ++_rear;
    }
    else {
        _arr[++_rear - 1] = elem;
    }
}
int SeqQueue::front() {
    if (_front == _rear) {
        return -1;
    }
    else {
        return _arr[0];
    }
}
int SeqQueue::back() {
    if (_front == _rear) {
        return -1;
    }
    else {
        return _arr[_rear - 1];
    }
}
bool SeqQueue::empty() {
    return _front == _rear;
}
int SeqQueue::size() {
    return (_front == _rear) ? 0 : (_rear);
}

2.2循环队列

队尾插满之后rear指针指向队头，队列这种头尾相接的顺序存储结构称为循环队列。

循环队列也是由数组来实现的。循环队列是在顺序队列基础上的改进，顺序队列出队复杂度为O(n),时间成本很高由于删除一个元素需要移动后面的很多元素，但我们可以不需要移动后面的元素，下面介绍循环队列的思路：

  1. 出队后，先判断队是否为空，再执行front原来指向的元素删除，最后front后移。入队，先判断队是否满，再执行插入元素，最后将rear后移。

    //出队
    _arr[_front] = 0;
    _front = (_front + 1) % _len;
//入队
    _arr[_rear] = elem;
    _rear = (_rear + 1) % _len;

  2. 数组末尾插满之后，rear再重头开始指向数组开头。因此，队的长度要分rear在front之前和之后两种情况讨论。

  3. **front和rear指针相同可能是队列为空或者队列满。**为了区别这种情况，我们保留一个数组元素空间==（由于rear指向队尾后一个元素的下标，如果不留一个元素rear和front指针在队空和队满时都相同。至于为什么rear指向队尾后一个元素，如果不知想队尾后一个元素，当队空和队只有一个元素的时候，rear和front都指向数组第一个元素）==。

  • 由于rear可能比front大也可能比front小，当rear比front大且队满时，队列没有元素出队，且rear指向数组最后一个元素，此时满足(rear+1)%5=front=0.
  • 当rear比front小且队满时，此时队列有元素出队，rear指向数组开头，rear和front中间只隔着一个元素，即rear+1=front，此时，依旧满足(rear+1)%QueueSize=front.结合上面一种情况可得，队列满条件为==(rear+1)%QueueSize=front.==

循环队列的C++代码为：

const int SIZE = 100;
class Queue {
public:
    Queue();
    Queue(int val);
    Queue(const Queue & s);
    Queue& operator=(const Queue & s);
    ~Queue();
    void pop();            //出队
    void push(int elem);   //入队
    int front();           //返回队头元素
    int back();            //返回队尾元素
    bool empty();          //判断队列是否为空
    bool full();           //判断队列是否满
    int size();            //返回队列的大小
private:
    int* _arr;
    int _front;
    int _rear;
    int _len;
};
Queue::Queue() {
    _len = SIZE;
    _arr = new int[SIZE];
    _rear = 0;
    _front = 0;
}
Queue::Queue(int val) {
    _len = val;
    _arr = new int[SIZE];
    _rear = 0;
    _front = 0;
}
Queue::Queue(const Queue& s) {
    _len = s._len;
    _arr = new int[s._len];
    for (int i = 0; i < s._len; i++) {
        _arr[i] = s._arr[i];
    }
    _front = s._front;
    _rear = s._rear;
}
Queue::~Queue() {
    if (_arr != nullptr) {
        delete[]_arr;
        _arr = nullptr;
    }
}
Queue& Queue:: operator=(const Queue& s) {
    if (_arr != nullptr) {
        delete[] _arr;
        _arr = nullptr;
    }
    _len = s._len;
    _arr = new int[s._len];
    for (int i = 0; i < s._len; i++) {
        _arr[i] = s._arr[i];
    }
    _front = s._front;
    _rear = s._rear;
    return *this;
}
bool Queue::empty() {
    if (_arr == nullptr) {
        return -1;
    }
    return (_front==_rear) ? true : false;
}
bool Queue::full() {
    if (_arr == nullptr) {
        return -1;
    }
    return ((_rear + 1) % _len == _front);
}
void Queue::pop() {
    _arr[_front] = 0;
    _front = (_front + 1) % _len;
}
void Queue::push(int elem) {
    if (full()) {
        return;
    } else {
        _arr[_rear] = elem;
        _rear = (_rear + 1) % _len;
    }
}
int Queue::front() {
    if (!empty()) {
        return _arr[_front];
    }  else {
        return -1;
    }
}
int Queue::back() {
    if (this->empty()) {
        return -1;
    }  else {
        return _arr[(_rear+4)%5];
    }
}
int Queue::size() {
    if (_rear == _front) {
        return 0;
    } else if (_rear > _front) {
        return _rear - _front;
    }  else {
        return _len - _front + _rear;
    }
}

​

2.3链式队列

队列的链式存储结构，就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。

空队时，front和rear都指向虚拟头节点，队头指针指向虚拟头节点，队尾指针指向终端结点。入队操作就是在链表尾部插入结点，出队操作就是删除头节点。

链式队列进队、出队的时间复杂度都为O(1).

下面为链式队列的C++代码实现：

class ListQueue{
public:
    struct ListNode{
        int val;
        ListNode *next;
        ListNode(int val):val(val),next(nullptr){}
    };
    ListQueue();           //默认构造
    ~ListQueue();          //析构函数
    void pop();            //出队
    void push(int elem);   //入队
    int front();           //返回队头元素
    int back();            //返回队尾元素
    bool empty();          //判断队列是否为空
    int size();            //返回队列的大小
private:
    ListNode *_front;      //队头指针，队头指针指向虚拟头节点
    ListNode *_rear;       //队尾指针
    int _size;
};
ListQueue::ListQueue(){
    _front=new ListNode(0);//队头指针，元素为0
    _rear=_front;
    _size=0;
}
ListQueue::~ListQueue(){
    ListNode *p=nullptr;
    while(_front!=_rear){
        p=_front;
        _front=_front->next;
        delete p;
    }
}
bool ListQueue::empty(){
    return _front==_rear;
}
void ListQueue::pop(){
    if(_front==_rear){
        return;
    }else{
        ListNode *p=_front->next;
        _front->next=p->next;
        delete p;
    }
    _size--;
}
void ListQueue::push(int elem){
    ListNode *newNode=new ListNode(elem);
    _rear->next=newNode;
    _rear=newNode;
    _size++;
}
int ListQueue::front(){
    if(empty()){
        return -1;
    }else{
        return _front->next->val;
    }
}
int ListQueue::back(){
    if(empty()){
        return -1;
    }else{
        return _rear->val;
    }
}
int ListQueue::size(){
    return _size;
}

3.队列的选用

对于循环队列和链队列的比较，从时间上他们的基本操作时间复杂度都是O(1)。空间上来说，循环队列必须有一个固定的场地，可能有存储个数和空间上的浪费问题。链队不存在这个问题，但是它需要一个指针与会产生空间上的开销。

在确定队列长度最大值的情况下，建议使用循环队列。如果无法预测队列的长度，则用链队列。

123_YQH
关注
专栏目录
队列的抽象数据类型（abstract data type，ADT）
杨春建的博客
09-03 3292
队列（queue）是表。然而，使用队列时插入在一端进行而删除则在另一端进行。  队列模型   队列的基本操作enqueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素 ，和dequeue（出队），它是删除并返回在表的开头（也叫队头（front））的元素。 队列抽象模型： 队列的数组实现   如同栈的情形一样，对于队列而言任何的表的实现都是合法的。像栈一样，对于
3.2消息队列
点点点
08-16 224
消息队列消息队列特点原型代码演示学习总结 消息队列 消息队列：消息的链接表，存放在内核中。 特点 a.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级 （消息中用各种各样的类型，int，char等等） b.消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除 （Linux内核中的内容不会由进程终止而删除） c.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取 （消息是个链表，读取更加的灵活） 原型 int msgget(key_t k
UDT协议实现分析——数据的接收
weixin_34318326的博客
09-21 515
看了UDT中数据发送的部分之后，我们转换一个角度，来看一下接收端...
抽象数据类型-队列
ignorewho的博客
06-10 1184
队列模型：1.在表的末端插入元素(入队)，在表的开头删除元素(出队)，表的末端又叫队尾，表的开头又叫队头队列实现：1.数组实现：使用循环数组的方式来实现队列的插入和删除，具体实现如下-- 1.1定义一个数组theArray、定义头部位置front和尾部位置back 1.2入队在队尾插入元素，即新元素放到back+1位置上，出队弹出队头元素，即弹出front位置上的元素，front位置向后移...
抽象数据类型
yooppa的博客
07-09 254
小结 ●虽然多种简单数据类型在所有的编程语言中已经被实现，但是大多数语言并没有定义复杂的数据类型。抽象数据类型(ADT)是个定义新数据类型、定义该数据类型的操作以及封装数据和操作的包。 ●栈是一种限制线性表，该列表中的添加和删除被限制在称为栈顶的一 端进行。如果我们把一系列数据项插入栈中，然后又移除它们，那么数据的次序就被颠倒了。这个倒排的属性就是栈被称为后进先出(LIFO)的原因。我们定义栈的4种基本操作:建栈、入栈、出栈和空。 ●队列是一种线性表，且数据的插人只能在称为尾部的一端进行，而数据的删除只能在
（十七）深入学习 -- 2. 抽象数据类型
FionaDong的博客
07-22 252
2. 抽象数据类型 按照它的行为而不是它的表示方式定义的类型叫做抽象数据类型(abstract datatype)，其缩写为ADT。 2.1 队列抽象 在程序设计中，模拟一组人排队等候的行为方式的结构叫做队列(queue) 。 基本操作包括： 创建一个新的等候队列。 删除一个已存在的等候队列。 在等候队列末尾加入一个顾客。在程序设计中，在队尾加入一个新项的操作，叫做入队(enqueue)操作。 从队首删除一个顾客。在程序设计中，删除队首项的操作叫做出队(dequeue)操作。 确定一个
3.2 队列
qq_43667537的博客
07-10 364
当队尾指针指向最后一个元素的时候，进行取余运算，由数组下标为9的位置到数组下标为0的位置 如果队头和队尾指针指向同一个位置，则表示队列为空，所以只能牺牲掉一个位置。 当队尾指针指向队尾元素，其初始化：队头指针指向0，队尾指针指向n-1 ......
tp 消息队列
qq_39856096的博客
03-19 502
1.安装 composer require topthink/think-queue 2.配置config/queue.php return [ 'default' => 'database', 'connections' => [ 'sync' => [ 'type' => 'sync', ], 'database' => [ 'type' .
2021-09-12 数据结构与算法 3.2 队列
ice_cream_moon的博客
09-12 238
1、循环队列 头文件 #pragma once #include <stdio.h> #include <stdlib.h> #define maxsize 1024 typedef int datatype; typedef struct { datatype data[maxsize]; int front; int rear; }SeQueue; SeQueue *sq= (SeQueue*)malloc(sizeof(SeQueue)); //生成循环队...
三年级数学下册三乘法3.2队列表演一教学反思素材北师大版20200506188
09-09
《三年级数学下册三乘法3.2队列表演一教学反思》 在教育领域，尤其是在数学教学中，有效的教学策略对于激发学生的兴趣和提升学习效果至关重要。针对三年级数学下册中的三乘法3.2“队列表演一”这一课时的教学反思，...
3.2队列表演(一)——小学生学习课件
11-23
3.2队列表演(一)——小学生学习课件
数据结构-5.2.树的性质
最新发布
ADCvbV的博客
10-12 239
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
数据结构之顺序表——静态顺序表(C语言版)
努力码字中······
10-09 1193
首先我们来介绍一下顺序表的概念：线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 585
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
栈的操作算法实现（数据结构）
m0_61903191的博客
10-09 385
验证性实验内容：编写一个程序sqstack.cpp,实现顺序栈(假设栈中元素类型ElemType为char的各种基本运算，并在此基础上设计一个程序exp3-1.cpp。验证性实验：实现顺序栈各种基本运算的算法掌握栈的存储结构的表示和实现方法。目的：领会顺序栈存储结构和掌握顺序栈中各种基本运算算法设计。(3)依次进栈元素a、b、c、d、e。(2)判断栈s是否非空。(4)判断栈s是否非空。(6)判断栈s是否非空。(5)输出出栈序列。
数据结构-八大排序之堆排序
m0_75163045的博客
10-08 601
原理：1. 利用完全二叉树构建大顶堆2. 堆顶元素和堆底元素进行交换，除堆底元素之外其余元素继续构建大顶堆3. 重复2，直到所有元素都不参与构建 整个数组排序完成完全二叉树：数据从上到下，从左到右排列大顶堆：父节点的值大于或等于其左右孩子的值堆顶元素和堆底元素进行交换数组的形式：完全二叉树：arr [ i ] 的左孩子 arr [ 2i+1 ]arr [ i ] 的右孩子 arr [ 2i+2 ]arr [ i ] 的父节点 arr [ (i-1) / 2 ]大顶堆：arr [ i ] >=
数据结构编程实践20讲(Python版)—07AVL树
AnFany
10-09 1054
数据结构编程实践20讲(Python版)—07AVL树
数据结构：快排
qincjun的博客
10-11 431
注：并不是故意的将所有的快排都列为不稳定；而是边界及判断问题，确实是学习的一大难点。
栈与队列基础概念及运算详解
3.2 队列 队列是一种线性表，允许在表的一端（队尾）进行插入操作，在另一端（队头）进行删除操作。队列的操作包括： - 初始化队列（InitQueue）：创建一个空队列。 - 销毁队列（DestroyQueue）：释放队列占用的内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值