队列与栈（模板）

栈和队列都属于特殊的线性表

队列

#include 
//循环队列
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 
//链队列
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 
//顺序栈
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 
//链栈
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;
}

总结：