队列与栈（模板）

最新推荐文章于 2023-04-24 19:14:32 发布
最新推荐文章于 2023-04-24 19:14:32 发布
阅读量340 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_lfy/article/details/105524511
版权

栈和队列都属于特殊的线性表
在这里插入图片描述
队列
在这里插入图片描述

#include <iostream>
//循环队列
using namespace std;
const int QueueSize=100;//100示例性数据
template<typename DataType>
class CirQueue
{
    public:
        CirQueue();//初始化空队列
        /*~CirQueue();销毁.
        循环队列是静态存储分配（一维数组形式实现），无需销毁，自动释放*/
        void enQueue(DataType x);//入队
        DataType deQueue();//出队
        DataType getHead();//取出队头元素（并不删除）
        int empty();//判断是否为空队列
    private:
        DataType data[QueueSize];//存放队列元素的数组
        int front,rear;//队头，队尾指针
};
template<typename DataType>
CirQueue<DataType>::CirQueue()
{//队头队尾指针同时指向数组的某一位置（最高端）
    front=rear=QueueSize-1;//或者front=rear=-1；
}
template<typename DataType>
void CirQueue<DataType>::enQueue(DataType x)
{//rear指针后移入队
    if((rear+1)%QueueSize==front) throw"队满，上溢";
    //队满，为了与队空区分，数组中保留一个空闲单元，（rear+1）%QueueSize==front
    rear=(rear+1)%QueueSize;//循环意义下的队尾指针加1
    data[rear]=x;//在队尾插入元素
}
template<typename DataType>
int CirQueue<DataType>::empty()
{
    if(rear==front)
        return 1;
    else return 0;
}
template<typename DataType>
DataType CirQueue<DataType>::deQueue()
{//front指针后移出队
    if(rear==front)throw"队空，下溢";
    front=(front+1)%QueueSize;//循环意义下的加1，front的值改变
    return data[front];//读取并返回出队前的队头元素
}
template<typename DataType>
DataType CirQueue<DataType>::getHead()
{
    if(rear==front)throw"下溢";
    return data[(front+1)%QueueSize];
}
/*取头元素与出队的区别：取头元素不改变队头的位置，front值不变；
出队front的值改变*/
int main()
{
    int x;
    CirQueue<int>Q;
    cout<<"对2和5进行入队操作：";
    Q.enQueue(2);
    Q.enQueue(5);
    cout<<"当前队头元素为："<<Q.getHead()<<endl;
    try
    {
        x=Q.deQueue();
        cout<<"执行一次出队,出队元素为:"<<x<<endl;//2
    }catch(char *str){cout<<str<<endl;}//抛出的异常为一句话
    try
    {
        cout<<"执行一次入队,入队元素为:"<<endl;
        cin>>x;
        Q.enQueue(x);
    }catch(char *str){cout<<str<<endl;}//抛出的异常为一句话
    if(Q.empty()==1)
        cout << "队空" << endl;
    else cout<<"队非空";
    return 0;
}


