STL之stack及其底层实现

STL之stack

1. 什么是stack？

stack文档(所有的接口介绍及其使用方法)

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

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

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

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

2. stack的使用

函数接口	接口说明
stack()	构造空栈
empty()	检测栈是否为空
top()	返回栈顶元素的引用
size()	返回栈中元素个数
push()	将元素val压入stack中
pop()	将stack中尾部的元素弹出

代码示例：

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

void test_stack()
{
	stack<int> st;
	st.push(1); // 压栈
	st.push(2);
	st.push(3);
	st.push(4);
	st.emplace(5); // C++11
	cout << st.size() << endl;
	// 没有迭代器
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();  // 出栈
	}
	cout << endl;
}

int main()
{
	test_stack();
	return 0;
}

3. stack没有迭代器

stack的所有元素进出都必须符合“先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。stack不提供随机访问功能，也不提供迭代器。

4. stack的模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack

#include<vector>
namespace St
{
	template<class T>
	class stack
	{
	public:
		stack() {} // 自定义类型自动调用构造与析构
		void push(const T& x) {_c.push_back(x);}
		void pop() {_c.pop_back();}
		T& top() {return _c.back();}
		const T& top()const {return _c.back();}
		size_t size()const {return _c.size();}
		bool empty()const {return _c.empty();}
	private:
			std::vector<T> _c;

注:若想查看C语言版栈的实现，详见博客栈与队列

5. 栈的OJ习题

1. 对于一个字符串，请设计一个算法，判断其是否为一个合法的括号串。给定一个字符串A和它的长度n，请返回一个bool值代表它是否为一个合法的括号串。OJ链接

思路：用栈结构实现，栈中存放左括号，当遇到右括号之后，检查栈中是否有左括号，如果有则出栈，如果没有或者栈空，则说明不匹配。

class Parenthesis {
public:
    bool chkParenthesis(string A, int n)
    {
        stack<char> st;
        size_t i = 0;
        for(; i < n; i++)
        {
            if(A[i] == '(')
            {
                st.push(A[i]);
            }
            else if(A[i] == ')')
            {
                if(st.empty())
                    break;
                else
                    st.pop();
            }
        }
        if(st.empty() && i == n)
            return true;
        return false;
    }
};

2. 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。OJ链接

思路：
1. 利用两个栈，一个为正常栈(保存所有的进出栈数据)，一个为最小栈(只有当数据为最小时，才会入栈)
2. 核心在于：入栈时，若数据最小，需要两个栈都要入栈，出栈时，如果出的数据为最小，需要更新最小栈

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {}
    
    void push(int x) {
        _st.push(x);
        if(_minst.empty() || _st.top() <= _minst.top())
            _minst.push(x);
    }
    
    void pop() {
        if(_st.top() == _minst.top())
            _minst.pop();
        _st.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _minst.top();
    }
    stack<int> _st;
    stack<int> _minst;
};

3. 根据逆波兰表示法，求表达式的值。有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。OJ链接

思路：
利用栈来实现，遍历给定字符串，若遇到的字符串为操作符取栈数据进行运算，遇到的字符为操作数则入栈。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto& str : tokens)
        {

            if(str == "+" || str == "-" || str == "*" || str == "/")
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                switch(str[0])
                {
                    case '+':
                        st.push(left + right);
                        break;                    
                    case '-':
                        st.push(left - right);
                        break;                    
                    case '*':
                        st.push(left * right);
                        break;
                    case '/':
                        st.push(left / right);
                        break;
                }
            }
            else
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

4. 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。OJ链接

思路：
1. 不管底层用什么结构实现，永远保证数据先进先出的一个逻辑数据结构，即队列
2. 创建栈s1和s2,入队直接在栈s1进行入队操作，
3. 出队时，若s2不空，直接出栈即是出队，若s2已为空，则把栈st1里面的所有数据导入s2
4. 获取队头元素时，若s2不空，就去栈顶元素即为队头，若为空，则需要把栈s1里面的所有数据导入s2
5. 判断队列是否为空，需要满足两个栈都为空时整个队列才为空

class MyQueue {
public:
    /** Initialize your data structure here. */
    MyQueue() {}
    
    /** Push element x to the back of queue. */
    void push(int x) {
        s1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        checkstack();
        int x = s2.top();
        s2.pop();
        return x;
    }
    
    /** Get the front element. */
    int peek() {
        checkstack();
        return s2.top();
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return s1.empty() && s2.empty();
    }

    void checkstack()
    {
        if (s2.empty())
        {
            while (!s1.empty())
            { 
                s2.push(s1.top());
                s1.pop();
            }
        }
    }
private:
    stack<int> s1;
    stack<int> s2;
};