2023年9月8日

1> 自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量

成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小

#include 
 
using namespace std;
 
class Stack
{
private:
    int data[8];
    int top=-1;
 
public:
    //构造函数
    Stack()
    {
 
    }
 
    //构析函数
    ~Stack()
    {
 
    }
 
    //拷贝构造函数
    Stack(const Stack &other)
    {
 
    }
 
    //判空
    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,int 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 ;
        }
 
        int 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 ;
        }
        int 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 zhan;
 
    //定义一个
    Stack *p=new Stack(zhan);
 
    //入栈
    zhan.stack_push(p,812);
    zhan.stack_push(p,627);
    zhan.stack_push(p,908);
    zhan.stack_push(p,929);
    zhan.stack_push(p,199);
    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;
}

2> 自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置

成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小

#include 
 
using namespace std;
 
class Queue
{
private:
    int data[8];
    int front=0;
    int tail=0;
 
public:
    //构造函数
    Queue()
    {
 
    }
 
    //构析函数
    ~Queue()
    {
 
    }
 
    //拷贝构造函数
    Queue(const Queue &other)
    {
 
    }
 
    //判空
    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,int 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 dl;
 
    //创建指针 申请空间
    Queue *p=new Queue(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;
}