C++ day3

https://note.youdao.com/s/VC4lNwOlhttps://note.youdao.com/s/VC4lNwOl

1>

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

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

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

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

循环队列：

#include <iostream>

using namespace std;

class My_Queue{
private:
    int *m_queue;
    int front;
    int tail;
    int length;
public:
    //构造函数
    My_Queue(int len);
    //构造拷贝函数
    My_Queue(const My_Queue& obj);
    //析构函数
    ~My_Queue();
    //队列长度
    int len();
    //入队
    bool push(int val);
    //出队
    bool pop();
    //判空
    bool empty();
    //判满
    bool full();
    //遍历
    bool show();

};

//有参构造
My_Queue::My_Queue(int len):m_queue(nullptr),front(0),tail(0),length(0){

    m_queue = new int[len+1];

    for(int i=0;i<len+1;i++){
        m_queue[i] = 0;

    }
    length = len+1;
}

//拷贝构造
My_Queue::My_Queue(const My_Queue& obj){

    length = obj.length;
    m_queue = new int[obj.length];

    for(int i=0;i<obj.length;i++){
        m_queue[i] = obj.m_queue[i];
    }
}

//求队长
int My_Queue::len(){
    return (tail + length - front)%length;

}

//出队
bool My_Queue::pop(){

    bool ret = true;
    if(empty()){
        cout<<"队为空"<<endl;
        ret = false;
        return ret;
     }
    front = (front + 1)%length;
    cout<<"出队成功"<<endl;
    return ret;
}

//入队
bool My_Queue::push(int val){

    bool ret = true;

    if(full()){
        cout<<"队已满"<<endl;
        ret = false;
        return ret;
    }
    m_queue[tail] = val;

    tail = (tail+1)%length;
    cout<<"入队成功"<<endl;

    return ret;
}

//判空
bool My_Queue::empty(){
    return front == tail;
}

//判满
bool My_Queue::full(){
    return (tail + 1)%length == front;
}

//遍历
bool My_Queue::show(){
    bool ret = true;
    if(empty()){
        cout<<"队为空"<<endl;
        ret = false;
        return ret;
    }
    for(int i=front;i!=tail;i = (i+1)%length){
        cout<<m_queue[i]<<" ";
    }
    cout<<endl;
    return ret;
}


My_Queue::~My_Queue(){
    delete[] m_queue;
}


int main()
{
    My_Queue q(10);

    for(int i=1;i<10;i++){
        q.push(i);
    }

    q.show();

    for(int i=1;i<4;i++){
        q.pop();
    }

    q.show();
    cout<<"队长为"<<q.len()<<endl;


    return 0;
}

 

栈：

#include <iostream>

using namespace std;
#define N 128

class my_stack{
private:
    int data[N];
    int top=-1;
public:
    //构造函数
    //my_stack();

    //判空
    bool empty();

    //判满
    bool full();

    //入栈
    void push(const  int val);

    //出栈
    void pop();

    //求栈大小
    int size();

    //获取栈顶元素
    int my_top();

    //销毁栈
    bool clear();

    //遍历
    bool show();

    //析构
    //~my_stack();
};


//判空
bool my_stack::empty(){

    return top == -1?1:0;

}



//判满
bool my_stack::full(){

    return top == N?1:0;
}


//入栈
void my_stack::push(const int val){

    if(full()){return;}
    top++;
    data[top] = val;
}


//出栈
void my_stack::pop(){
    if(empty()){
        cout<<"栈空";
    }
    top--;
    cout<<"出栈成功！"<<endl;

}


//求栈大小
int my_stack::size(){
    if(empty()){return -1;}
    return top+1;
}


//获取栈顶元素
int my_stack::my_top(){

    return data[top];
}


//清空栈
bool my_stack::clear(){
    bool ret = true;
    if(empty()){
        ret = false;
        cout<<"栈为空"<<endl;
        return ret;
    }
    top = -1;
    cout<<"栈已清空"<<endl;
    return ret;
}


//遍历
bool my_stack::show(){
    bool ret = true;
    if(empty()){
        ret = false;
        cout<<"栈为空"<<endl;
        return ret;
    }
    for(int i=0;i<=top;i++){
        cout<<data[i]<<" ";
    }
    cout<<endl;
    return ret;
}

//析构
//my_stack::~my_stack(){

//}
int main()
{

    my_stack s;
    for(int i = 1;i<10;i++ ){
        s.push(i);
    }
    s.show();
    for(int i=0;i<5;i++){
        s.pop();
    }
    s.show();
    cout<<"对列长度为"<<s.size()<<endl;
    cout<<"top="<<s.my_top()<<endl;
    s.clear();
    s.show();


    return 0;
}