两栈共享空间

大话数据结构：打个比方，两个大学室友毕业同时到北京工作，开始时，他们觉得住了这么多年的集体宿舍，现在工作了一定要有自己的私密空间。于是他们都希望租房时能租到独住的一居室，可找来找去才发现，最便宜的一居室要1500，地段还不好，实在是承受不起，最终他们两还是合租了一套两居室，一共2000各出一半还不错。
对于两个一居室都有独立的卫生室和厨房，是私密了，但大部分空间的利用率却不高。而两居室，两个人各有卧室，还共享了客厅，厨房，卫生间，房间的利用率就显著提高，而且租房的成本也大大下降。

/*
使用前提：相同数据类型的两个栈，最好一方减少，另外一方随之增加
*/

const   int  MAXSIZE = 20;

template <typename  T>
class  Sharestack
{
public:
    Sharestack()
    {
        data = new  T[MAXSIZE]();
        top0 = -1;
        top1 = MAXSIZE;
    }
    Sharestack(const  Sharestack & rhs)
    {
        data = new  T[MAXSIZE]();
        top0 = rhs -> top0;
        top1 = rhs -> top1;
        memcpy(data,rhs->data,sizeof(T)*MAXSIZE);
    }
    ~Sharestack()
    {
        delete [] data;
        data = NULL;
    }

    bool Empty(bool stackNumber)
    {
        if(!stackNumber)
        {
            if(top0 == -1)
            {
                return 1;
            }
        }

        if(stackNumber == 1)
        {
            if(top == MAXSIZE)
            {
                return 1;
            }
        }
        return 0;
    }

    bool Full()
    {
        return top0 + 1 == top1;
    }

    void Push(T val,bool stackNumber)
    {
        if(Full())
        {
            throw  std::exception("Stack  is  Full !");
        }
        if(!stackNumber)
        {
            data[++top0] = val;
        }
         if(stackNumber)
        {
            data[--top1] = val;
        }
    }

    void Pop(bool stackNumber)
    {
        if(Empty(stackNumber))
        {
            throw  std::exception("Stack  is Empty!");
        }
        if(!stackNumber)
        {
            --top0;
        }
        if(stackNumber)
        {
            ++top1;
        }
    }

    T  top(bool stackNumber)
    {
        if(Empty(stackNumber))
        {
             throw  std::exception("Stack  is Empty!");
        }
        if(!stackNumber)
        {
            data[top0];
        }
        if(stackNumber)
        {
            data[top1];
        }
    }
    
    int Size (bool stackNumber)
    {
        if(!stackNumber)
        {
           return top0+1;
        }
        if(stackNumber)
        {
            return MAXSIZE - top1;
        }
    }

    void Clear(bool stackNumber)
    {
        if(!stackNumber)
        {
            top0 == -1;
        }
        if(stackNumber)
        {
            top1 == MAXSIZE;
        }
    }
    void  Show(bool stackNumber)
    {
        if(!stackNumber)
        {
             std::cout<<"stack-0:  ";
            for(int i = 0;i <= top0;++i)
            {
                std::cout<<data[i]<<"-";
            }
            std::cout<<std::endl;
        }
        if(stackNumber)
        {
            std::cout<<"stack-1:  ";
            for(int i = MAXSIZE-1;i >= top1;--i)
            {
                std::cout<<data[i]<<"-";
            }
            std::cout<<std::endl;
        }
    }
private:
    T *data;
    int top0;
    int top1;
};


int main()
{
    Sharestack<int> sta;
    for(int i = 0;i <= 8;i++)
    {
        sta.Push(i,0);
        sta.Push(i,1);
    }
    sta.Show(0);
    sta.Show(1);
}

事实上，使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时，也就是一个栈增长时另外一个栈缩短。就像买股票，你买入时，一定是有一个你不知道的人卖出。有人赚钱，就一定有人赔钱。这样使用两栈共享的空间存储办法才有较大意义，否则两个栈都在不停的增长，那很快就会因为栈满而溢出了。
当然这只是指针两个具有相同数据类型设计上的一个技巧，如果是不相同数据类型的栈，这种办法不但不能很好的处理问题，反而会使问题变得更复杂，大家要注意这个问题。