C++实现队列：顺序存储、链式存储

最新推荐文章于 2024-05-14 20:33:08 发布
最新推荐文章于 2024-05-14 20:33:08 发布
阅读量818 收藏 9
点赞数 1
文章标签： 队列 数据结构 c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MilkLeong/article/details/104228789
版权

队列(Queue)也是一种运算受限的线性表。它只允许在表的一端进行插入，而在另一端进行删除。允许删除的一端称为队头(front)，允许插入的一端称为队尾(rear)。
例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开队列。因此队列亦称作先进先出(First In First Out)的线性表，简称FIFO表。
当队列中没有元素时称为空队列。在空队列中依次加入元素a1,a2,…an之后，a1是队头元素，an是队尾元素。显然退出队列的次序也只能是a1,a2,…an ，也就是说队列的修改是依先进先出的原则进行的。
队列的示意图如下：
在这里插入图片描述
队列主要是两种实现方式，一是基于数组的顺序存储实现，一是基于链表的链式存储实现。

一、顺序存储实现

在用数组存储队列元素时，通常将队列头放在数组下标小的位置，将队列尾放在数组下标大的位置，并用两个变量Front和Rear分别指示队列的头和尾。可将Front和Rear初始化为0或-1，当有元素入队，Rear向右移动一格，放队尾元素+1；当有元素出队，Front向右移动一格，+1，再删除对头元素。
下图(a)(b)©(d)分别为队列在不同状态时的示意图。（通常，在队列非空的状态下，可使Front始终指向队头元素前一个空间）
在这里插入图片描述
从上图的©图可看出，当随着元素入队出队，队列整体向后移动到一定的程度，便无法再插入元素，尽管数组在对头之前还有很多冗余空间。这种现象叫做“假溢出”。
为解决这个问题，可在顺序存储中采用循环队列的方式：Rear和Front到达数组断点后，能折回数组开始处。
可想象循环队列的结构如下：
在这里插入图片描述
为使Rear和Front能准确传达队列的状态，在对队列进行各种操作时，需要注意Rear和Front的值如何设置：
队空：Q.front =Q. rear
队满： Q.front =(Q.rear + 1) % maxSize
入队: Q.rear = (Q.rear + 1) % maxSize
出队: Q.front = (front + 1) % maxSize;
求队长:(Q.rear-Q.front+maxSize)%maxSize

顺序队列的存储实现：
0.定义顺序队列结构类型

struct SeqQueue
{
    ElementType data[MaxSize];
    int Front,Rear;
};

1.初始化队列

void CreateQueue(SeqQueue *Q)
{
    Q->Front=0;
    Q->Rear=0;
}

2.判断是否队满

bool IsFull(SeqQueue *Q)
{
    return((Q->Rear+1)%MaxSize==Q->Front);
}

3.判断是否队空

bool IsEmpty(SeqQueue *Q)
{
    return(Q->Front==Q->Rear);
}

4.入队：在对尾插入元素X

void InsertQue(SeqQueue *Q,ElementType X)
{
    if(IsFull(Q))
        cout<<"队列满"<<endl;
    else{
        Q->Rear=(Q->Rear+1)%MaxSize; //避免“假溢出”，同时使两者最初所指的内存为空
        Q->data[Q->Rear]=X;
    }
}

5.出队：返回队头元素

ElementType DeleteQue(SeqQueue *Q)
{
    if(IsEmpty(Q)){
        cout<<"队已空"<<endl;
        return 0;
    }
    else{
        Q->Front=(Q->Front+1)%MaxSize;
        return(Q->data[Q->Front]);
    }
}

6.求队长

int LengthQue(SeqQueue *Q)
{
    return((Q->Rear-Q->Front+MaxSize)%MaxSize);
}

以下为一个完整程序，其功能是在队列中存入1~10这10个元素，并依据其存入的先后顺序，将其输出：

#include <iostream>
#define MaxSize 20
using namespace std;
typedef int ElementType;
/*定义顺序队列结构类型*/
struct SeqQueue
{
    ElementType data[MaxSize];
    int Front,Rear;
};

