C++初阶--queue和stack

stack

stack是一种容器适配器，按照后进先出的原则存储数据。通过

#include< stack >

头文件进行提供；

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

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

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

常用接口

deque

deque被称为双端队列，时一种双向开口的数据结构，它可以在头尾两端进行插入和删除的操作，且时间复杂度为O（1）,与vector比，头插效率高， 不需要搬移元素；与list比，空间利用率高；

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维
数组；双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂。

stack的自我实现

#pragma once
namespace fnc
{
	template<class T,class Container=deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

stack的例题

最小栈

最小栈

思路：最小栈，除了获取最小元素与普通的栈没有什么区别；但对于栈来说，要去遍历它一遍才知道它的最小元素；这道题在时间作了限制，但是在空间上没有作要求；所以这里我们可以利用多一个栈来存储当前栈中的最小元素；这里需要考虑，栈的出入会影响最小元素的变化，所以这里要跟着动态变化；
具体做法：创建出两个栈，一个用来存储元素(elem)，一个用来存储当前栈的最小元素（称为min)；入栈的时候，当min为空或者插入元素小于等于min的最大值（也就是栈顶）就需要对min进行入栈（这里用等于是因为当有多个最小数时，如果没有进行存储，那么当min栈出栈时，最小数就没有了，但实际还有很多相同的最小数在elem中）；出栈时要判断min的栈顶与elem的栈顶是否相同，相同就需要出栈；

class MinStack {
public:
    
    void push(int val) {
        _elem.push(val);

        if(_min.empty()||val<=_min.top())
        {
            _min.push(val);
        }
    }
    
    void pop() {
        if(_elem.top()==_min.top())
        {
            _min.pop();
        }
        _elem.pop();
    }
    
    int top() {
        return _elem.top();
    }
    
    int getMin() {
        return _min.top();
    }
private:
    std::stack<int> _elem;

    std::stack<int> _min;

};

栈的压入和弹出

栈的压入和弹出

思路：这道题实际上就是对pushV进行模拟出入栈的过程，然后看popV是否符合；而要找到popV这个顺序是否符合，我们可以这么操作：创建一个栈，pushV入栈，栈顶元素与popV的头元素相同时，就对popV进行移动下标，表示出栈顺序，同时对栈顶进行出栈；直到栈为空，表示符合栈的出入；

bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        stack<int> s;
        int pushi=0,popi=0;
        //pushV入栈
        while(pushi<pushV.size())
        {
            s.push(pushV[pushi++]);
            //相等时进行位移；
            while(!s.empty()&&s.top()==popV[popi] )
            {
                s.pop();
                popi++;
            }

        }
        return s.empty();
    }

queue

队列也是一种容器适配器，具有先进先出的特点；
队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
标准容器类deque和list满足了这些要求。

queue的模拟实现

template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		const T& front()
		{
			return _con.front();
		}

		const T& back()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

priority_queue

优先队列，一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特
定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成
堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。

仿函数

仿函数是一个重载了函数调用符() 的类对象，它可以像函数一样被调用。在C++中，仿函数可以作为函数对象来使用，可以像函数一样接受 参数并返回结果。



使用仿函数的好处是它提供了更大的灵活性，可以封装更多的状态信息，并且可以用于算法的泛化和定制化。它可以被用于STL算法。

模拟实现priority_queue

//仿函数
	template<class T>
	class less
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	class greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	template<class T, class Container = vector<T>, class Compare=less<int>>
	class priority_queue
	{
	public:
		void adjust_up(int child)
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(int parent)
		{
			int child = parent * 2 +1;
			Compare com;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && com(_con[child],_con[child+1]))
				{
					child++;
				}
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);

			adjust_up(_con.size() - 1);
		}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			adjust_down(0);
		}

		const T& top()
		{
			return _con[0];
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};