一个数组实现两个栈

【面试题】一个数组实现两个栈
思路一：在数组中，一个栈从左往右增长，另一个栈从右往左增长。
思路二：采用交叉索引法，1号栈所占数组索引1，3，5，7.....;2号栈所占数组索引2，4，6，8.......
思路一必须给定数组长度，不易动态增长，但可通过扩容实现动态增长。
思路二比思路一容易动态增长，但空间利用率低，对两个栈实现了公平。
思路一的实现如下：

)
, _size(size)
, _capacity(size)
{}
~TwoStack()
{
if (_arr)
{
delete[] _arr;
}
}
public:
//indx判断需要进行插入、删除等操作的栈是哪个栈,设置indx为0时是_stack1,为1时是_stack2
void CheckCapacity();
void Push(size_t indx, const T& x);
void Pop(size_t indx);
bool Empty(size_t indx);
size_t Size(size_t indx);
T& Top(size_t indx);
void PrintArr();
private:
size_t _stacktop1;//栈1栈顶位置
size_t _stacktop2;//栈2栈顶位置
T* _arr;
size_t _size;
size_t _capacity;
};
template<class T>
void TwoStack<T>::CheckCapacity()
{
if (_stacktop1 - 1 == _stacktop2)//当发生交叉时，则数组已满
{
_capacity = 2 * _capacity + 3;
T* tmp = new T[_capacity];
for (size_t i = 0; i < _stacktop1; i++)
{
tmp[i] = _arr[i];
}
for (size_t i = 1; i < _size - _stacktop2; i++)//_size - _stacktop2 - 1为栈2的大小
{
tmp[_capacity - i] = _arr[_size - i];
}
delete[] _arr;
_arr = tmp;
_size = _capacity;//更新数组大小
_stacktop2 = _size - _stacktop2 - 1;//更新栈2的栈顶位置,指向下一个栈存放的下标
}
}
template<class T>
void TwoStack<T>::Push(size_t indx, const T& x)
{
CheckCapacity();
if (indx == 0)
{
_arr[_stacktop1] = x;
_stacktop1++;
}
if (indx == 1)
{
_arr[_stacktop2] = x;
_stacktop2--;
}
}
template<class T>
void TwoStack<T>::Pop(size_t indx)
{//注意在入栈后_stacktop1和_stacktop2指向即将下一个进栈的位置
assert(_size);
if (indx == 0)
{
if (_stacktop1 == 0)
{
cout << ]思路二的实现如下：
template<class T>
class TwoStack
{
public:
TwoStack()
:_stacktop1(-1)
, _stacktop2(-2)
, _array(new T[MAX_SIZE])
{}
~TwoStack()
{
if (_array)
{
delete[] _array;
}
}
public:
//indx判断需要进行插入、删除等操作的栈是哪个栈,设置indx为1时是_stack1,为0时是_stack2
void Push(size_t indx, const T& x);
void Pop(size_t indx);
bool Empty(size_t indx);
size_t Size(size_t indx);
T& Top(size_t indx);
void PrintArr();
private:
int _stacktop1;//栈1栈顶位置
int _stacktop2;//栈2栈顶位置
T* _array;
};
template<class T>
void TwoStack<T>::Push(size_t indx, const T& x)
{
if (indx == 1)
{
if (_stacktop1 + 2 >= MAX_SIZE)
{
cout << "Stack1 is full!" << endl;
}
else
{
_stacktop1 += 2;
_array[_stacktop1] = x;
}
}
if (indx == 0)
{
if (_stacktop2 + 2 >= MAX_SIZE)
{
cout << "Stack2 is full!" << endl;
}
else
{
_stacktop2 += 2;
_array[_stacktop2] = x;
}
}
}
template<class T>
void TwoStack<T>::Pop(size_t indx)
{
if (indx == 1)
{
if (_stacktop1 < 0)
{
cout << "Stack1 is empty!" << endl;
}
else
{
_stacktop1 -= 2;
}
}
if (indx == 0)
{
if (_stacktop1 < 1)
{
cout << "Stack2 is empty!" << endl;
}
else
{
_stacktop2 -= 2;
}
}
}
template<class T>
bool TwoStack<T>::Empty(size_t indx)
{
if (indx == 1)
{
return _stacktop1 == 0;
}
if (indx == 0)
{
return _stacktop2 == 1;
}
}
template<class T>
size_t TwoStack<T>::Size(size_t indx)
{
if (indx == 1)
{
return (_stacktop1 + 1) / 2;
}
if (indx == 0)
{
return (_stacktop2 + 2) / 2;//由于_stacktop2为奇数，且/运算，故+2
}
}
template<class T>
T& TwoStack<T>::Top(size_t indx)
{
if (indx == 1)
{
return _array[_stacktop1];
}
if (indx == 0)
{
return _array[_stacktop2];
}
}
template<class T>
void TwoStack<T>::PrintArr()
{
if (Empty(0))
{
cout << "Stack1 is empty!" << endl;
}
else if(Empty(0))
{
cout << "Stack2 is empty!" << endl;
}
else
{
cout << "Stack1:";
for (int i = 1; i <= _stacktop1; i += 2)
{
cout << _array[i]<<"  ";
}
cout << '\n' << "Stack2:";
for (int i = 0; i <= _stacktop2; i += 2)
{
cout << _array[i]<<"  ";
}
cout << endl;
}
}
测试用例如下：
void Test()
{
TwoStack<string> s1;
s1.Push(1, "aaaaa");
s1.Push(1, "bbbbb");
s1.Push(1, "lllll");
s1.Push(0, "yyyyy");
s1.Push(0, "fffff");
s1.Push(0, "ggggg");
s1.PrintArr();

s1.Pop(1);
s1.PrintArr();
s1.Pop(0);
s1.PrintArr();
cout << "empty: "<<s1.Empty(1) << "----" << s1.Empty(0) << endl;
cout << "size: " << s1.Size(1) << "----" << s1.Size(0) << endl;
cout << "top: " << s1.Top(1) << "----" << s1.Top(0) << endl;
s1.Pop(1);
s1.Pop(1);
s1.Pop(1);
s1.PrintArr();
}

在面试时，由于时间紧迫，我们可以不用实现动态的，只需实现静态的数组，并实现push()和pop().

本文出自 “Scen” 博客，请务必保留此出处http://10741357.blog.51cto.com/10731357/1762157