C++实现栈的基本操作【顺序、队列、单调】

一、顺序

#include <iostream>
#include <stdexcept>
using namespace std;

template <typename T> // 类模板，类似于顺序表中数据类型eleType的作用
class Stack
{
private:
    T* data;       // 数据域
    int size;      // 栈大小
    int capacity;  // 栈容量
    void resize(); // 栈扩容

public:
    Stack() : size(0), capacity(10), data(new T[capacity]) {}; // 构造
    ~Stack();                                                 // 析构
    void resize();                                     // 扩容
    void push(T element);                                     // 插入
    T pop();                                                  // 弹出栈顶元素
    T top() const;                                            // 获取栈顶元素
    int getSize() const;                                      // 获取大小
};

template <typename T>
void Stack<T>::resize() // 扩容
{
    int newCapacity = capacity * 2;
    T* newData = new T[newCapacity];
    for (int i = 0; i < size; ++i)
    {
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity = newCapacity;
}

template <typename T>
Stack<T>::~Stack() // 析构
{
    delete[] data;
}
template <typename T>
void Stack<T>::push(T element) // 插入
{
    if (size == capacity)
    {
        resize();
    }
    data[size++] = element;
}
template <typename T>
T Stack<T>::pop() // 弹出栈顶元素
{
    if (size == 0)
    {
        throw std::underflow_error("Stack is empty");
    }
    return data[--size];
}
template <typename T>
T Stack<T>::top() const // 获取栈顶元素
{
    if (size == 0)
    {
        throw std::underflow_error("Stack  is empty");
    }
    return data[size - 1];
}
template <typename T>
int Stack<T>::getSize() const // 获取大小
{
    return size;
}
int main()
{
    int NeedSpace = 100;
    Stack <int> s;
    s.push(100);
    s.push(200);
    s.push(300);
    s.push(400);
    std::cout << s.top();
    s.pop();
    std::cout << s.top();
    std::cout << s.getSize();
    if (s.getSize() < NeedSpace) {
        s.resize();
    }
    return 0;
}

二、队列

#include <iostream>
#include <stdexcept>
using namespace std;

template <typename T>
class Queue
{
private:
    class Node // 结点
    {
    public:
        T data;                                 // 数据域
        Node* next;                             // 后继结点
        Node(T dt) : data(dt), next(nullptr) {}; // 构造
    };
    Node* front; // 队首指针
    Node* rear;  // 队尾指针
    int size;    // 队列大小

public:
    Queue() : front(nullptr), rear(nullptr), size(0) {}; // 构造
    ~Queue();                                           // 析构
    void enqueue(T element);                            // 入队
    T dequeue();                                        // 出队
    T getFront() const;                                 // 获取队首元素
    int getSize() const;                                // 获取队列大小
    bool empty() const;                                 // 判空
};

template <typename T>
Queue<T>::~Queue() // 析构
{
    while (front)
    {
        Node* temp = front;
        front = front->next;
        delete temp;
    }
}

template <typename T>
void Queue<T>::enqueue(T element) // 入队
{
    if (rear == nullptr)
    {
        rear = new Node(element);
        front = rear;
    }
    else
    {
        rear->next = new Node(element);
        rear = rear = rear->next;
    }
    ++size;
}

template <typename T>
T Queue<T>::dequeue() // 出队
{
    if (front == nullptr)
    {
        throw std::underflow_error("Queue is empty");
    }
    T element = front->data;
    Node* temp = front; // 避免内存泄漏
    front = front->next;
    delete temp;
    return element;
    --size;
}

template <typename T>
T Queue<T>::getFront() const // 获取队首元素
{
    if (front == nullptr)
    {
        throw std::underflow_error("Queue is empty");
    }
    return front->data;
}

template <typename T>
int Queue<T>::getSize() const // 获取队列大小
{
    return size;
}

template <typename T>
bool Queue<T>::empty() const
{
    return size == 0;
}

class MyStack
{
private:
    Queue<int> q1;
    Queue<int> q2;

public:
    MyStack() {};     // 构造
    void push(int x) // 入栈
    {
        q1.enqueue(x);
    }
    int pop() // 出栈
    {
        while (q1.getSize() > 1)
        {
            q2.enqueue(q1.dequeue());
        }
        int result = q1.dequeue();
        q2.enqueue(result);
        while (!q2.empty())
        {
            q1.enqueue(q1.dequeue());
        }
        return result;
    }
    int top() // 获取栈顶元素
    {
        while (q1.getSize() > 1)
        {
            q2.enqueue(q1.dequeue());
        }
        int result = q1.dequeue();
        while (!q2.empty())
        {
            q1.enqueue(q1.dequeue());
        }
        return result;
    }
    bool empty() // 判空
    {
        return q1.empty();
    }
};

int main()
{
    MyStack  s;
    s.push(100);
    s.push(200);
    s.push(300);
    s.push(400);
    s.pop();
    std::cout << s.top();
    if (s.empty()) {
        std::cout << "s为空";
    }
    return 0;
}

三、单调