一个数组实现两个栈

一个数组实现两个栈，共有三个思路
1.奇偶法

2.从中间分别向两边压栈

3.从两边向中间压栈
将数组的起始位置看做第一个栈的栈底，将数组的尾部看做第二个栈的栈底，压栈时，栈顶分别向中间位置移动，直到两个栈顶相遇，则扩容。

第三种 最节省空间，不会造成空间浪费，所以代码实现只实现这一种

#include <iostream>  
#include <Windows.h>  

using namespace std;  

//一个数组实现两个栈  
template <class T>  
class TwoStack  
{  
public:  
    TwoStack()  
        :_arr(NULL)  
        , _top1(0)  
        , _top2(0)  
        , _capacity(0)  
    {  
        _CheckCapacity();      //增容  
    }  

    ~TwoStack()    //析构  
    {  
        if (_arr != NULL)  
        {  
            delete[] _arr;  
        }  
    }  

    void Push1(const T& data)    //入栈1  
    {  
        _CheckCapacity();      
        _arr[_top1++] = data;     
    }  

    void Push2(const T& data)    //入栈2  
    {  
        _CheckCapacity();  
        _arr[_top2--] = data;    
    }  

    void Pop1()    //栈1出栈  
    {  
        if (_top1 > 0)    //top1从数组下标为0的位置开始压栈，所以top1的数字同时可以代表栈1中的数据个数  
        {  
            --_top1;  
        }  
    }  

    void Pop2()    //栈2出栈  
    {  
        if (_top2 < _capacity - 1)     //top2压栈的第一个元素下标为_capacity-1,依次向前压栈  
        {  
            ++_top2;  
        }  
    }  

    T& Top1()     //栈1的栈顶  
    {  
        return _arr[_top1 - 1];  
    }  

    T& Top2()     //栈2的栈顶  
    {  
        return _arr[_top2 + 1];  
    }  

    bool Empty1()   //栈1判空  
    {  
        return _top1 == 0;  
    }  

    bool Empty2()    //栈2判空  
    {  
        return _top2 == _capacity - 1;  
    }  

    size_t Size1()      
    {  
        return _top1;  
    }  

    size_t Size2()      
    {  
        return _capacity - 1 - _top2;  
    }  

    void Print()    //打印  
    {  
        while (Size1() != 0)  
        {  
            cout << Top1() << " ";  
            Pop1();  
        }  
        cout << endl;  

        while (Size2() != 0)  
        {  
            cout << Top2() << " ";  
            Pop2();  
        }  
        cout << endl;  
    }  

protected:  
    void _CheckCapacity()    //检查容量  
    {  
        if (_arr == NULL)  
        {  
            _capacity = _capacity + 3;  
            _arr = new T[_capacity];  
            _top2 = _capacity - 1;  
            return;  
        }  
        if (_top1 == _top2)   //两个栈顶相遇，需要增容  
        {  
            T OldCapacity = _capacity;    //先将现有数据保存  
            _capacity = _capacity * 2;  
            T* temp = new T[_capacity];  
            for (size_t i = 0; i < _top1; ++i)     //top1依次放入对应下标即可  
            {  
                temp[i] = _arr[i];  
            }  
            for (size_t j = OldCapacity - 1, i = _capacity - 1; j > _top2; --i, --j)  
            {  
                temp[i] = _arr[j];  
            }  
            delete[] _arr;    //释放旧空间  
            _arr = temp;  
            _top2 = _capacity - 1;  
        }  
    }  

protected:  
    T* _arr;     //数组  
    size_t _top1;       //栈1的栈顶  
    size_t _top2;       //栈2的栈顶  
    size_t _capacity;    //容量  
};  
void TestTwoStack()  
{  
    TwoStack<int> q;  
    q.Push1(1);  
    q.Push1(2);  
    q.Push1(3);  
    q.Push1(4);  
    q.Push1(5);  
    q.Push1(6);  

    q.Push2(1);  
    q.Push2(2);  
    q.Push2(3);  
    q.Push2(4);  

    cout << "Size1:" << q.Size1() << endl;  
    cout << "Size2:" << q.Size2() << endl;  

    cout << "Top1:" << q.Top1() << endl;  
    cout << "Top2:" << q.Top2() << endl;  

  /*  cout << "Empty1:" << q.Empty1() << endl;  
    cout << "Empty2:" << q.Empty2() << endl;  */

    q.Print();  
}  

int main()  
{  
    TestTwoStack();  
    system("pause");  
    return 0;  
}