~一个数组实现两个栈（扩充版）~

栈和队列最常考的面试题之一：  一个数组实现两个栈

 

之前，我有一篇博客中写道一个数组实现两个栈的基本解题方法及各方法的优势，但遗憾的是没有代码实现，现在我就来实现代码。若有不懂解题方法的童鞋，可以查看我的这篇博客：http://blog.csdn.net/manongdeyipiant/article/details/70197180

在这里，我只实现方法1：栈顶指针从两边向中间生长，因为方法1较节省空间，但扩容时需要移动数据，浪费时间。

 

那就直入主题，完整的源代码及测试用例如下：

template <class T>
class Array_To_Two_Stack
{
public:
	//构造函数
	Array_To_Two_Stack()
		:_a(NULL)
		,_headTop(0)
		,_tailTop(0)
		,_capacity(0)
	{
		_CheckCapacity();
	}

	//析构函数
	~Array_To_Two_Stack()
	{
		if(_a)
		{
			delete[] _a;

			_a = NULL;
			_headTop = 0;
			_tailTop = 0;
			_capacity = 0;
		}
	}

	//头栈插入
	void Head_Push(const T& x)
	{
		_CheckCapacity();

		_a[_headTop++] = x;
	}

	//尾栈插入
	void Tail_Push(const T& x)
	{
		_CheckCapacity();

		_a[_tailTop--] = x;
	}

	//头栈删除
	void Head_Pop()
	{
		if(_headTop > 0)
		{
			--_headTop;
		}
	}

	//尾栈删除
	void Tail_Pop()
	{
		if(_tailTop < _capacity)
		{
			++_tailTop;
		}
	}

	//头栈判空
	bool Head_Empty()
	{
		return _headTop == 0;
	}

	//尾栈判空
	bool Tail_Empty()
	{
		return _tailTop == _capacity - 1;
	}

	//头栈大小
	size_t Head_Size()
	{
		return _headTop;
	}

	//尾栈大小
	size_t Tail_Size()
	{
		return _capacity - 1 - _tailTop;
	}

	//头栈栈顶
	T& Head_Top()
	{
		if(_headTop > 0)
		{
			return _a[_headTop - 1];
		}
	}

	//尾栈栈顶
	T& Tail_Top()
	{
		if(_tailTop < _capacity)
		{
			return _a[_tailTop + 1];
		}
	}

	//打印头栈元素
	void Head_Print()
	{
		for(size_t i = _capacity - 1; i > _tailTop; --i)
		{
			cout<<_a[i]<<" ";
		}

		cout<<endl;
	}

	//尾栈栈顶
	void Tail_Print()
	{
		for(size_t i = 0; i < _headTop; ++i)
		{
			cout<<_a[i]<<" ";
		}

		cout<<endl;
	}

protected:
	//增容
	void _CheckCapacity()
	{
		if(_a == NULL)
		{
			_capacity += 3;

			_a = new T[_capacity];
			_headTop = 0;
			_tailTop = _capacity - 1;

			return;
		}

		if(_headTop == _tailTop)
		{
			size_t old_capacity = _capacity;
			_capacity = _capacity * 2;
			T* tmp = new T[_capacity];

			for(size_t i = 0; i < _headTop; ++i)
			{
				tmp[i] = _a[i];
			}

			for(size_t j = old_capacity-1, i = _capacity-1; j > _tailTop; --j, --i)
			{
				tmp[i] = _a[j];
			}

			delete[] _a;
			_a = tmp;
			_tailTop += _capacity / 2;
		}
	}

protected:
	T* _a;
	int _headTop;
	int _tailTop;
	int _capacity;
};

void TestArray_To_Two_Stack()
{
	Array_To_Two_Stack<int> s;

	s.Head_Push(1);
	s.Head_Push(2);
	s.Head_Push(3);
	s.Head_Push(4);
	s.Tail_Push(1);
	s.Tail_Push(2);
	s.Tail_Push(3);
	s.Tail_Push(4);
	s.Head_Print();
	s.Tail_Print();

	s.Head_Pop();
	s.Head_Pop();
	s.Head_Pop();
	s.Tail_Pop();
	s.Tail_Pop();
	s.Tail_Pop();
	s.Head_Print();
	s.Tail_Print();

	cout<<"Head_Empty: "<<s.Head_Empty()<<endl;
	cout<<"Tail_Empty: "<<s.Tail_Empty()<<endl;

	cout<<"Head_Size: "<<s.Head_Size()<<endl;
	cout<<"Tail_Size: "<<s.Tail_Size()<<endl;

	cout<<"Head_Top: "<<s.Head_Top()<<endl;
	cout<<"Tail_Top: "<<s.Tail_Top()<<endl;
}