栈的实现

头文件

#ifndef MY_STACK_H
#define MY_STACK_H
#include <iostream>

using namespace std;


class my_stack
{
private:
    int *base;//动态栈指针
    int top;//栈顶元素
    int size;//栈大小
public:
    my_stack();//无参构造
    my_stack(int size):top(-1),size(size)
    {
        base = new int[this->size];
        cout<<"有参构造"<<endl;
    }
    ~my_stack()
    {
        delete []base;
        cout<<"析构函数"<<endl;
    }

    //赋值
    my_stack & operator=(const my_stack &str);

    //访问栈顶元素
    int my_top();

    //检查容器是否为空
    bool my_empty();

    //返回容纳元素数
    int my_size();
    //插入栈顶
    void my_push(int value);
    //删除栈顶
    void my_pop();
};

#endif // MY_STACK_H

源文件

#include "my_stack.h"

//赋值
my_stack & my_stack::operator=(const my_stack &str)
{
    if(this != &str)
    {
        delete []base;
        this->size = str.size;
        this->top = str.top;
        base = new int[size];
        for(int i = 0;i<size;i++)
        {
            base[i] = str.base[i];
        }
    }
    return *this;
}

//访问栈顶元素
int my_stack::my_top()
{
    if(my_empty())
    {
        cout<<"栈为空"<<endl;
        return -1;
    }
    return base[top];
}

//检查容器是否为空
bool my_stack::my_empty()
{
    return top == -1;
}

//返回容纳元素数
int my_stack::my_size()
{
    return top+1;
}
//插入栈顶
void my_stack::my_push(int value)
{
    if(top >= size)
    {
        cout<<"栈满"<<endl;
        return;
    }
    base[++top] = value;
    cout<<value<<"插入成功"<<endl;
}
//删除栈顶
void my_stack::my_pop()
{
    if(my_empty())
    {
        cout<<"栈为空"<<endl;
        return;
    }
    top--;
    cout<<"删除栈顶成功"<<endl;
}

主程序

#include "my_stack.h"
int main()
{
    my_stack s(10);
    s.my_push(23);
    s.my_push(45);
    s.my_push(74);

    cout<<"栈顶 = "<<s.my_top()<<endl;
    cout<<"栈元素个数="<<s.my_size()<<endl;
    s.my_pop();
    cout<<"删除栈顶后栈元素个数="<<s.my_size()<<endl;
    return 0;
}

队列的实现

头文件

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>

using namespace std;


class queue
{
private:
    int *base;//队列动态数组
    int front;//头部
    int rear;//尾部
    int size;//容器大小
public:
    queue();//无参构造
    queue(int size):front(0),rear(0),size(size)//有参构造
    {
        base = new int[size];
        cout<<"有参构造"<<endl;
    }
    //析构函数
    ~queue()
    {
        delete [] base;
        cout<<"析构函数"<<endl;
    }

    //赋值
    queue &operator=(const queue &str);
    //访问第一个元素
    int my_front();
    //访问最后一个元素
    int my_back();
    //检查容器是否为空
    bool my_empty();
    //返回容器的元素数
    int my_size();
    //向队尾插入元素
    void my_push(int value);
    //删除首个插入元素
    void my_pop();
};

#endif // QUEUE_H

源文件

#include "queue.h"

//赋值
queue &queue::operator=(const queue &str)
{
    if(this != &str)
    {
        delete []base;
        front = str.front;
        rear = str.rear;
        size = str.size;
        base = new int[size];
        for(int i = front;i<rear;i++)
        {
            base[i] = str.base[i];
        }
    }
    return *this;
}
//访问第一个元素
int queue::my_front()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return -1;
    }
    return base[front];
}
//访问最后一个元素
int queue::my_back()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return -1;
    }
    return base[rear-1];
}
//检查容器是否为空
bool queue::my_empty()
{
    return rear == front;
}
//返回容器的元素数
int queue::my_size()
{
    return rear-front;
}
//向队尾插入元素
void queue::my_push(int value)
{
    base[rear++] = value;
    cout<<"插入成功"<<endl;
}
//删除首个插入元素
void queue::my_pop()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return;
    }
    cout<<"首元素"<<base[front++]<<"删除成功"<<endl;
}

主程序

#include "queue.h"

int main()
{
    queue s(10);
    s.my_push(14);
    s.my_push(24);
    s.my_push(41);
    s.my_push(4);
    cout<<"最后一个元素是"<<s.my_back()<<endl;
    s.my_pop();
    cout<<"第一个元素"<<s.my_front()<<endl;
    return 0;
}

思维导图