int main()
{
    void CreateQueue(SeqQueue *Q);
    bool IsFull(SeqQueue *Q);
    bool IsEmpty(SeqQueue *Q);
    void InsertQue(SeqQueue *Q,ElementType X);
    ElementType DeleteQue(SeqQueue *Q);
    int LengthQue(SeqQueue *Q);

    SeqQueue Que,*Q;
    Q=&Que;
    CreateQueue(Q);
    for(int i=1;i<11;i++)   //在队列中输入1~10这10个元素
        InsertQue(Q,i);     //求队长
    cout<<"队长="<<LengthQue(Q)<<endl;
    while(!IsEmpty(Q))     //输出
        cout<<DeleteQue(Q)<<' ';

    return 0;
}

/*初始化队列*/
void CreateQueue(SeqQueue *Q)
{
    Q->Front=0;
    Q->Rear=0;
}

/*判断是否队满*/
bool IsFull(SeqQueue *Q)
{
    return((Q->Rear+1)%MaxSize==Q->Front);
}

/*判断是否队空*/
bool IsEmpty(SeqQueue *Q)
{
    return(Q->Front==Q->Rear);
}

/*入队：在对尾插入元素X*/
void InsertQue(SeqQueue *Q,ElementType X)
{
    if(IsFull(Q))
        cout<<"队列满"<<endl;
    else{
        Q->Rear=(Q->Rear+1)%MaxSize; //避免“假溢出”，同时使两者最初所指的内存为空
        Q->data[Q->Rear]=X;
    }
}

/*出队：返回队头元素*/
ElementType DeleteQue(SeqQueue *Q)
{
    if(IsEmpty(Q)){
        cout<<"队已空"<<endl;
        return 0;
    }
    else{
        Q->Front=(Q->Front+1)%MaxSize;
        return(Q->data[Q->Front]);
    }
}

/*求队长*/
int LengthQue(SeqQueue *Q)
{
    return((Q->Rear-Q->Front+MaxSize)%MaxSize);
}

二、链式存储实现

队列的链式存储结构简称为链队列，它是限制仅在表头删除和表尾插入的单链表。显然仅有单链表的头指针不便于在表尾做插入操作，为此再增加一个尾指针，指向链表的最后一个结点。于是，一个链队列由头指针和尾指针唯一确定。
下图为链队在非空和空状态下的示意图：
在这里插入图片描述
如图示，可设链栈的结点类型为QueNode，Front和Rear皆为指向QueNode结点的指针，可设置一个为空的结点（上图紫色结点），初始化时Front和Rear皆指向它，插入和删除操作皆在该节点之后的队列中执行。
所以，定义链队的结构类型有两步：
（1）定义结点类型

struct QueNode
{
    ElementType data;
    QueNode *next;
};

（2）定义指向结点的指针类型

struct LinkQueue
{
    QueNode *Front;
    QueNode *Rear;
};

链队的主要操作如下：
1.初始化

void CreateQueue(LinkQueue *Q)
{
    Q->Front->next=NULL;
    Q->Rear->next=NULL;
}

初始化后的队列大致如上图中的空队列。
需要注意的是，在初始化之前，需要对LinkQueue类型的指针对象的Front和Rear所指向的结点作出声明，如下：

QueNode node;
    LinkQueue *Q;
    Q->Front=&node;
    Q->Rear=&node;

2.判断是否队空

bool IsEmpty(LinkQueue *Q)
{
    return(Q->Front->next==NULL && Q->Rear->next==NULL);
}

3.入队：在队尾插入元素X

void InsertQue(LinkQueue *Q,ElementType X)
{
    QueNode *p;
    p=new QueNode;
    p->data=X;
    p->next=NULL;
    if(IsEmpty(Q))
        Q->Front->next=Q->Rear=p;
    else{
        Q->Rear->next=p;
        Q->Rear=p;
    }
}

4.出队：返回队头元素

ElementType DeleteQue(LinkQueue *Q)
{
    ElementType x;
    QueNode *p;
    if(IsEmpty(Q)){
        cout<<"队空"<<endl;
        return 0;
    }
    p=Q->Front->next;
    x=p->data;
    Q->Front->next=p->next;
    if(Q->Rear==p)
        Q->Rear=Q->Front;
    delete p;
    return(x);

}

以下为一个完整程序，其功能是在队列中存入1~10这10个元素，并依据其存入的先后顺序，将其输出：