#include <iostream>
//链队列
using namespace std;
template<typename DataType>
struct Node
{
    DataType data;
    Node<DataType>*next;
};
template<typename DataType>
class LinkQueue
{
    public:
        LinkQueue();
        ~LinkQueue();//动态存储分配，要释放链队列所有结点的存储空间，与单链表的析构函数类似
        void enQueue(DataType x);
        DataType deQueue();
        DataType getHead();
        int empty();
    private:
        Node<DataType>*front,*rear;
};
template<typename DataType>
LinkQueue<DataType>::LinkQueue()
{//初始化只需申请头结点，然后让队头指针和队尾指针都指向头结点。
    Node<DataType>*s=NULL;
    s=new Node<DataType>;//申请结点s
    s->next=NULL;//让s的指针域为空
    rear=front=s;//将队头队尾指针都指向头结点s
}
template<typename DataType>
LinkQueue<DataType>::~LinkQueue()
{
    Node<DataType>*q=NULL;//工作指针
    while(front!=NULL){//释放队列的每一个结点的存储空间
        q=front;//暂存被释放结点
        front=front->next;//指向被释放结点的下一个结点
        delete q;
    }
}
template<typename DataType>
void LinkQueue<DataType>::enQueue(DataType x)
{
    Node<DataType>*s=NULL;
    s=new Node<DataType>;//申请要入队的新结点s
    s->data=x;s->next=NULL;
    rear->next=s;//原来的队尾结点指向新的结点
    rear=s;//新的结点成为rear
}
template<typename DataType>
DataType LinkQueue<DataType> ::deQueue()
{
    DataType x;//存放那个出队结点的数据域
    if(rear==front)throw"队空，下溢";
    Node<DataType>*q=NULL;
    q=front->next;x=q->data;//暂存放队头元素
    front->next=q->next;//将队头元素所在结点摘链
    if(q->next=NULL)rear=front;//若是最后一个结点，要修改队尾指针，出队前队列长度为1
    delete q;
    return x;
}
template<typename DataType>
DataType LinkQueue<DataType>:: getHead()
{//取队头元素，返回第一个元素结点的数据域
    if(rear==front)throw"队空，下溢";
    return front->next->data;
}
template<typename DataType>
int LinkQueue<DataType>::empty()
{//判空，判断front是否==rear
    if(front==rear)return 1;
    return 0;
}
int main()
{
    int x;
    LinkQueue<int>Q;
    cout<<"对3和4进行入队操作：";
    Q.enQueue(3);
    Q.enQueue(4);
    cout<<"当前队头元素为："<<Q.getHead()<<endl;
    try
    {
        x=Q.deQueue();
        cout<<"执行一次出队操作,出队元素为："<<x<<endl;//3
    }catch(char *str){cout<<str<<endl;}
    if(Q.empty()==1)cout<<"队空！"<<endl;
    else cout << "队非空!" << endl;
    return 0;
}

栈
在这里插入图片描述

#include <iostream>
//顺序栈
using namespace std;
const int StackSize=10;
template <typename DataType>
class SeqStack
{
    public:
        SeqStack();
        ~SeqStack();
        int empty();
        void push(DataType x);
        DataType pop();
        DataType getTop();
    private:
        int top;
        DataType data[StackSize];
};
template <typename DataType>
SeqStack<DataType>::SeqStack()
{//初始化，将top置-1
    top=-1;
}
template <typename DataType>
SeqStack<DataType>::~SeqStack()
{//静态存储，自动释放

}
template <typename DataType>
int SeqStack<DataType>::empty()
{
    if(top==-1)return 1;
    return 0;
}
template <typename DataType>
DataType SeqStack<DataType>::pop()
{//出栈，先取出栈顶元素，再修改top位置
    DataType x;//存放top的值
    if(top==-1)throw"下溢";
    x=data[top];
    top--;
    //x=data[top--];
    return x;
}
template <typename DataType>
DataType SeqStack<DataType>::getTop()
{//取栈顶元素，不改变top位置，只是取值
    if(top==-1)throw"下溢";
    return data[top];
}
template <typename DataType>
void SeqStack<DataType>::push(DataType x)
{//入栈，先改变top栈顶的位置，再使用top的值
    if(top==StackSize-1)//下标是从0开始的，最后一个stacksize-1
        throw"上溢";
    top++;
    data[top]=x;//data[++top]=x;
}
int main()
{
    SeqStack<int>S;
    try
    {   S.push(1);
        S.push(2);
        int x;
        x=S.pop();
        cout<<"出栈元素为："<<x<<endl;
    }catch(char* str){cout<<str<<endl;}
    cout<<"当前栈顶元素为："<<S.getTop()<<endl;
    if(S.empty()==1)cout << "栈空!" << endl;
    cout<<"栈非空！"<<endl;
    return 0;
}

