9.8C++作业

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

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

#include <iostream>

using namespace std;

class Stack
{
private:
    int str[10];      //栈的数组
    int top;       //栈顶变量

public:
    //无参构造函数
    Stack():top(-1)
    {
        cout<<"无参构造"<<endl;
    }


    //析构函数
    ~Stack()
    {
        cout<<"析构函数"<<endl;
    }


   //判空
    bool empty_stack()
    {
        if(-1 == top)
        {
            cout<<"栈为空！"<<endl;
            return 1;
        }
        return 0;
    }

    //判满
    bool full_stack()
    {
        if(10 == top)
        {
            cout<<"栈已满!"<<endl;
            return 1;
        }
        return 0;
    }

    //入栈
    int input_stack(int a)
    {
        if(full_stack())     //判满操作
        {
            cout<<"栈满，入栈失败"<<endl;
            return -1;
        }
        top++;
        str[top] = a;

        return 0;
    }

    //出栈
    int output_stack()
    {
        if(empty_stack())    //判空操作
        {
            cout<<"栈空，出栈失败"<<endl;
            return -1;
        }

        cout<<str[top--];
        cout<<"出栈成功"<<endl;

        return 0;
    }

    //求栈顶元素
    void head_stack()
    {
        cout<<"栈顶元素为"<<str[top]<<endl;
    }

    //清空栈
    void delete_stack()
    {
        empty_stack();
        top=-1;
        cout<<"栈已清空"<<endl;
    }

    //求栈的大小
    void size_stack()
    {
       cout<<"栈的大小为"<<top+1<<endl;
    }

    //拷贝构造函数
    Stack(Stack &s1):top(s1.top){
        for(int i=0; i<=top; i++){
            str[i] = s1.str[i];
        }
        cout<<"Stack:拷贝构造函数"<<endl;
    }


    //遍历栈
    void show_stack()
    {
        full_stack();
        for(int i=top; i>=0; i--)
        {
            cout<<str[i]<<endl;
        }
        cout<<"遍历成功"<<endl;
    }

};


int main()
{
    Stack s;
    s.input_stack(8);    //入栈
    s.input_stack(7);
    s.input_stack(6);
    s.input_stack(5);
    s.input_stack(4);
    s.show_stack();      //遍历栈

    s.output_stack();    //出栈
    s.show_stack();

    s.size_stack();      //栈的大小
    s.head_stack();      //栈顶元素
    s.delete_stack();    //清空栈
    s.show_stack();


    return 0;
}

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

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

#include <iostream>
#define N 10

using namespace std;

class Queue
{
private:
    int data[N];   //数组容器
    int head;     //队头元素下标
    int tail;      //队尾元素下标的下一位

public:
    //构造函数
    Queue():head(0), tail(0)
    {
        cout<<"无参构造函数"<<endl;
    }

    //析构函数
    ~Queue()
    {
        cout<<"析构函数"<<endl;
    }

    //拷贝构造函数
    Queue(Queue &s):head(s.head),tail(s.tail)
    {
        int i = head;
        while(i!=tail)
        {
            data[i] = s.data[i];
            i = (i+1)%N;
        }
        cout<<"Queue:拷贝构造函数"<<endl;
    }

    //判空
    bool empty_queue()
    {
        if(head == tail)
        {
            return 1;
        }
        return 0;
    }

    //判满
    bool full_queue()
    {
        if((tail+1)%N == head)
        {
            return 1;
        }
        return 0;
    }

    //入队
    int input_queue(int n)
    {
        if(full_queue())
        {
            cout<<"队满,入队失败"<<endl;
            return -1;
        }

        data[tail] = n;
        tail = (tail+1)%N;   //队尾下标自增

        return 0;
    }

    //出队
    int output_queue()
    {
        if(empty_queue())
        {
            cout<<"队空,出队失败"<<endl;
            return -1;
        }

        cout<<data[head]<<endl;;
        head = (head+1)%N;       //队头自增

       return 0;
    }

    //清空队
    int delete_queue()
    {
        if(empty_queue())
        {
            cout<<"队空,无需清空"<<endl;
            return -1;--
        }

        head = tail;
        cout<<"清空成功"<<endl;

        return 0;
    }

    //求队列大小
    void size_queue()
    {
        cout<<"队列大小为"<<(tail+N-head)%N<<endl;
    }

    //遍历栈内元素
    int show_queue()
    {
        if(empty_queue())
        {
            cout<<"队空，遍历失败"<<endl;
            return -1;
        }

        for(int i=head; i!=tail; i=(i+1)%N)
        {
            cout<<data[i];
        }
        cout<<endl;
        return 0;
    }
};
int main()
{
    Queue q;
    q.input_queue(9);   //入队
    q.input_queue(8);
    q.input_queue(7);
    q.input_queue(6);
    q.input_queue(5);
    q.show_queue();      //遍历队列

    q.output_queue();    //出队
    q.show_queue();      //遍历队列
    q.size_queue();      //队列大小
    q.delete_queue();    //清空队列
    q.show_queue();
    return 0;
}