栈和队列面试题（一）---一个数组实现两个栈

一，用一个数组实现两个栈（先进后出），有以下几种方法：
①数组的奇数位置存储一个栈的元素，偶数位置存储另一个栈的元素；

②两个栈分别从数组的中间向两头增长； 数组的中间位置看做两个栈的栈底，压栈时栈顶指针分别向两边移动，当任何一边到达数组的起始位置或是数组尾部，则开始扩容

③两个栈分别从数组的两头开始增长。 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底， 压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容

二、图说

经过分析，前边两种方法在一定的情况下会造成空间的浪费，采用第三种方式完成。

三、下边给出代码实现：

#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.仔细认真的保证各个判断条件准确无误。