（1）225用栈实现队列–简单

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

class MyStack {
public:
    MyStack() {

    }
    //push用临时队列实现，要push的元素先放到临时队列的队头，再把队中原有的后续元素接入到后面。
    void push(int x) {
        if(queue1.empty()) {
            queue1.push(x);
            return;
        }
        std::queue<int> queue_tmp;
        queue_tmp.push(x);
        while( !queue1.empty() ){
            int x = queue1.front();
            queue1.pop();
            queue_tmp.push(x);
        }
        while( !queue_tmp.empty()){
            int x = queue_tmp.front();
            queue_tmp.pop();
            queue1.push(x);
        }
    }
    
    int pop() {
        int x = queue1.front();
        queue1.pop();
        return x;
    }
    
    int top() {
        return queue1.front();
    }
    
    bool empty() {
        return queue1.empty();
    }
private:
    std::queue<int> queue1;
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

（2）232用栈实现队列–简单

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

class MyQueue {
private:
    stack<int> _data;

public:
    
    MyQueue() {

    }
    
    void push(int x) {
        if(_data.empty()) {
            _data.push(x);
            return;
        }
        //临时栈，要插入的元素先放入临时栈
        std::stack<int> temp_stack;
		//
        while( !_data.empty() ){
            int i = _data.top();
            temp_stack.push(i);
            _data.pop();
        }
        //最后插入的元素放在临时栈顶
        temp_stack.push(x);
        //将临时栈转换到原来的栈，栈顶元素变到栈低
        while(!temp_stack.empty()){
            int i = temp_stack.top();
            _data.push(i);
            temp_stack.pop();
        }
        
    }
    
    int pop() {

        int x = _data.top();
        _data.pop();
        return x;
    }
    
    int peek() {
        return _data.top();
    }
    
    bool empty() {
        return _data.empty();
    }


};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

（3）155最小栈–中等

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

class MinStack {
private:
//用一个临时最小值栈记录各个元素为栈顶时的最小值，与data栈同步
    stack<int> record_min;
    stack<int> _data;

public:

    MinStack() {

    }
    
    void push(int val) {
        if(_data.empty()) {
            _data.push(val);
            record_min.push(val);
            return;
        }
        _data.push(val);
        int x = record_min.top();
        if(val<x) record_min.push(val);
        else record_min.push(x);
        
    }
    
    void pop() {
        _data.pop();
        record_min.pop();
    }
    
    int top() {
        return _data.top();
    }
    
    int getMin() {
        return record_min.top();
    }
};

/**
 * 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();
 */

（4）224基本计算器–困难

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。

#include<iostream>
#include <string>
#include <sstream>
using namespace std;
class Solution {
private:
    stack<int> number_stack;
    stack<int> op_stack;
public:
    int cal(int a, int b ,char op){
        if(op == 43) {
            //cout<< " "<< a << "+" << b ;//<< endl;
            return (a + b);
        }
        else if(op == 45) {  
            //cout<< " "<< a << "-" << b ;//<< endl;
            return (a - b);
        }
        return 0;
    }