#include <iostream>
using namespace std;
typedef int ElementType;
/*定义链队结构类型*/
struct QueNode
{
    ElementType data;
    QueNode *next;
};
struct LinkQueue
{
    QueNode *Front;
    QueNode *Rear;
};

int main()
{
    void CreateQueue(LinkQueue *Q);
    bool IsEmpty(LinkQueue *Q);
    void InsertQue(LinkQueue *Q,ElementType X);
    ElementType DeleteQue(LinkQueue *Q);

    QueNode node;
    LinkQueue *Q;
    Q->Front=&node;
    Q->Rear=&node;
    CreateQueue(Q);
    for(int i=1;i<11;i++)   //在队列中输入1~10这10个元素
        InsertQue(Q,i);     //求队长
    while(!IsEmpty(Q))     //输出
        cout<<DeleteQue(Q)<<' ';

    return 0;
}

/*初始化队列*/
void CreateQueue(LinkQueue *Q)
{
    Q->Front->next=NULL;
    Q->Rear->next=NULL;
}


/*判断是否队空*/
bool IsEmpty(LinkQueue *Q)
{
    return(Q->Front->next==NULL && Q->Rear->next==NULL);
}

/*入队：在对尾插入元素X*/
void InsertQue(LinkQueue *Q,ElementType X)
{
    QueNode *p;
    p=new QueNode;
    p->data=X;
    p->next=NULL;
    if(IsEmpty(Q))
        Q->Front->next=Q->Rear=p;
    else{
        Q->Rear->next=p;
        Q->Rear=p;
    }
}

