一个数组实现两个栈

分析：

用一个数组实现两个栈有三种思路：

（1）将数组按照奇、偶为分成两组

（2）将数组按照从两边到中间分成两组

（3）将数组按照从中间到两边分成两组

比价上面三种思路，第一种和第三种虽然也可以实现，但对比第二种来看空间利用率还是明显不好，因为在一个数组中我们实现的两个栈并不一定每次就是等大的，而一旦一个栈满了就要涉及到开空间的问题，所以就会涉及到开空间的问题，下面主要以第二种思路为主

代码实现：

#include<iostream>
using namespace std;
#include<assert.h>

template<class T>
class DoubleStack
{
public:
	DoubleStack()
		: arr(NULL)
		, size(0)
		, capacity(0)
		, top1(0)
		, top2(0)
	{}

	~DoubleStack()
	{
		delete[] arr;
	}

	void Push(const T& data, int flag)
	{
		CheckCapacity();
		if (flag == 0)
		{
			arr[top1++] = data;
		}
		else
		{
			arr[top2--] = data;
		}
	}

	void Pop(int flag)
	{
		if (flag == 0)
		{
			assert(top1 > 0);
			top1--;
		}
		else
		{
			assert(top2 < size);
			top2++;
		}
	}

	int& Top(int flag)
	{
		if (flag == 0)
		{
			assert(top1 > 0);
			return arr[top1 - 1];
		}
		else(flag == 1)
		{
			assert(top2 < size);
			return arr[top2 + 1];
		}
	}

	void CheckCapacity()
	{
		if (top1 == top2)
		{
			size_t newCapacity = 2 * capacity + 5;
			T* tmp = new T[newCapacity];
			for (size_t i = 0; i < top1; ++i)
			{
				tmp[i] = arr[i];
			}

			int j = capacity - 1;
			for (size_t i = newCapacity - 1; j>top2; --i,--j)
			{
				tmp[i] = arr[j];
			}

			delete[] arr;
			arr = tmp;
			size_t count = 0;		//求出第二个栈元素的个数
			if (capacity != 0)
			{
				count = capacity - 1 - top2;
			}
			capacity = newCapacity;
			top2 = capacity - 1 - count;	//修改top2的值
			cout << capacity << endl;
		}
	}

protected:
	T* arr;
	size_t size;
	size_t capacity;
	int top1;
	int top2;
};

int main()
{
	DoubleStack<int> s;
	s.Push(1,1);
	s.Push(2,1);
	s.Push(3,1);
	s.Push(4,0);
	s.Push(5,0);
	s.Push(6,1);
	s.Push(7,0);
	s.Push(8,0);
	s.Push(9,0);

	system("pause");
	return 0;
}