【数据结构】栈和队列

内容：
1）编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈
2）编程实现队列的以下基本操作：建队列，取队头元素，入队，出队

实现思路：
① 编写顺序栈的操作。定义顺序栈的数据类型，实现顺序栈初始化、入栈、出栈、取栈顶元素函数
② 编写链栈的操作。定义链栈的数据类型，实现链栈初始化、入栈、出栈、取栈顶元素函数
③ 编写循环队列的操作。定义循环队列数据类型，实现循环队列初始化、求数列长度、入队、出队、取循环队列的队头元素函数。
④ 编写链式队列的操作。定义链式队列数据类型，实现循环队列初始化、入队、出队、取链式队列的队头元素函数。
⑤ 出栈、出队、取栈顶元素、取队头元素记得判空；入栈、入队记得判断是否满。

1、顺序栈

#include <iostream>

using namespace std;

#define MAXSIZE 100  //顺序栈存储空间的初始配量
#define OK 1
#define ERROR 0

typedef int SElemType;

typedef struct
{
    SElemType *base; //栈底指针
    SElemType *top;  //栈顶指针
    int stacksiza;  //栈可用的最大容量
}SqStack;

int InitStack(SqStack &S) //栈的初始化
{
    S.base=new SElemType[MAXSIZE];
    if(!S.base)
        return ERROR;
    S.top=S.base;
    S.stacksiza=MAXSIZE;
    return OK;
}

int Push(SqStack &S,SElemType e)  //入栈
{
    if(S.top-S.base==S.stacksiza)
        return ERROR;
    //*S.top++=e;
    *S.top=e;
    S.top++;
    return OK;
}

int Pop(SqStack &S,SElemType &e)  //出栈
{
    if(S.top==S.base)
        return ERROR;
    //e=*--S.top;
    S.top--;
    e=*S.top;
    return OK;
}

