一，用一個數組實現兩個棧（先進後出），有以下幾種方法：
①陣列的奇數位置儲存一個棧的元素，偶數位置儲存另一個棧的元素；

②兩個棧分別從陣列的中間向兩頭增長； 陣列的中間位置看做兩個棧的棧底，壓棧時棧頂指標分別向兩邊移動，當任何一邊到達陣列的起始位置或是陣列尾部，則開始擴容

③兩個棧分別從陣列的兩頭開始增長。 將陣列的起始位置看作是第一個棧的棧底，將陣列的尾部看作第二個棧的棧底， 壓棧時，棧頂指標分別向中間移動，直到兩棧頂指標相遇，則擴容

二、圖說

經過分析，前邊兩種方法在一定的情況下會造成空間的浪費，採用第三種方式完成。

三、下邊給出程式碼實現：

#include<iostream>
 

using namespace std;
#include<stdlib.h>

template<typename T>
class StackArray
{
public: 
    StackArray()//構造
        : _array(new int [2])
        , _size1(0)
        , _size2(1)
        , _capacity(2)
    {}
    ~StackArray()//析構
    {
        if (NULL != _array)
        {
            delete
 
[] _array;
            _array = NULL;
            _size1 = 0;
            _size2 = 0;
            _capacity = 0;
        }
    }

    void PushArr1(const T& x)//棧1插入
    {
        Capacity();
        _array[_size1] = x;
        _size1++;
    }
    void PushArr2(const T& x)//棧2插入
    {
        Capacity();
        _array[_size2] = x;
        _size2--;
    }

    void
 
 PopArray1()//棧1刪除
    {
        if (_size1 > 0)
        {
            _size1--;
        }
    }
    void PopArray2()//棧2刪除
    {
        if (_size2 != _capacity-1)
        {
            _size2++;
        }
    }
    T& TopArray1()//棧1棧頂元素
    {
        if (_size1 > 0)
        {
            return _array[_size1-1];
        }
    }
    T& TopArray2()//棧2棧頂元素
    {
        if (_size2 > 0)
        {
            return _array[_size2+1];
        }
    }
    int Size1()//元素個數
    {
        return _size1;
    }
    int Size2()
    {
        return _capacity -1- _size2;
    }
    bool Empty1()//空
    {
        return _size1 == 0;
    }
    bool Empty2()
    {
        return _size2 == _capacity - 1;
    }
    void DisplayArray1()//列印棧1元素
    {
        if (_size1 > 0)
        {
            for (int i = _size1 - 1; i >= 0; --i)
            {
                cout << _array[i] << " ";
            }
            cout << endl;
        }
    }
    void DisplayArray2()//列印棧2元素
    {
        if (_size2 > 0)
        {
            for (int i = _size2 + 1 ; i <_capacity; ++i)
            {
                cout << _array[i] << " ";
            }
            cout << endl;
        }
    }
private:
    void Capacity()//增容
    {
        if ( (Size1()+Size2()) >= _capacity)
        {
            int NewCapacity = _capacity *2;
            T* tmp = new T[NewCapacity];
            int k = NewCapacity - 1;
            //memcpy(tmp, _array1, _size1*sizeof(T));
            for (int i = 0; i < _size1; ++i)
            {
                tmp[i] = _array[i];
            }
            //memcpy(tmp+NewCapacity-1-_size2,_array2-_size2,_size2*sizeof(T));
            for (int i = _capacity-1; i > _capacity-_size2; --i)
            {
                tmp[k] = _array[i];
                k--;
            }
            delete[] _array;
            _size2 = NewCapacity - (_capacity - _size2);

            _capacity = NewCapacity;
            _array = tmp;
        }
    }
private:
    T*  _array;//陣列
    int _size1;//棧1的棧頂在陣列中的下標
    int _size2;//棧2的棧頂在陣列中的下標
    int _capacity;//陣列大小
};
//測試程式碼
void test()
{
    StackArray<int> s;
    s.PushArr1(1);
    s.PushArr1(2);
    s.PushArr1(3);
    s.PushArr1(4);
    s.PushArr1(5);
    s.PushArr1(6);
    s.PushArr1(7);
    s.DisplayArray1();
    s.PopArray1();
    s.DisplayArray1();
    cout<<"Stack1 Top:"<<s.TopArray1()<<endl;
    cout<<"Stack1 Size:"<<s.Size1()<<endl;

    cout<<endl;

    s.PushArr2(7);
    s.PushArr2(8);
    s.PushArr2(9);
    s.PushArr2(10);
    s.DisplayArray2();
    s.PopArray2();
    s.DisplayArray2();
    cout<<"Stack2 Top:"<<s.TopArray2()<<endl;
    cout<<"Stack2 Size:"<<s.Size2()<<endl;
}
int main()
{
    test();
    system("pause");
    return 0;
}

四：執行結果

五、在實現過程中，需要注意幾個問題：
1._size1和_size2分別指向棧頂元素的下一個位置。
2.內容複製過程中需要考慮對特殊型別比如string型別的特殊 處理。
3.仔細認真的保證各個判斷條件準確無誤。