C++【栈和队列】

       栈

         首先要明确一点，栈和队列已经不再是之前所说的容器了，而是容器适配器，本质就是在容器的基础上进行某些行为限制，比如队列的先进先出，比如栈的先进后出。

官方解释：

       ⭕stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

       ⭕ stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

        ⭕stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作： empty：判空操作 back：获取尾部元素操作 push_back：尾部插入元素操作 pop_back：尾部删除元素操作

        ⭕标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。

 stack的用法

常用接口有：

函数名称	效果
stack()	构造空栈
empty()	检测stack是否为空
size ()	反回stack的元素个数
top()	反回栈顶元素
push()	入栈
pop()	将栈顶元素弹出

各位看好，我将演示一遍stack的遍历

stack sk;
while(!sk.empty())
{
    cout<<sk.top();
    sk.pop();
}
cout<<endl;

话不多说，我将进行一道例题展示，以助各位理解：

155. 最小栈 - 力扣（LeetCode）https://leetcode.cn/problems/min-stack/description/

class MinStack {
public:
//再多弄一个栈，用来放更小值，只要小于等于目前的最小值就插入
    MinStack() {
        //初始化
        _size=_size_min=0;
        _capacity=_min_capacity=100;
        _ptr=new int[_capacity];
        _min=new int[_min_capacity];
    }
    void push(int val) {
        if(_size_min==0)
        {//此时最小栈为空
            check();
            _ptr[_size]=_min[_size_min]=val;
            _size++;
            _size_min++;
        }
        else
        {//栈不为空，就要进行比较
            check();
            _ptr[_size++]=val;
            if(val<=_min[_size_min-1])
                _min[_size_min++]=val;
        }
    }
    void pop() {
        if(_ptr[_size-1]==_min[_size_min-1])
        {
            _size--;
            _size_min--;
        }
        else
        _size--;
    }
    
    int top() {
        return _ptr[_size-1];
    }
    void check()
    {
        if(_size==_capacity)
        {//如果空间满了就扩容
            int flag=_capacity;
            _capacity*=2;
            int* tem=new int[_capacity];
            memcpy(tem,_ptr,flag*sizeof(int));
            delete[] _ptr;
            _ptr=tem;
        }
        if(_size_min==_min_capacity)
        {
            int flag=_min_capacity;
            _min_capacity*=2;
            int* tem=new int[_min_capacity];
            memcpy(tem,_min,sizeof(int)*flag);
            delete[] _min;
            _min=tem;
        }
    }
    int getMin() {
        return _min[_size_min-1];
    }
    int* _ptr;
    int* _min;
    int _size;
    int _size_min;
    int _capacity;
    int _min_capacity;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

         代码有一点点长，先看一下题目，然后再看一下成员变量，在回去看成员函数。上述这种解法是自己写了一个栈，其实我们可以用std中的栈，但感觉这样不太好，毕竟是让你实现栈，那不如彻彻底底自己实现算了。

queue

        1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

        2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

        3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

                empty：检测队列是否为空

                size：返回队列中有效元素的个数

                front：返回队头元素的引用

                back：返回队尾元素的引用

                push_back：在队列尾部入队列

                pop_front：在队列头部出队列

        4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

queue模拟实现

template<class T,class container=std::list<int>>
	class quene
	{
	public:
		void push(const T& x)
		{//尾插
			_con.push_back(x);
		}
		//头删
		void pop()
		{
			_con.pop_front();
		}
		//返回出口元素
		const T& front()
		{
			return _con.front();
		}
		//判空
		bool empty()
		{
			return _con.empty();
		}
		//返回队尾元素
		const T& back()
		{
			return _con.back();
		}
		//返回队列数量
		size_t size()
		{
			return _con.size();
		}
	private:
		container _con;
	};