队列和堆栈
队列和栈是常用和重要的数据结构。队列只允许在表的一端插入,在另一端删除,允许插入的一端叫做队尾,允许
除的一端叫做队头,是一种先进先出线性表。栈只允许在表的一端进行插入和删除操作,是一种后进先出的线性表
常用函数:
(1)构造函数
queue(class T, class Container=deque<T>);创建元素类型为T的空队列,默认容器是 deque
stack(class T, class Container=deque<T>);创建元素类型为T的空堆栈,默认容器是deque
(2)操作函数
队列和堆栈共有函数:
bool empty(); 如果队列(堆栈)为空返回true,否则返回false
int size(); 返回队列(堆栈)中元素数量
void push(const T& t); 把t元素压入队尾(栈顶)
void pop(); 当队列(栈)非空情况下,删除队头(栈顶)元素
队列独有函数:
T& front(); 当队列非空情况下,返回队头元素引用
T& back(); 当队列非空情况下,返回队尾元素引用
堆栈独有函数:
T& top(); 当栈非空情况下,返回栈顶元素的应用
容器适配器:
能成为queue基本容器类Container的条件是它应当支持size,empty,push_back,pop_front,front,back方法
可对数据的两端分别进行插入、删除操作,而deque、list都具有这些函数,所以它们可成为queue的基本容
类Container;能成为stack基本容器类Container的条件是它应当支持size,empty,push_back, pop_back,bac
方法,可对数据的一端进行插入、删除操作,而deque、list、vector都具有这些函数,所以它们可成为stack的
本容器类Container。注意:vector不能作为queue的基本容器类,因为vector没有pop_front方法。
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<stack>
using namespace std;
/*
void PrintStack(stack<int,vector<int> >obj)
{
while(!obj.empty())
{
cout<<obj.top()<<"\t";
obj.pop();
}
cout<<endl;
}
void PrintStack(stack<string,list<string> >obj)
{
while(!obj.empty())
{
cout<<obj.top()<<"\t";
obj.pop();
}
cout<<endl;
}*/
template<class T,class Container> //模板
void PrintStack(stack<T,Container>obj)
{
while(!obj.empty())
{
cout<<obj.top()<<"\t";
obj.pop();
}
cout<<endl;
}
int main()
{
stack<int,vector<int> >s;
for(int i=0;i<4;i++)
{
s.push(i+1);
}
PrintStack(s);
string str="a";
stack<string,list<string> >t;
for(int i=0;i<4;i++)
{
t.push(str);
str+="a";
}
PrintStack(t);
stack<float,deque<float> >u;
for(int i=0;i<4;i++)
{
u.push(i+1);
}
PrintStack(u);
return 0;
}
PrintStack函数参数是复制类型,不能写成引用类型,例如写成PrintStack(stack<int,vector<int> >&obj)
,则当该函数执行时实参和形参都指向形同的实体,函数指向完后堆栈变成空的了,相当与原来堆栈实体内容变了,因此是错误的。
Queue基本函数操作示例
#include<iostream>
#include<string>
#include<list>
#include<deque>
#include<queue>
using namespace std;
template<class T,class Container>
void PrintQueue(queue<T,Container>obj)
{
while(!obj.empty())
{
cout<<obj.front()<<"\t";
obj.pop();
}
cout<<endl;
}
int main()
{
string str="a";
queue<string,deque<string> >t;
for(int i=0;i<4;i++)
{
t.push(str);;
str+="a";
}
PrintQueue(t);
queue<float,list<float> >u;
for(int i=0;i<4;i++)
{
u.push(i+1);
}
PrintQueue(u);
return 0;
}
编一个固定大小的堆栈类。
分析:标准模板库中stack中元素个数没有限制,与题意不符,那么如何既能用上stack固有功能,又能加
特有的限制呢,其实在这句话中已经体现出了具体思路:(1)从stack派生出自己定义的堆栈类mystack。
这样,mystack类就继承了stack的固有特性;(2)在mystack类中加入特有的功能,题意中要求限制
小,那么一方面要定义一个成员变量m_nMaxSize,通过构造函数传入堆栈大小,并赋给m_nMaxSize;另
方面要重载push函数,如果当前堆栈元素个数小于m_nMaxSize,则把新元素压入堆栈。
#include<iostream>
#include<deque>
#include<stack>
using namespace std;
template<class T,class Container=deque<T> >
class mystack:public stack<T,Container>
{
private:
int MaxSize;
public:
mystack(int Size)
{
MaxSize=Size;
}
void push(const T &t)
{
if(this->size()<MaxSize)
{
stack<T,Container>::push(t);
}
else
{
cout<<"stack is fill"<<endl;
}
}
};
int main()
{
mystack<int,deque<int> >obj(2);
obj.push(1);
obj.push(2);
obj.push(3);
return 0;
}