2023年9月13日

1> 将之前定义的栈类和队列类都实现成模板类

栈

#include 
 
using namespace std;
 
template <class T>
class Stack
{
private:
    T data[8];
    int top;
 
public:
    //构造函数
    Stack()
    {
        top=-1;
    }
 
    //构析函数
    ~Stack()
    {
 
    }
 
    //判空
    bool stack_empty(Stack *p)
    {
        if(p->top==-1)
        {
            return 1;
        }
        return 0;
    }
 
    //判满
    bool stack_full(Stack *p)
    {
        if(p->top==7)
        {
            return 1;
        }
        return 0;
    }
 
    //入栈
    void stack_push(Stack *p,T e)
    {
        if(NULL==p||stack_full(p))
        {
            return;
        }
 
        p->top++;
        p->data[p->top]=e;
        cout<
        cout<<"入栈成功"<
        return ;
    }
 
    //出栈
    void stack_pop(Stack *p)
    {
        if(NULL==p||stack_empty(p))
        {
            return ;
        }
 
        T e=p->data[p->top];
        cout<"出栈成功"<
        p->top--;
        return;
    }
 
    //销毁栈
    void stack_free(Stack *p)
    {
        if(NULL==p)
        {
            return ;
        }
 
        delete p;
        p=nullptr;
        cout<<"销毁成功"<
        return ;
    }
 
    //获取栈顶元素
    void stack_gettop(Stack *p)
    {
        if(NULL==p)
        {
            return ;
        }
        T e = p->data[p->top];
        cout<<"栈顶元素为"<
        return ;
    }
 
    //求栈的大小
    void stack_size(Stack *p)
    {
        if(NULL==p)
        {
            return ;
        }
        cout<<"栈的大小为"<top+1<
    }
 
    void stack_show(Stack *p)
    {
        for(int i=0;i<=p->top;i++)
        {
            cout<<" "<data[i];
        }
        cout<
        return ;
    }
};
 
 
int main()
{
    //初始化
    Stack<double>zhan;
 
    //定义一个
    Stack<double> *p=new Stack<double>(zhan);
 
    //入栈
    zhan.stack_push(p,8.12);
    zhan.stack_push(p,6.27);
    zhan.stack_push(p,9.08);
    zhan.stack_push(p,9.29);
    zhan.stack_push(p,1.99);
    zhan.stack_show(p);
    cout<<"*******************************"<
    //出栈
    zhan.stack_pop(p);
    zhan.stack_pop(p);
    zhan.stack_pop(p);
    zhan.stack_show(p);
 
    //获取栈顶元素
    zhan.stack_gettop(p);
 
    //求栈大小
    zhan.stack_size(p);
 
    //销毁栈
    zhan.stack_free(p);
 
    return 0;
}

队列

#include 
 
using namespace std;
 
template<class T>
class Queue
{
private:
    T data[8];
    int front;
    int tail;
 
public:
    //构造函数
    Queue()
    {
        cout<<"构造函数"<
        front=0;
        tail=0;
    }
 
    //构析函数
    ~Queue()
    {
 
    }
 
    //判空
    int queue_empty(Queue *p)
    {
        if(NULL==p)
        {
            cout<<"队列不合法"<
            return -1;
        }
        return 0;
    }
 
    //判满
    int queue_full(Queue *p)
    {
        if(NULL==p)
        {
            cout<<"所给队列不和发"<
            return -1;
        }
        return 0;
    }
 
    //入队
    void queue_push(Queue *p,T e)
    {
        if(NULL==p||queue_full(p))
        {
            cout<<"入队失败"<
            return ;
        }
 
        p->data[p->tail]=e;
        p->tail=(p->tail+1)%8;
 
        cout<<"入队成功"<
        return ;
    }
 
    //出队
    void queue_pop(Queue *p)
    {
        if(NULL==p||queue_empty(p))
        {
            cout<<"出队失败"<
            return ;
        }
 
        cout<data[p->front]<<"出队成功"<
        p->front=(p->front+1)%8;
        return ;
    }
 
    //求队列长度
    void queue_size(Queue *p)
    {
        if(NULL==p)
        {
            cout<<"所给队列不合法"<
            return ;
        }
 
        cout<<"队列长度为"<<(p->tail+8-p->front)%8<
        return ;
    }
 
    //销毁队列
    void queue_free(Queue *p)
    {
        if(NULL!=p)
        {
            free(p);
            p=NULL;
            cout<<"释放成功"<
            return ;
        }
        cout<<"所给队列不合法"<
        return ;
    }
 
    //遍历
    void queue_show(Queue *p)
    {
        for(int i=p->front;i!=p->tail;i=(i+1)%8)
        {
            cout<data[i]<<" ";
        }
        cout<
    }
};
 
int main()
{
    //定义一个队列
    Queue<int> dl;
 
    //创建指针 申请空间
    Queue<int> *p=new Queue<int>(dl);
 
    //入队
    dl.queue_push(p,8);
    dl.queue_push(p,60);
    dl.queue_push(p,19);
    dl.queue_push(p,627);
    dl.queue_push(p,78);
    dl.queue_push(p,1);
    dl.queue_push(p,2);
    dl.queue_show(p);
    cout<<"**********************"<
 
    //出队
    dl.queue_pop(p);
    dl.queue_pop(p);
    dl.queue_pop(p);
    dl.queue_show(p);
    cout<<"**********************"<
 
    //求队列长度
    dl.queue_size(p);
 
    //销毁队列
    dl.queue_free(p);
 
    return 0;
}