//1.两个栈栈头在数组头尾(利用率高)
//2.两个栈栈头在数组中间(利用率低)
//3.奇偶下标分别为两栈(扩容时复制数据简单)
//实现1
template<class T>
class Stack
{
public:
	Stack()
		:_array(NULL)
		, _q1Size(0)
		, _q2Size(0)
		, _capacity(0)
	{}
	~Stack()
	{
		delete[] _array;
		_q1Size = _q2Size = _capacity = 0;
	}
	void Push1(const T& x)
	{
		_CheckCapacity();
		_array[_q1Size++] = x;
	}
	void Pop1()
	{
		if (_q1Size>0)
		  --_q1Size;
	}
	void Push2(const T& x)
	{
		_CheckCapacity();
		_array[_q2Size--] = x;
	}
	void Pop2()
	{
		if (_q2Size<_capacity-1)
		   ++_q2Size;
	}
	T& Top1()
	{
		assert(_q1Size > 0);
		return _array[_q1Size-1];
	}
	T&  Top2()
	{
		assert(_q2Size!=0||_q2Size!=_capacity-1);
		return _array[_q2Size+1];	
	}
protected:
	void _CheckCapacity()
	{
		if (_q1Size ==_q2Size)
		{
			int newCapacity = 2 * _capacity + 3;
			T* tmp = new T[newCapacity];
			if (_array)
			{
				int i = 0;
				for (i = 0; i <= _q1Size; ++i)
				{
					//类型萃取决定memcpy还是operator=
					tmp[i] = _array[i];
				}
				int j = newCapacity;
				//i控制循环次数,此时可改变_capacity
				for (;_capacity >= _q2Size; --j,  --_capacity)
				{
					tmp[j - 1] = _array[_capacity - 1];
				}
				_capacity = newCapacity;
				_q2Size = j+1;
			}
			else
			{
				_capacity = newCapacity;
				_q2Size = _capacity - 1;
			}
			swap(_array, tmp);
		}
	}
protected:
	T* _array;
	int _q1Size;//栈1头部下标
	int _q2Size;//栈2头部下标
	int _capacity;//数组大小
};
void Test1()
{
	Stack<int> s;
	s.Push1(1);
	cout << s.Top1() << endl;
	s.Push1(2);
	s.Push1(3);
	s.Push1(4);
	cout << s.Top1() << endl;
	s.Pop1();
	s.Pop1();
	s.Pop1();
	s.Pop1();
	s.Pop1();
	s.Pop1();
	//cout << s.Top1() << endl;

	s.Push2(5);
	s.Push2(6);
	s.Push2(7);
	s.Push2(8);
	cout << s.Top2() << endl;
	s.Pop2();
	s.Pop2();
	s.Pop2();
	s.Pop2();
	s.Pop2();
	//cout << s.Top2() << endl;

}