C++一个数组实现两个栈

方案一：将数组的下标为0的位置当做第一个栈的栈底，下标为1的位置当做第二个栈的栈底，将数组的偶数位置看做第一个栈的存储空间，奇数位置看做第二个栈的存储空间。

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

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

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

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

#define _CRT_SECURE_NO_WARNINGS 1


#include<iostream>
#include<stdlib.h>


using namespace std;
template<class T>
class TwoStack
{
public:
TwoStack()
:_a(NULL)
, _top1(0)
, _top2(0)
, _capacity(0)
{
_CheckCapacity();
}
~TwoStack()
{
if (_a)
delete[] _a;
}
void Push1(const T& d)
{
_CheckCapacity();
_a[_top1++] = d;
}
void Push2(const T& d)
{
_CheckCapacity();
_a[_top2--] = d;
}
void Pop1()
{
if (_top1 > 0)
--_top1;
}
void Pop2()
{
if (_top2 < _capacity - 1)
_top2++;
}
size_t Size1()
{
return _top1;
}
size_t Size2()
{
return _capacity - 1 - _top2;
}
bool Empty1()
{
return _top1 == 0;
}
bool Empty2()
{
return _top2 == _capacity - 1;
}
T& Top1()
{
if (_top1>0)
{
return _a[_top1 - 1];
}
}
T& Top2()
{
if (_top2 < _capacity - 1)
return _a[_top2 + 1];
}


private:
void _CheckCapacity()
{
if (_a == NULL)
{
_capacity += 3;
_a = new T[_capacity];
_top2 = _capacity - 1;
return;
}
if (_top1 == _top2)//栈顶相遇则扩容
{
size_t OldCapacity = _capacity;
_capacity = _capacity * 2;
T* tmp = new T[_capacity];


for (size_t i = 0; i < _top1; i++)
{
tmp[i] = _a[i];
}
for (size_t j = OldCapacity - 1, i = _capacity - 1; j>_top2; j--, i--)//把老数组的值赋给新数组
{
tmp[i] = _a[j];
}
delete[] _a;//释放老数组
_a = tmp;
_top2 += _capacity / 2;
}
}


private:
T* _a;//数组
size_t _top1;//第一个栈的栈顶
size_t _top2;//第二个栈的栈顶
size_t _capacity;//容量
};


void TestTwoStack()
{
TwoStack<int> s;
s.Push1(1);
s.Push1(2);
s.Push1(3);
s.Push1(4);
s.Push1(5);
s.Push2(1);
s.Push2(2);
s.Push2(3);
s.Push2(4);
s.Push2(5);
cout << "s1:" << s.Size1() << endl;;
cout << "s2:" << s.Size2() << endl;
while (!s.Empty1())
{
cout << s.Top1() << endl;
s.Pop1();
}
cout << endl;
while (!s.Empty2())
{
cout << s.Top2() << endl;
s.Pop2();
}
}


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

代码运行结果：