栈(stack)的介绍和使用

1. stack的介绍和使用
1.1 stack的介绍
stack的文档介绍
翻译：

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行
   元素的插入与提取操作。
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定
   的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下
   操作：
   empty：判空操作
   back：获取尾部元素操作
   push_back：尾部插入元素操作
   pop_back：尾部删除元素操作
4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，
   默认情况下使用deque。
   
   1.2 stack的使用
   
   最小栈练习题

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {

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

栈的弹出压入序列

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> st;
        int pushIdx=0;
        int popIdx=0;
        //入栈
        while(pushIdx < pushV.size())
        {
            st.push(pushV[pushIdx++]);
            //判断栈顶元素和出栈元素是否相同
            while(!st.empty() && st.top() == popV[popIdx])
            {
                st.pop();
                popIdx++;
            }
        }
        //判断栈是否为空
        return st.empty();
    }
};

1.3 stack的模拟实现
用vector封装一个栈

//用vector实现一个栈
template <class T>
class Stack
{
public:
	void push(const T& val)
	{
		st.push_back(val);
	}

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

	T& top()
	{
		return st.back();
	}

	size_t size() const
	{
		return st.size();
	}

	bool empty() const
	{
		return st.empty();
	}

private:
	vector<T> st;
};

用list封装一个栈

//用list实现一个栈
template <class T>
class Stack2
{
public:
	void push(const T& val)
	{
		st.push_back(val);
		//st.push_front(val);
	}

	void pop()
	{
		st.pop_back();
		//st.pop_front();
	}

	T& top()
	{
		return st.back();
		//return st.front();
	}

	size_t size() const
	{
		return st.size();
	}

	bool empty() const
	{
		return st.empty();
	}
private:
	list<T> st;
};

3.使用双端对列实现栈

//使用双端对列,vector,list实现栈,默认使用deque
#include<list>
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
template <class T,class Container=deque<T>>
class Stack
{
	// size,empty,back,push_back,pop_back
public:
	void push(const T& val)
	{
		_c.push_back(val);
	}
	void pop()
	{
		_c.pop_back();
	}
	T& top()
	{
		return _c.back();
	}
	size_t size() const
	{
		return _c.size();
	}
	bool empty() const
	{
		return _c.empty();
	}

private:
	Container _c;
};

void test()
{
	Stack<int> st;
	//Stack<int, vector<int>> st;
	//Stack<int, list<int>> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}