#include <iostream>
//链栈
using namespace std;
template <typename DataType>
struct Node
{
    DataType data;
    Node<DataType>*next;
};
template <typename DataType>
class   LinkStack
{
    public:
        LinkStack();
        ~LinkStack();
        int empty();
        void push(DataType x);
        DataType pop();
        DataType getTop();
    private:
        Node<DataType>* top;
};
template <typename DataType>
LinkStack<DataType>::LinkStack()
{//初始化，无头结点（因为是单一端操作）将top置空
    top=NULL;
}
template <typename DataType>
LinkStack<DataType>::~LinkStack()
{//动态存储，释放
    Node<DataType>*p=NULL;
    while(p!=NULL)
    {
        p=top;
        top=top->next;
        delete p;
    }
}
template <typename DataType>
int LinkStack<DataType>::empty()
{
    if(top==NULL)return 1;
    return 0;
}
template <typename DataType>
DataType LinkStack<DataType>::pop()
{//出栈
    DataType x;//存放被删top的值
    Node<DataType>*p=NULL;
    if(top==NULL)throw"下溢";
    x=top->data;p=top;
    top=top->next;//栈顶结点摘链
    delete p;
    return x;
}
template <typename DataType>
DataType LinkStack<DataType>::getTop()
{//取栈顶元素，不改变top位置，只是取值
    if(top==NULL)throw"下溢";
    return top->data;
}
template <typename DataType>
void LinkStack<DataType>::push(DataType x)
{//入栈
   Node<DataType>*p=NULL;
   p=new Node<DataType>;//申请一个新的结点p
   p->data=x;//新结点p的数据域为x
   p->next=top;//新结点p指向top
   top=p;//新结点p成为top
}
int main()
{
    int x;
	LinkStack<int> S;
    	cout << "对15和10执行入栈操作，";
	S.push(15); S.push(10);
	cout << "当前栈顶元素为：" << S.getTop( ) << endl;
	try {
      	x=S.pop( );
	  	cout << "执行一次出栈操作，删除元素：" << x << endl;
	} catch(char* str){cout << str << endl;   }
    try
    {
        cout << "请输入待插入元素：";
      	cin >> x;
      	S.push(x);
      } catch(char* str){cout << str << endl;     }
      if (S.empty( ) == 1) cout << "栈为空" << endl;
      else cout << "栈非空" << endl;
      return 0;
}

总结：
在这里插入图片描述

