栈和队列

一、定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

class Solution {
public:
    void push(int value) {
        stackData.push(value);
        if(stackMin.empty() || value<=stackMin.top())
            stackMin.push(value);
        else if(value>stackMin.top())
            stackMin.push(stackMin.top());
    }
    void pop() {
        stackData.pop();
        stackMin.pop();
    }
    int top() {
        return stackData.top();
    }
    int min() {
        return stackMin.top();
    }
private:
    stack<int> stackData;
    stack<int> stackMin;
};

二、编写一个类,只能用两个栈结构实现队列,支持队列的基本操作(push，pop)。
给定一个操作序列ope及它的长度n，其中元素为正数代表push操作，为0代表pop操作，保证操作序列合法且一定含pop操作，请返回pop的结果序列。
测试样例：
[1,2,3,0,4,0],6
返回：[1,2]

class TwoStack {
public:
    vector<int> twoStack(vector<int> ope, int n) {
        stack<int> StackPush;    //push数据
        stack<int> StackPop;     //pop数据
        vector<int> result;
        for(int i = 0; i < n; ++i){         //将数据全部压入到StackPush
            if(ope[i]){
                StackPush.push(ope[i]);
            }
            else{
                if(StackPop.empty()){       //将StackPush中的数据全部倒入StackPop
                    while(!StackPush.empty()){
                        int temp = StackPush.top();
                        StackPush.pop();
                        StackPop.push(temp);
                    }
                }
                int tmp = StackPop.top();   //将StackPop中的数据弹出放入到vector向量中
                result.push_back(tmp);
                StackPop.pop();
            }
        }
        return result;
    }
};

三、实现一个栈的逆序，但是只能用递归函数和这个栈本身的pop操作来实现，而不能自己申请另外的数据结构。
给定一个整数数组A即为给定的栈，同时给定它的大小n，请返回逆序后的栈。
测试样例：
[4,3,2,1],4
返回：[1,2,3,4]

class StackReverse {
public:
    stack<int> s;
    vector<int> reverseStack(vector<int> A, int n) {
        reverse(A);
        return A;
    }
    void reverse(vector<int> &s){
        if(s.empty())
            return;
        int i=get(s);
        reverse(s);
        s.push_back(i);
    }
    int get(vector<int> &s){   //取得栈底元素
        int res=s.back();
        s.pop_back();
        if(s.empty())
            return res;
        else{
            int last=get(s);
            s.push_back(res);
            return last;
        }  
    }
};

四、请编写一个程序，按升序对栈进行排序（即最大元素位于栈顶），要求最多只能使用一个额外的栈存放临时数据，但不得将元素复制到别的数据结构中。
其中第一个元素为栈顶，请返回排序后的栈。请注意这是一个栈，意味着排序过程中你只能访问到第一个元素。
测试样例：
[1,2,3,4,5]
返回：[5,4,3,2,1]

class TwoStacks {
public:
    vector<int> twoStacksSort(vector<int> numbers) 
    {
       vector<int> help;
       while(!numbers.empty())
       {
         int current=numbers.back();
         numbers.pop_back();
         //help.back()>current按照从小到大输出；help.back()<current按从大到小输出
         while((!help.empty()) && help.back()>current)
         {
           numbers.push_back(help.back());
           help.pop_back();
         }
           help.push_back(current);
       }
       while(!help.empty())
       {
         numbers.push_back(help.back()); 
           help.pop_back();
       }
        return numbers;
    }
};