一个数组实现两个栈

用一个数组实现两个栈

方案一：奇偶下标依次存储

    将数组下标为0的位置作为第一个栈的栈底，下标为1的位置作为第二个栈的栈底，将整个数组中偶数下标部分依次存储在第一个栈中，将数组中奇数下标部分依次存储在第二个栈中。

方案二：从中间分别向两边压栈

    将数组的中间位置看做两个栈的栈底，压栈时栈顶分别向两边移动，当任何一边到达数组的起始位置或是数组的最后位置，则扩容。

方案三：从两边向中间压栈

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

PS：

   所以三种方案，第三种较好，无空间浪费，此处实现方案三。

代码实现如下：

#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;    //栈2从数组最后开始依次向前压数据
	}

	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()    //栈1的元素个数
	{
		return _top1;
	}

	size_t Size2()    //栈2的元素个数
	{
		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;    //容量
};

#include "TwoStack.h"

void TestTwoStack()
{
	TwoStack<int> qq;
	qq.Push1(1);
	qq.Push1(2);
	qq.Push1(3);
	qq.Push1(4);
	qq.Push1(5);
	qq.Push1(6);

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

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

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

	cout << "Empty1:" << qq.Empty1() << endl;
	cout << "Empty1:" << qq.Empty2() << endl;

	qq.Print();
}

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