砂小糖
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++循环队列与链队列基本操作的实现
qq_60462402的博客
04-23 3239
队列定义 队列，一种特殊的线性表，乍一看总觉得和栈有那么千丝万缕的联系。事实上，队列的确与栈非常类似，但它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列–队列的顺序表示与实现 就是与顺序表对应的队列类型，使用一组连续的存储单元依次存放队列从头到尾的元素，同时使用两个整型变量：front（头指针）与rear（尾指针）分别指示队首元素和队尾元素。 循环队列存储结构表示 typ
队列的链式和顺序存储及其相关操作
qq_63010894的博客
05-15 445
目录一、链式存储1.结构体的定义2.初始化3.入队4.出队5.打印元素6.完整代码7.运行结果二、顺序存储1.结构体的定义2.初始化3.判断队列是否已满4.判断队列是否为空5.入队6.1 出队：(法一）6.2 出队：(法二)7.获取队首元素8.获取队长9.打印10.清空队列11.完整代码12.测试结果三、总结 一、链式存储 1.结构体的定义 typedef struct Queue_Node { DataType data; Queue_Node* next; }*QueueNodePtr; type
5-1链队入队出队操作
m0_61630188的博客
05-16 870
链队基本操作。 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 typedef int Status; typedef char QElemType; typedef struct QNode { QElemType data; struct QNode *next; } QNode, *QueuePtr; typedef struct { QueuePtr front;
数据结构（五）、C++链表实现队列
weijianjain的博客
11-21 607
【代码】数据结构（五）、C++链表实现队列。
链队列（入队和出队操作）
qq_73931224的博客
04-24 570
出队操作：创建一个节点p指向队列的第一个节点，p=front->next，front->next=p->next,需要注意的是如果只有一个节点时，出队后，rear=front，两个指针都指向头结点。入队操作：创建一个新节点p存储入队元素，rear->next=p，rear=p。链队列有两个指针：front指向头结点，rear指向最后一个节点。链队列的特点：先进先出。
数据结构队列和栈的模板实验
11-16
本实验“数据结构队列和栈的模板实验”着重于使用模板实现这些数据结构，以实现对不同类型数据的通用处理。 1. **队列**： - **定义**：队列是一种先进先出（FIFO，First In First Out）的数据结构，元素在队列的...
C++利用链表模板类实现简易队列
08-26
C++利用链表模板类实现简易队列 本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，...
队列实现栈_栈_数据结构_队列_
09-30
在C++中，可以使用标准模板库（STL）中的`stack`容器来实现栈的操作。 队列则是一种先进先出（FIFO，First In First Out）的数据结构，常见的操作有入队（enqueue）元素到队尾和出队（dequeue）队首元素。C++中的`...
栈与队列.zip
最新发布
04-06
在实际编程中，栈和队列常与其他数据结构结合使用，如栈与队列的组合可以实现优先队列，通过调整元素的入栈和出栈顺序来达到优先级的处理。此外，它们也是图论算法（如深度优先搜索DFS和广度优先搜索BFS）中的关键...
队列与栈c++1111111111111111
09-10
在C++中，可以使用标准模板库（Standard Template Library，简称STL）中的`queue`容器来实现队列。例如： ```cpp #include #include int main() { std::queue<int> myQueue; // 入队 myQueue.push(1); ...
【数据结构】队列（queue）-链队列（图解、c++、java）
扑腾的江鱼复习仓库
01-20 2486
URLeisure的链队列“完美”复习资料。
C++数据结构——链队列（基本代码实现与案例）
eyes++的博客
06-19 601
基本代码实现 #include<iostream> using namespace std; enum error_code{ success, underflow }; struct node{ int data; node* next; }; class linkQueue{ public: linkQueue(); ~linkQueue(); bool empty()const; // 判断是否为空 int getCount()const; // 得到队列长
数据结构——队列的定义与顺序实现（初始化，入队，出队，获取队头元素，判空，判满）C/C++实现
m0_63339166的博客
10-05 1616
2.大胆的将rear指向的那块内存单元存入数据，则变成rear == front,那么就导致队空和队满时rear == front条件一样，无法判断。即栈满的条件是：rear的下一个指向是front了，但此时会浪费掉一个内存单元，即此时rear指向的这个。但是这种判断队满的方式浪费了一个存储单元（即栈满时rear所指向的这个单元不会再放数据） ，为解决这个问题，以下两种判断队满的方式）就可以通过新的方式判空（size == 0）,判满（size == MAX_BUF) ，队内元素个数为size;
C/C++ 队列的出队入队单链表实现（完整代码）
SanpTap的博客
06-15 4775
队列的C/C++实现逻辑比较简单，用单链表实现队列的创建、入队、出队和判断队列是否为空操作，这里直接贴代码了。 /* 完整代码 */ #include <iostream> using namespace std; typedef struct queue { int val; struct queue* next; }Queue; void Init(...
链式队列的基本操作
qq_42698696的博客
11-10 1307
/* run this program using the console pauser or add your own getch, system("pause") or input loop *///链式队列的构造，遍历等基本操作 /*  问题：                         1.初始化无法运行，下一步没有进行                         2.加上初始化...
Java创建链式队列
weixin_46911891的博客
04-03 281
Java创建链式队列 更改成了可以互动的创建形式 来源：https://blog.csdn.net/jiutianhe/article/details/18606295?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161741230116780357231415%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=1617412301167
C++ 循环出队问题
田螺姑娘的博客
04-12 432
C++ 循环出队问题 源代码 struct ListNode { ListNode* next; int val; }; //循环出队，size表示当前的总数据，比如13（1，2，3，...，13） //startIndex表示从起始位置 //k表示从哪个数开始出队 //例如：13，4，1 //则出对列表：4 5 6 7 8 9 10 11 12 13 1 2 3 void PushQueue(int size, int startIndex, int k) { ListNode* pStart
C++ 清空队列(queue)的几种方法
Blog
12-23 3946
说明：C++中的queue自身不支持clear操作，但双端队列deque是支持clear操作的。 方法一：直接用空的队列对象赋值 queue<int> q1; //process //…… q1=queue<int>(); 方法二：遍历出队列 while(!Q.empty()) { Q.pop(); } 方法三：使用swap实现 使用swap定义clear，保持ST...
掌握算术运算符优先级与栈队列原理
队列则没有在文中直接给出，但可以推测后续章节会介绍另一种线性数据结构，与栈不同的是，队列遵循先进先出(FIFO，First In First Out)原则，允许在两端进行操作，一端用于入队(Enqueue)，另一端用于出队(Dequeue)。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值