栈和队列的基本操作（c++实现）

（1）编程实现顺序栈和链栈的基本操作：建栈，取栈顶元素，入栈，出栈；
（2）编程实现循环队列和链队列的基本操作：建队列，取队头元素，入队，出队。

1.顺序栈

#include<iostream>
using namespace std;
#define MAXSIZE 5
typedef struct{
    int *base;
    int *top;
    int stacksize;
}SqStack;
void InitStack(SqStack &s);
void GetTop(SqStack s);
void Push(SqStack &s,int n);
void Pop(SqStack &s,int n);

int main(){
    SqStack s;
    int n;
    InitStack(s);
    cout<<"请输入入栈的个数（栈最大为5）：";
    cin>>n;
    Push(s,n);
    cout<<"请输入出栈的个数：：";
    cin>>n;
    Pop(s,n);
    GetTop(s);
    return 0;
}
//初始化顺序栈
void InitStack(SqStack &s){
    s.base=new int[MAXSIZE];
    s.top=s.base;
    s.stacksize=MAXSIZE;
}
//取栈顶元素
void GetTop(SqStack s){
    if(s.base!=s.top){
        cout<<"栈顶元素为："<<*(s.top-1)<<endl;
    }else{
        cout<<"栈为空，无栈顶元素"<<endl;
    }
}
//入顺序栈
void Push(SqStack &s,int n){
    int e;
    if(s.top-s.base==s.stacksize){
        cout<<"栈满了"<<endl;
    }else{
        cout<<"进栈的值为："<<endl;
        for(int i=0;i<n;i++){
            cin>>e;
            *s.top++=e;
            if(s.top-s.base==s.stacksize){
                cout<<"栈满了，不能进栈了"<<endl;
                break;
            }
        }
    }
}
//出顺序栈
void Pop(SqStack &s,int n){
    int e;
    if(s.base==s.top){
        cout<<"栈为空"<<endl;
    }else{
        cout<<"出栈的值为："<<endl;
        for(int i=0;i<n;i++){
            e=*--s.top;
            cout<<e<<" ";
            if(s.base==s.top){
                cout<<"栈为空，不能出栈了"<<endl;
                break;
            }
        }
        cout<<endl;
    }
}

2.链栈

#include<iostream>
using namespace std;
typedef struct StackNode{
    int data;
    struct StackNode *next;
}StackNode,*LinkStack;
void InitStack(LinkStack &s);
void GetTop(LinkStack s);
void Push(LinkStack &s,int e);
void Pop(LinkStack &s);

int main(){
    LinkStack s;
    int e;
    InitStack(s);
    Push(s,e);
    Push(s,e);
    Pop(s);
    GetTop(s);
    return 0;
}
//初始化链栈
void InitStack(LinkStack &s){
    s=NULL;
}
//取栈顶元素
void GetTop(LinkStack s){
    if(s!=NULL){
        cout<<"栈顶元素为："<<s->data<<endl;
    }else{
        cout<<"无栈顶元素"<<endl;
    }

}
//进链栈
void Push(LinkStack &s,int e){
    LinkStack p=new StackNode;
    cout<<"入栈的值为：";
    cin>>e;
    p->data=e;
    p->next=s;
    s=p;
}
//出链栈
void Pop(LinkStack &s){
    int e;
    LinkStack p=new StackNode;
    if(s==NULL){
        cout<<"链栈为空"<<endl;
    }else{
        p=s;
        s=s->next;
        e=p->data;
        cout<<"出栈的值为："<<e<<endl;
        delete p;
    }
}

3.循环队列

#include<iostream>
using namespace std;
#define MAXQSIZE 5
typedef struct{
    int *base;
    int front;
    int rear;
}SqQueue;
void InitQueue(SqQueue &s);
void GetFront(SqQueue s);
void EnQueue(SqQueue &s);
void DeQueue(SqQueue &s);

int main(){
    SqQueue s;
    InitQueue(s);
    EnQueue(s);
    EnQueue(s);
    DeQueue(s);
    GetFront(s);
    return 0;
}
//初始化循环队列
void InitQueue(SqQueue &s){
    s.base=new int[MAXQSIZE];
    s.front=s.rear=0;
}
//取队头元素
void GetFront(SqQueue s){
    if(s.front!=s.rear){
        cout<<"队头元素为："<<s.base[s.front]<<endl;
    }else{
        cout<<"循环队列为空，无队头元素"<<endl;
    }
}
//入循环队列
void EnQueue(SqQueue &s){
    int e;
    if(s.front==((s.rear+1)%MAXQSIZE)){
        cout<<"队列满了无法入队"<<endl;
    }else{
        cout<<"输入入队的值：";
        cin>>e;
        s.base[s.rear]=e;
        s.rear=(s.rear+1)%MAXQSIZE;
    }
}
//出循环队列
void DeQueue(SqQueue &s){
    int e;
    if(s.front==s.rear){
        cout<<"队列空了无法出队"<<endl;
    }else{
        e=s.base[s.front];
        s.front=(s.front+1)%MAXQSIZE;
        cout<<"出队的值为："<<e<<endl;
    }
}

4.链队

#include<iostream>
using namespace std;
typedef struct QNode{
    int data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
void InitQueue(LinkQueue &q);
void GetFront(LinkQueue q);
void EnQueue(LinkQueue &q);
void DeQueue(LinkQueue &q);

int main(){
    LinkQueue q;
    InitQueue(q);
    EnQueue(q);
    EnQueue(q);
    DeQueue(q);
    GetFront(q);
    return 0;
}
//初始化链队
void InitQueue(LinkQueue &q){
    q.front=q.rear=new QNode;
    q.front->next=NULL;
}
//取队头元素
void GetFront(LinkQueue q){
    if(q.front==q.rear){
        cout<<"链队为空"<<endl;
    }else{
        cout<<"队头元素为："<<q.front->next->data<<endl;
    }
}
//入链队
void EnQueue(LinkQueue &q){
    int e;
    QueuePtr s=new QNode;
    cout<<"入队的值为：";
    cin>>e;
    s->data=e;
    q.rear->next=s;
    q.rear=s;
}
//出链队
void DeQueue(LinkQueue &q){
    int e;
    if(q.front==q.rear){
        cout<<"链队为空"<<endl;
    }else{
        QueuePtr s;
        s=q.front->next;
        e=q.front->next->data;
        q.front->next=s->next;
        if(s==q.rear){
            q.rear=q.front;
        }
        cout<<"出队的值为："<<e<<endl;
        delete s;
    }
}