SElemType GetTop(SqStack S)  //取栈顶元素
{
    if(S.base!=S.top)
        return *(S.top-1);
    return NULL;
}
int main()
{
    SqStack S;
    cout<<"0 初始化栈"<<endl;
    cout<<"1 入栈"<<endl;
    cout<<"2 出栈"<<endl;
    cout<<"3 取栈顶元素"<<endl;
    cout<<"    输入负数退出"<<endl;

    while(1)
    {
        int ip;
        cout<<endl;
        cout<<endl;
        cout<<"============================"<<endl;
        cout<<"请输入操作指令："<<endl;
        cin>>ip;
        if(ip<0)
            break;
        else
        {
            switch(ip)
            {
            case 0:
                {
                    int flag=InitStack(S);
                    if(flag)
                        cout<<"初始化成功！"<<endl;
                    else
                        cout<<"初始化失败！"<<endl;
                    break;
                }
            case 1:
                {
                    SElemType e;
                    cout<<"请输入入栈元素：";
                    cin>>e;
                    int flag=Push(S,e);
                    if(flag)
                        cout<<"元素入栈成功!"<<endl;
                    else
                        cout<<"栈元素已满，入栈失败！"<<endl;
                    break;
                }
            case 2:
                {
                    SElemType e;

                    int flag=Pop(S,e);
                    if(flag)
                        cout<<"元素出栈成功,出栈元素为："<<e<<endl;
                    else
                        cout<<"空栈，出栈失败！"<<endl;
                    break;
                }
            case 3:
                {
                    SElemType e=NULL;
                    e=GetTop(S);
                    if(e==NULL)
                        cout<<"空栈，获取栈顶元素失败！"<<endl;
                    else
                        cout<<"栈顶元素为："<<e<<endl;
                    break;
                }
            default:
                {
                    cout<<"操作指令不合法！请重新输入！"<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}

2、循环队列

#include <iostream>

using namespace std;

#define MAXQAIZE 100 //队列可能达到的最大长度

typedef int QElemType;

typedef struct
{
    QElemType *base; //存储空间的基地址
    int front;  //头指针
    int rear;   //尾指针
}SqQueue;

int InitQueue(SqQueue &Q) //初始化
{
    Q.base=new QElemType[MAXQAIZE]; //为队列分配一个最大容量为MAXQSIZE的数组空间
    if(!Q.base)
        return 0;//存储分配失败
    Q.front=Q.rear=0;  //头指针尾指针置为零，队列为空
    return 1;
}

int QueueLength(SqQueue Q)  //求数列长度
{
    return (Q.rear-Q.front+MAXQAIZE)%MAXQAIZE;
}

int EnQueue(SqQueue &Q,QElemType e)  //入队
{
    if((Q.rear+1)==Q.front)  //谓之神在循环意义上加1后等于头指针，表明队满
        return 0;
    Q.base[Q.rear]=e;  //新元素插入队尾
    Q.rear=(Q.rear+1)%MAXQAIZE;  //尾指针后移一位
    return 1;
}

int DeQueue(SqQueue &Q,QElemType &e)  //出队
{
    if((Q.rear)==Q.front)  //判读队空
        return 0;
    e=Q.base[Q.front];  //保存队头元素
    Q.front=(Q.front+1)%MAXQAIZE;  //队头指针后移一位
    return 1;
}

QElemType GetHead(SqQueue Q) //取循环队列的队头元素
{
    if(Q.front!=Q.rear)  //队列非空
        return Q.base[Q.front];  //返回队头元素的值，队头指针不变
    return NULL;
}

int main()
{
    SqQueue Q;
    cout<<"0 初始化队列"<<endl;
    cout<<"1 入队"<<endl;
    cout<<"2 出队"<<endl;
    cout<<"3 取队列的对头元素"<<endl;
    cout<<"    输入负数退出"<<endl;

    while(1)
    {
        int ip;
        cout<<endl;
        cout<<endl;
        cout<<"============================"<<endl;
        cout<<"请输入操作指令："<<endl;
        cin>>ip;
        if(ip<0)
            break;
        else
        {
            switch(ip)
            {
            case 0:
                {
                    int flag=InitQueue(Q);
                    if(flag)
                        cout<<"初始化成功！"<<endl;
                    else
                        cout<<"初始化失败！"<<endl;
                    break;
                }
            case 1:
                {
                    QElemType e;
                    cout<<"请输入入队的元素：";
                    cin>>e;
                    int flag=EnQueue(Q,e);
                    if(flag)
                        cout<<"元素入队成功!"<<endl;
                    else
                        cout<<"队列已满,入队失败！"<<endl;
                    break;
                }
            case 2:
                {
                    QElemType e;
                    int flag=DeQueue(Q,e);
                    if(flag)
                        cout<<"元素出队成功,出队元素为："<<e<<endl;
                    else
                        cout<<"空队，出队失败！"<<endl;
                    break;
                }
            case 3:
                {
                    QElemType e=NULL;
                    e=GetHead(Q);
                    if(e==NULL)
                        cout<<"空队，获取对头元素失败！"<<endl;
                    else
                        cout<<"对头元素为："<<e<<endl;
                    break;
                }
            default:
                {
                    cout<<"操作指令不合法！请重新输入！"<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}

3、链栈

#include <iostream>

using namespace std;
#define OK 1
#define ERROR 0

typedef int ElemType;
typedef struct StackNode  //链栈的存储结构
{
    ElemType data;
    struct StackNode *next;
}StackNode,*LinkStack;

void InitStack(LinkStack &S)  //链栈的初始化
{
    S=NULL;
}

void Push(LinkStack &S,ElemType e)
{
    StackNode *p=new StackNode;
    p->data=e;
    p->next=S;
    S=p;
}

int Pop(LinkStack &S,ElemType &e)
{
    if(S==NULL)
        return ERROR;
    e=S->data;
    StackNode *p=S;
    S=S->next;
    delete p;
    return OK;

}

ElemType GetTop(LinkStack S)
{
    if(S==NULL)
        return NULL;
    else
        return S->data;
}
int main()
{
    LinkStack S;
    cout<<"0 初始化栈"<<endl;
    cout<<"1 入栈"<<endl;
    cout<<"2 出栈"<<endl;
    cout<<"3 取栈顶元素"<<endl;
    cout<<"    输入负数退出"<<endl;

    while(1)
    {
        int ip;
        cout<<endl;
        cout<<endl;
        cout<<"============================"<<endl;
        cout<<"请输入操作指令："<<endl;
        cin>>ip;
        if(ip<0)
            break;
        else
        {
            switch(ip)
            {
            case 0:
                {
                    InitStack(S);
                    cout<<"初始化成功！"<<endl;
                    break;
                }
            case 1:
                {
                    ElemType e;
                    cout<<"请输入入栈元素：";
                    cin>>e;
                    Push(S,e);
                    cout<<"元素入栈成功!"<<endl;
                    break;
                }
            case 2:
                {
                    ElemType e;
                    int flag=Pop(S,e);
                    if(flag)
                        cout<<"元素出栈成功,出栈元素为："<<e<<endl;
                    else
                        cout<<"空栈，出栈失败！"<<endl;
                    break;
                }
            case 3:
                {
                    ElemType e=NULL;
                    e=GetTop(S);
                    if(e==NULL)
                        cout<<"空栈，获取栈顶元素失败！"<<endl;
                    else
                        cout<<"栈顶元素为："<<e<<endl;
                    break;

                }
            default:
                {
                    cout<<"操作指令不合法！请重新输入！"<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}

4、链式队列

#include <iostream>

using namespace std;

typedef int QElemType;

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

void InitQueue(LinkQueue &Q) //链队的初始化
{
    Q.front=Q.rear=new QNode;  //生成新节点作为头节点，对头和队尾指针指向此节点
    Q.front->next=NULL;  //头节点的指针域置空
}

int EnQueue(LinkQueue &Q,QElemType e)  //入队
{
    QNode *p=new QNode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return 1;
}

int DeQueue(LinkQueue &Q,QElemType &e)  //出队
{
    if(Q.front==Q.rear)  //判断队空
        return 0;
    QNode *p=Q.front->next; //p指向队头元素
    e=p->data;              //e保存队头元素的值
    Q.front->next=p->next; //修改头节点的指针域
    if(Q.rear==p)          //最后一个元素怒被删，队尾指针指向头节点
        Q.rear=Q.front;
    delete p;
    return 1;
}

QElemType GetHead(LinkQueue Q)
{
    if(Q.front==Q.rear)
        return NULL;
    else
        return Q.front->next->data;
}

int main()
{
    LinkQueue Q;
    cout<<"0 初始化队列"<<endl;
    cout<<"1 入队"<<endl;
    cout<<"2 出队"<<endl;
    cout<<"3 取队列的对头元素"<<endl;
    cout<<"    输入负数退出"<<endl;

    while(1)
    {
        int ip;
        cout<<endl;
        cout<<endl;
        cout<<"============================"<<endl;
        cout<<"请输入操作指令："<<endl;
        cin>>ip;
        if(ip<0)
            break;
        else
        {
            switch(ip)
            {
            case 0:
                {
                    InitQueue(Q);
                        cout<<"初始化成功！"<<endl;
                    break;
                }
            case 1:
                {
                    QElemType e;
                    cout<<"请输入入队的元素：";
                    cin>>e;
                    int flag=EnQueue(Q,e);
                    if(flag)
                        cout<<"元素入队成功!"<<endl;
                    else
                        cout<<"队列已满,入队失败！"<<endl;
                    break;
                }
            case 2:
                {
                    QElemType e;
                    int flag=DeQueue(Q,e);
                    if(flag)
                        cout<<"元素出队成功,出队元素为："<<e<<endl;
                    else
                        cout<<"空队，出队失败！"<<endl;
                    break;
                }
            case 3:
                {
                    QElemType e=NULL;
                    e=GetHead(Q);
                    if(e==NULL)
                        cout<<"空队，获取对头元素失败！"<<endl;
                    else
                        cout<<"对头元素为："<<e<<endl;
                    break;
                }
            default:
                {
                    cout<<"操作指令不合法！请重新输入！"<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}