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<data[p->top];
        cout<top--;
        return;
    }

    //销毁栈
    void stack_free(Stack *p)
    {
        if(NULL==p)
        {
            return ;
        }

        delete p;
        p=nullptr;
        cout<<"销毁成功"<data[p->top];
        cout<<"栈顶元素为"<top+1<top;i++)
        {
            cout<<" "<data[i];
        }
        cout<

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<<"队列不合法"<data[p->tail]=e;
        p->tail=(p->tail+1)%8;

        cout<<"入队成功"<data[p->front]<<"出队成功"<front=(p->front+1)%8;
        return ;
    }

    //求队列长度
    void queue_size(Queue *p)
    {
        if(NULL==p)
        {
            cout<<"所给队列不合法"<tail+8-p->front)%8<front;i!=p->tail;i=(i+1)%8)
        {
            cout<data[i]<<" ";
        }
        cout<