    int calculate(string s) {
        //仅有一个数字
        //cout<< s.length() << endl;
        if(s.length()<=2) {
            int tmp;
            stringstream ss;
            ss << s[0];
            ss >> tmp;
            return tmp;
        }
        int a;
        int b;
        int calculateMark = 0;
        int numberMark = 0;//标志连续输入了几个数字，连续输入的数字被合并成一个数字
        int beginFlag1 = 1;//起始输入flag1为1
        int beginFlag2 = 0;//前括号后的输入flag2为1
        for(int i = 0; i<s.length(); i++){
            if(i > 0) beginFlag1 = 0;
            //cout<< "s[i] = " << s[i] ;//<< endl;
            if(s[i] == 32) {
                //cout<< "SPACE continue" << endl;
                continue;
            }

            //如果是数字
            else if(s[i]<=57&&s[i]>=48){
                //如果可以计算了
                beginFlag1 = 0;
                beginFlag2 = 0;
                //cout << " " << i <<" numberMark="<< numberMark;
                if(numberMark == 0){
                    //前面没有已经输入的数字（非连续输入的数字），直接push
                    int tmp;
                    stringstream ss;
                    ss << s[i];
                    ss >> tmp;
                    number_stack.push(tmp);
                    numberMark += 1;//已经输入了一个数字
                    //cout<< " pushed" << endl;
                }
                else{
                    a = number_stack.top();
                    //cout <<" a= "<< a;
                    number_stack.pop();
                    string tmp;
                    //判断+或-
                    stringstream ss;
                    ss << a;
                    ss >> tmp;
                    //cout << " " << tmp <<"->" ;
                    tmp = tmp+s[i];//与前面的字符串合并
                    //cout<<tmp;
                    int c;
                    //同一stream进行多次转换应调用成员函数clear
                    ss.clear();
                    ss << tmp;
                    ss >> c;
                    number_stack.push(c);//重新push到栈中
                    //cout << " " << c << "pushed "<< endl;

                }
                
            }
            //如果是前括号，直接push，calculateMark置0
            else if(s[i] == 40) {
                op_stack.push(s[i]);
                calculateMark = 0;
                numberMark = 0;
                //cout<< " pushed level_flag=" << level_flag << " pushed" << endl;
                beginFlag2 = 1;
                //level.push(level_flag);
                //level_flag = 0;
                
            }

            //如果是后括号
            else if(s[i] == 41){
                numberMark = 0;
                beginFlag2 = 0;
                //如果括号内有可计算的表达式
                if(op_stack.top() != 40){
                        //计算括号内的表达式
                    b = number_stack.top();
                    number_stack.pop();
                    a = number_stack.top();
                    number_stack.pop();
                    //判断+或-
                    //cout << " a="<< a<< " b="<<b <<" op="<< op_stack.top()<<" ";
                    
                    number_stack.push(cal(a, b, op_stack.top()));
                    op_stack.pop();
                    //calculateMark = 0;
                    //cout<< " "<< op_stack.top() << " poped " << endl ;
                }
                
                op_stack.pop();//弹出前括号
                //如果符号栈非空
                if( !op_stack.empty() && (!(op_stack.top() == 40))) calculateMark = 1;
                else calculateMark = 0;
                
            }
            //如果是其它符号（加或者减），push,calculateMark置1
            else {
                //如果未输入数字就输入加或减，会被认为是数符
                if( beginFlag1 || beginFlag2 ){
                    //cout<< " " <<s[i+1] << "->" ;
                    number_stack.push(0);
                    op_stack.push(s[i]);

                    calculateMark = 1;
                    numberMark = 0;
                    beginFlag2 = 0;
                    
                }
                //如果运算标识符为1，表示前面已经有表达式可以计算了，计算完再push当前运算符
                //运算标识符不变
                
                else if (calculateMark == 1){
                    b = number_stack.top();
                    number_stack.pop();
                    a = number_stack.top();
                    number_stack.pop();
                    
                    //cout << " a="<< a<< " b="<<b <<" op="<< op_stack.top()<<" ";
                    //std::istringstream(s[i]) >> tmp;
                    //cout<< " "<< a << op_stack.top() << tmp << endl;
                    //判断+或-
                    number_stack.push(cal(a, b, op_stack.top()));
                    op_stack.pop();
                    op_stack.push(s[i]);
                    calculateMark = 1;
                    //cout<< " pushed" ;//<< endl;
                    numberMark = 0;
                    
                }
                //如果运算标识符为0，表示前面没表达式可以计算直接push当前运算符
                //运算标识符置1
                else {
                    op_stack.push(s[i]);
                    calculateMark = 1;
                    //cout<< " pushed" ;//<< endl;
                    numberMark = 0;
                }
                
                //cout << " calculateMark ="<< calculateMark<<" "<< endl;
            }
                
        }
        if( !op_stack.empty() ){
            b = number_stack.top();
            number_stack.pop();
            a = number_stack.top();
            number_stack.pop();
            
            //cout << " a="<< a<< " b="<<b <<" op="<< op_stack.top()<<" ";
            //std::istringstream(s[i]) >> tmp;
            //cout<< " "<< a << op_stack.top() << tmp << endl;
            //判断+或-
            number_stack.push(cal(a, b, op_stack.top()));
        }
        return number_stack.top();
    }
};