/*出队：返回队头元素*/
ElementType DeleteQue(LinkQueue *Q)
{
    ElementType x;
    QueNode *p;
    if(IsEmpty(Q)){
        cout<<"队空"<<endl;
        return 0;
    }
    p=Q->Front->next;
    x=p->data;
    Q->Front->next=p->next;
    if(Q->Rear==p)
        Q->Rear=Q->Front;
    delete p;
    return(x);

}
MilkLeong
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
队列顺序存储&链式存储.rar
04-12
中国大学MOOC上浙大的《数据结构》课程队列顺序存储&链式存储实现的代码。包括队列创建、入队、出队。
C/C++数据结构队列的链式存储实现
Qiao_lin的博客
04-08 1201
和循环队列采用数组实现顺序存储不同，队列的链式存储和单链表非常类似，依然带头节点，采用尾插法和头部删除法，代码如下： #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef int Elem; //链表 typedef struct LinkNode { Elem data; struct LinkNode *next; }LinkNode; //队列 typedef stru
C++单链表
我不是秃头的博客
10-25 821
实现单链表的下列功能： 1、 从键盘输入一组数据，创建单链表； 2、 输出单链表； 3、 插入元素，给出插入成功或失败的信息； 4、 头插，给出插入成功或失败的信息； 5、 尾插，给出插入成功或失败的信息； 6、 删除元素，给出插入成功或失败的信息； 7、 头删，给出插入成功或失败的信息； 8、 尾删，给出插入成功或失败的信息； 9、 打印链表长度。
用C++实现线性表的链式存储结构
m0_70940447的博客
06-09 205
C++实现线性表的链式存储
C++数据结构队列的链式存储和循环队列（含完整代码）
qq_63184211的博客
02-10 209
队列的链式存储和循环队列的实现代码。
用固定数组实现队列---C++
wysw1998的博客
06-03 397
用固定数组实现队列 队列顾名思义就是排队的队列，像排队一样先进先出 这里举个例子 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #define max 10 using namespace std; class ArrayQueue { public: ArrayQueue(int len) { this-&g...
C++数据结构——队列
热门推荐
GeekZW的博客
06-26 17万+
C++数据结构——队列参考博客：http://www.cnblogs.com/QG-whz/p/5171123.htmlhttp://www.169it.com/article/2718050585107790752.html1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；（...
数据结构学习：c++实现队列的链式存储结构（链队列）
每天进步一点点
10-18 1827
前面一篇博客实现了如何使用c++实现队列的链式存储结构，参见链接：c++ 实现队列的顺序存储结构 我自己认为无论是线性表、栈还是队列等等结构，链式结构总是要比顺序结构难一点，因为顺序存储结构就是玩数组嘛，数组大家都能玩的转; 但链式结构肯定就有指针，而有了指针，程序必将变得复杂，所以实现起来可能稍微有点困难，但是换句话说，链式不就是玩指针嘛，相信大家指针也一定都一定能玩的转. 话不多说，进入正题：...
C++中队列的顺序存储
肩上风骋的博客
06-21 443
队列先进先出，队头出队，队尾入队，其存储可以分为顺序存储和链式储存。本文记录队列的顺序存储。也就是队列中的元素存储的内存空间是连续的，这里使用数组来模拟线性队列。
队列的顺序与链式存储结构
11-04
队列的顺序与链式存储结构，已在acm通过
栈和队列的顺序存储结构和链式存储结构停车场问题
06-23
车辆按到达先后顺序依次从最里面向大门口停放 。 如果已放满 N 辆车 ， 再来的车辆只能在大门外的便道上等待 ， 一旦有车辆从停车场离开排在便道上的车辆可依次进入停车场 。停车场中某辆车离开时 ， 在它之后进入...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构入门——队列的实现.rar
04-02
队列是一种先进先出的数据结构：即插入在表的一端（队尾）进行，删除在表的另一端（队头）进行 与线性表相似，队列也有顺序储存和链式储存两种储存方法；实现方法和代码在此文档中，详细说明见本人博客
C++——内存池（链式队列）
Tiantian的博客
01-03 374
Mqueue.h #ifndef MQUEUE_H #define MQUEUE_H #include &lt;vector&gt; #include&lt;mutex&gt; //加锁的头文件 #define LEN 10 //mutex m; //一级 &gt;128字节 系统申请 //二级 &lt;128字节 内存管理 //内存池 template&lt;typename T&gt; ...
【数据结构C/C++】详解线性表之链式与顺序存储结构增删改查的实现方式(附代码)
Zhangsama1的博客
07-30 7744
文章目录前言一、顺序存储结构1：建立一个包含数组的结构体2：获得元素（从数组中获取所需元素）3：插入元素4：删除元素二、链式存储结构（方法1）1.创建承载数据的载体2:创建链表2.显示链表数据3：删除链表数据4：插入数据二、链式存储结构（方法2）1：结构体创建2：创建链表3：删除链表4：获取元素5：插入元素6：删除元素推荐学习网站 前言 链表，作为数据结构中非常重要的一种算法，有着诸多用途，因此写下本文记录自己的学习过程。 参考书籍《大话数据结构第二版》 一、顺序存储结构 我们知道，数组最大的特点就.
第94篇 C++数据结构（四）队列
weixin_49188222的博客
04-24 1457
第94篇 C++数据结构（四）队列1.队列简介1.队列的存储结构2.节点3.实现3.1.变量3.2.方法4.测试4.1.测试代码4.2.输出结果5.实现代码6.总结 1.队列简介 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。 1.队列的存储结构 （1）数组：队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针 fro
C++实现队列的顺序存储与链式存储
qq_41696018的博客
08-19 1127
队列是一种特殊的数据存储结构，与栈不同的是(C++实现栈的顺序存储与链式存储)，其数据存储与访问顺序为先进先出，形式如下： 下面附上队列顺序存储与链式存储的实现代码： 1、顺序存储 #include <iostream> using namespace std; const int max_size=1024; //定义队列 class seqqueue { public: void* data[max_size]; int size; }; //初始化队列 se...
C++创建线程实现自动保存队列中的数据
haimianjie2012的专栏
05-16 764
多线程 互斥量mutex CreateMutex()函数可用来创建一个有名或无名的互斥量对象 互斥量： 采用互斥对象机制。互斥锁，像一个物件，这个物件只能同时被一个线程持有。只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。 互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。 WINB...
二叉树专题（有关二叉树的相关学习）
最新发布
aaa114514aaaa的博客
05-14 1597
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
c++队列的顺序存储实现代码
05-23
以下是C++队列顺序存储的实现代码： ```cpp #define MAXSIZE 100 // 队列最大容量 template class Queue { private: T data[MAXSIZE]; // 存储队列元素的数组 int front; // 队头指针 int rear; // 队尾指针 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值