数据结构之栈和队列

#include <iostream>
#include "stdio.h"
#include "hikaka_stack.h"
using namespace std;

#define maxsize 50
//#define elemtype int;

typedef struct sqstack
{
    elemtype data[maxsize];
    int top;
}sqstack;

typedef struct queue
{
    elemtype data[maxsize];
    int front,rear;
}queue;
   
typedef struct linknode
{
    elemtype data;
    struct linknode *next;
}linknode;          //链式队列的结点

typedef struct linkqueue
{
    linknode *front,*rear;  
}linkqueue;  

class Stack_Queue
{
    public:
    //顺序栈
        void stack_init(sqstack &S);                //顺序栈初始化
        bool stack_isempty(sqstack S);              //判断是否为空栈
        bool stak_push(sqstack &S,elemtype x);      //入栈
        bool stack_pop(sqstack &S,elemtype &x);     //出栈
        bool stack_get_top(sqstack S,elemtype &x);  //获取栈顶内容
        void print_stack(sqstack S);                //打印栈
    //顺序队列
        void queue_init(queue &Q);                  //初始化队列
        bool queue_isempty(queue Q);                //判断队列是否为空
        bool queue_en(queue &Q,elemtype x);         //入队
        bool queue_de(queue &Q,elemtype x);         //出队
        void print_queue(queue Q);                  //打印队列
    //链队
        void linkqueue_init(linkqueue &LQ);         //链队初始化
        bool linkqueue_isempty(linkqueue LQ);       //判断链队是否为空
        void linkqueue_en(linkqueue &LQ,elemtype x);//入队
        bool linkqueue_de(linkqueue &LQ,elemtype &x);//出队
        void print_linkqueue(linkqueue LQ);         //打印链队
};

/**********************顺序栈**************************/


//初始化
void Stack_Queue::stack_init(sqstack &S)
{
    S.top=-1;
}

//判空
bool Stack_Queue::stack_isempty(sqstack S)
{
    if(S.top==-1)
        return true;
    else
        return false;
}

//入栈
bool Stack_Queue::stak_push(sqstack &S,elemtype x)
{
    if(S.top==maxsize-1)
        return false;
    S.data[++S.top]=x;
    return true;
}

//出栈
bool Stack_Queue::stack_pop(sqstack &S,elemtype &x)
{
    if(S.top==maxsize-1)
        return false;
    x=S.data[S.top--];
    return true;
}

//读取栈顶元素
bool Stack_Queue::stack_get_top(sqstack S,elemtype &x)
{
    if(S.top==-1)
    return false;
    x=S.data[S.top];
    return true;
}

//打印栈
void Stack_Queue::print_stack(sqstack S)
{
    while(S.top!=-1)
        cout<<S.data[S.top--]<<" ";    
    cout<<endl;
}


/****************************循环队列**********************************/

//初始化
void Stack_Queue::queue_init(queue &Q)
{
    Q.rear=Q.front=0;
}

//判断空
bool Stack_Queue::queue_isempty(queue Q)
{
    if(Q.front=Q.rear)
        return true;
    else
        return false;
}

//入队
bool Stack_Queue::queue_en(queue &Q,elemtype x)
{
    if((Q.rear+1)%maxsize==Q.front)
        return false;
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%maxsize;
    return true;
}

//出队
bool Stack_Queue::queue_de(queue &Q,elemtype x)
{
    if(Q.rear==Q.front)
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%maxsize;
    return true;
}

void Stack_Queue::print_queue(queue Q)
{
    while(Q.front!=Q.rear)
        cout<<Q.data[Q.front++]<<" ";    
    cout<<endl;
}

/*******************************链队****************************************/
/*
front--->a1--->a2--->a3--->......--->an(rear)
*/
 

//链队初始化
void Stack_Queue::linkqueue_init(linkqueue &LQ)
{
    LQ.front=LQ.rear=new linknode;
    LQ.front->next=nullptr;
}

//判断空
bool Stack_Queue::linkqueue_isempty(linkqueue LQ)
{
    if(LQ.front==LQ.rear)
        return true;
    else
        return false;
}

//入队
void Stack_Queue::linkqueue_en(linkqueue &LQ,elemtype x)
{
    linknode *s=new linknode;
    s->data=x;
    s->next==nullptr;
    LQ.rear->next=s;
    LQ.rear=s;
}

//出队
bool Stack_Queue::linkqueue_de(linkqueue &LQ,elemtype &x)
{
    if(LQ.front==LQ.rear)
    return false;
    linknode *p=LQ.front->next;
    if(LQ.rear==p)
        LQ.rear=LQ.front;
    else
        LQ.front->next=p->next;
    free(p);
    return true;
}

//打印链队
void Stack_Queue::print_linkqueue(linkqueue LQ)
{
    while(LQ.front!=LQ.rear)
    {
        cout<<LQ.front->next->data<<" ";
        LQ.front=LQ.front->next;
    }
    cout<<endl;
}

int main()
{
    elemtype x,e;

    linkqueue Q;
    Stack_Queue myqueue;
    myqueue.linkqueue_init(Q);
    cout<<"入队"<<endl;
    for(int i=0;i<5;i++)
        myqueue.linkqueue_en(Q,i);
    myqueue.print_linkqueue(Q);
    cout<<"出队"<<endl;
    myqueue.linkqueue_de(Q,e);
    myqueue.print_linkqueue(Q);
    return 0;
}