堆栈的一些小小的实践

/*只用一个数组实现三个栈*/
/*方法1，每个栈都有一个栈顶，三部分平分数组*/
#define SIZE 100
template<class T> class istack{
private:
    int size;
    T *buf;
    int stack_top[3];
public:
    istack(int i = 300){
        size = i;
        buf = new  T[i * 3];
        stack_top[0] = stack_top[1] = stack_top[2] = -1;
    }
    ~istack(){
        delete[]  buf;
    }
    void push(int stack_num, T n){
        int pos = stack_num*size + stack_top[stack_num] + 1;
        buf[pos] = n;
        stack_top[stack_num]++;
    }

    T pop(int stack_num){
        if (empty(stack_num))
            return NULL;
        stack_top[stack_num]--;

        int pos = stack_num*size + stack_top[stack_num]+1;
        return buf[pos];
    }
    int top(int stack_num){
        return stack_top[stack_num]+stack_num*size;
    }
    bool empty(int stack_num){
        return stack_top[stack_num] == -1;
    }
};
/*实现一个栈，除了push和pop操作，还要实现min函数以返回栈中的最小值。 push，pop和min函数的时间复杂度都为O(1)。*/
/*push的时候可以用一个变量来保存当前最小值，但是在pop时就比较麻烦，因为不知道pop之后的最小值*/
/*可以每一个结点中都push了这个结点时的最小值*/
/*但是这存在一个问题，有可能有数据冗余，多个结点的最小值都是相等的.
更好的解决办法是使用另一个小堆栈来存储最小值，每一次pop时都会与当前值进行比较*/
template<class T>class stack{
private:T* buf;
        int cur;
public:
    stack(int size=100){
        cur = -1;
        buf = new T[size];
    }
    ~stack(){
        delete[] buf;
    }
    void push(T number){
        buf[++cur] = number;
    }
    T pop(){
        return buf[cur--];
    }
    bool empty(){
        return cur == -1;
    }
    T top(){
        return buf[cur];
    }
};
class minstack{
private:
    stack<int> s, min;
public :
    void push(int num){
        s.push(num);
        if (!(num > min.top()))
            min.push(num);
    }
    int pop(){
        if (s.top() == min.top())
            min.pop();
        return s.pop();
    }
    bool empty(){
        return s.empty();
    }
    int min(){
        if (min.empty())
            return INT_MAX;
        return min.top();
    }
};
/*使用两个栈实现一个队列MyQueue。*/
/*思路是入队列时压入到A栈中，出队列时将B中的出栈，如果B为空，则将A出栈，压入B*/
template <class T>class queue_stack{
private:
    stack<T> src, dst;
public:
    void push(T val){
        src.push(val);
    }
    T pop(){
        if (dst.empty()){
            while (src.empty()){
                dst.push(src.pop());
            }
        }
        return dst.pop();
    }

};

/*写程序将一个栈按升序排序。对这个栈是如何实现的，你不应该做任何特殊的假设。 程序中能用到的栈操作有：push | pop | peek | isEmpty。*/
stack<int> Ssort(stack<int> s){
    stack<int> t;
    while (!s.empty()){
        int data = s.top();
        s.pop();
        while (!t.empty() && t.top()>data){
            s.push(t.top());
            t.pop();
        }
        t.push(data);
    }
    return t;
}
/*方案2：

使用一个优先队列来为出栈的元素排序，原栈中的元素不断出栈然后插入优先队列， 直到原栈为空。然后再将优先队列中的元素不断压回原栈，这样操作后， 栈中的元素便有序化了。

代码如下：
*/
#include <cstdlib>
#include <stack>
#include <queue>
#include<functional>
using namespace std;
void Qsort(stack<int> &s){
    priority_queue< int, vector<int>, greater<int> > q;
    while (!s.empty()){
        q.push(s.top());
        s.pop();
    }
    while (!q.empty()){
        s.push(q.top());
        q.pop();
    }
}